ZhouXY108/hutool
1
0
Fork 0
mirror of https://gitee.com/chinabugotech/hutool.git synced 2025-05-09 23:51:34 +08:00
Code Issues Packages Projects Releases Wiki Activity

[cleanup] erefactor/EclipseJdt - Remove trailing whitespace - All lines

Browse Source 
EclipseJdt cleanup 'RemoveAllTrailingWhitespace' applied by erefactor.

For EclipseJdt see https://www.eclipse.org/eclipse/news/4.19/jdt.php
For erefactor see https://github.com/cal101/erefactor
This commit is contained in:
cal101 2021-06-05 12:14:11 +00:00
parent f441b319da
commit 1a0a3d334d
20 changed files with 135 additions and 135 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
hutool-core/src/main/java/cn/hutool/core/io/resource/StringResource.java
View File

@ -6,7 +6,7 @@ import java.nio.charset.Charset;
/** /**
* 字符串资源，字符串做为资源 * 字符串资源，字符串做为资源
* *
* @author looly * @author looly
* @since 4.1.0 * @since 4.1.0
* @see CharSequenceResource * @see CharSequenceResource

18
hutool-core/src/main/java/cn/hutool/core/io/resource/UrlResource.java
View File

@ -16,10 +16,10 @@ import java.net.URL;
*/ */
public class UrlResource implements Resource, Serializable{ public class UrlResource implements Resource, Serializable{
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
protected URL url; protected URL url;
protected String name; protected String name;
//-------------------------------------------------------------------------------------- Constructor start //-------------------------------------------------------------------------------------- Constructor start
/** /**
* 构造 * 构造
@ -28,7 +28,7 @@ public class UrlResource implements Resource, Serializable{
public UrlResource(URL url) { public UrlResource(URL url) {
this(url, null); this(url, null);
} }
/** /**
* 构造 * 构造
* @param url URL，允许为空 * @param url URL，允许为空
@ -38,7 +38,7 @@ public class UrlResource implements Resource, Serializable{
this.url = url; this.url = url;
this.name = ObjectUtil.defaultIfNull(name, (null != url) ? FileUtil.getName(url.getPath()) : null); this.name = ObjectUtil.defaultIfNull(name, (null != url) ? FileUtil.getName(url.getPath()) : null);
} }
/** /**
* 构造 * 构造
* @param file 文件路径 * @param file 文件路径
@ -49,17 +49,17 @@ public class UrlResource implements Resource, Serializable{
this.url = URLUtil.getURL(file); this.url = URLUtil.getURL(file);
} }
//-------------------------------------------------------------------------------------- Constructor end //-------------------------------------------------------------------------------------- Constructor end
@Override @Override
public String getName() { public String getName() {
return this.name; return this.name;
} }
@Override @Override
public URL getUrl(){ public URL getUrl(){
return this.url; return this.url;
} }
@Override @Override
public InputStream getStream() throws NoResourceException{ public InputStream getStream() throws NoResourceException{
if(null == this.url){ if(null == this.url){
@ -67,7 +67,7 @@ public class UrlResource implements Resource, Serializable{
} }
return URLUtil.getStream(url); return URLUtil.getStream(url);
} }
/** /**
* 获得File * 获得File
* @return {@link File} * @return {@link File}
@ -75,7 +75,7 @@ public class UrlResource implements Resource, Serializable{
public File getFile(){ public File getFile(){
return FileUtil.file(this.url); return FileUtil.file(this.url);
} }
/** /**
* 返回路径 * 返回路径
* @return 返回URL路径 * @return 返回URL路径

4
hutool-core/src/main/java/cn/hutool/core/io/resource/WebAppResource.java
View File

@ -6,7 +6,7 @@ import cn.hutool.core.io.FileUtil;
/** /**
* Web root资源访问对象 * Web root资源访问对象
* *
* @author looly * @author looly
* @since 4.1.11 * @since 4.1.11
*/ */
@ -15,7 +15,7 @@ public class WebAppResource extends FileResource {
/** /**
* 构造 * 构造
* *
* @param path 相对于Web root的路径 * @param path 相对于Web root的路径
*/ */
public WebAppResource(String path) { public WebAppResource(String path) {

2
hutool-core/src/main/java/cn/hutool/core/io/resource/package-info.java
View File

@ -1,6 +1,6 @@
/** /**
* 针对ClassPath和文件中资源读取的封装，主要入口为工具类ResourceUtil * 针对ClassPath和文件中资源读取的封装，主要入口为工具类ResourceUtil
* *
* @author looly * @author looly
* *
*/ */

2
hutool-core/src/main/java/cn/hutool/core/io/unit/package-info.java
View File

@ -1,6 +1,6 @@
/** /**
* 数据单位相关封装，包括DataUnit数据单位和DataSize数据大小 * 数据单位相关封装，包括DataUnit数据单位和DataSize数据大小
* *
* @author looly * @author looly
* @since 5.3.10 * @since 5.3.10
*/ */

2
hutool-core/src/main/java/cn/hutool/core/io/watch/SimpleWatcher.java
View File

@ -9,5 +9,5 @@ import cn.hutool.core.io.watch.watchers.IgnoreWatcher;
* *
*/ */
public class SimpleWatcher extends IgnoreWatcher{ public class SimpleWatcher extends IgnoreWatcher{
} }

94
hutool-core/src/main/java/cn/hutool/core/io/watch/WatchUtil.java
View File

@ -12,14 +12,14 @@ import cn.hutool.core.util.URLUtil;
/** /**
* 监听工具类<br> * 监听工具类<br>
* 主要负责文件监听器的快捷创建 * 主要负责文件监听器的快捷创建
* *
* @author Looly * @author Looly
* @since 3.1.0 * @since 3.1.0
*/ */
public class WatchUtil { public class WatchUtil {
/** /**
* 创建并初始化监听 * 创建并初始化监听
* *
* @param url URL * @param url URL
* @param events 监听的事件列表 * @param events 监听的事件列表
* @return 监听对象 * @return 监听对象
@ -30,7 +30,7 @@ public class WatchUtil {
/** /**
* 创建并初始化监听 * 创建并初始化监听
* *
* @param url URL * @param url URL
* @param events 监听的事件列表 * @param events 监听的事件列表
* @param maxDepth 当监听目录时，监听目录的最大深度，当设置值为1（或小于1）时，表示不递归监听子目录 * @param maxDepth 当监听目录时，监听目录的最大深度，当设置值为1（或小于1）时，表示不递归监听子目录
@ -42,7 +42,7 @@ public class WatchUtil {
/** /**
* 创建并初始化监听 * 创建并初始化监听
* *
* @param uri URI * @param uri URI
* @param events 监听的事件列表 * @param events 监听的事件列表
* @return 监听对象 * @return 监听对象
@ -53,7 +53,7 @@ public class WatchUtil {
/** /**
* 创建并初始化监听 * 创建并初始化监听
* *
* @param uri URI * @param uri URI
* @param events 监听的事件列表 * @param events 监听的事件列表
* @param maxDepth 当监听目录时，监听目录的最大深度，当设置值为1（或小于1）时，表示不递归监听子目录 * @param maxDepth 当监听目录时，监听目录的最大深度，当设置值为1（或小于1）时，表示不递归监听子目录
@ -65,7 +65,7 @@ public class WatchUtil {
/** /**
* 创建并初始化监听 * 创建并初始化监听
* *
* @param file 文件 * @param file 文件
* @param events 监听的事件列表 * @param events 监听的事件列表
* @return 监听对象 * @return 监听对象
@ -76,7 +76,7 @@ public class WatchUtil {
/** /**
* 创建并初始化监听 * 创建并初始化监听
* *
* @param file 文件 * @param file 文件
* @param events 监听的事件列表 * @param events 监听的事件列表
* @param maxDepth 当监听目录时，监听目录的最大深度，当设置值为1（或小于1）时，表示不递归监听子目录 * @param maxDepth 当监听目录时，监听目录的最大深度，当设置值为1（或小于1）时，表示不递归监听子目录
@ -88,7 +88,7 @@ public class WatchUtil {
/** /**
* 创建并初始化监听 * 创建并初始化监听
* *
* @param path 路径 * @param path 路径
* @param events 监听的事件列表 * @param events 监听的事件列表
* @return 监听对象 * @return 监听对象
@ -99,7 +99,7 @@ public class WatchUtil {
/** /**
* 创建并初始化监听 * 创建并初始化监听
* *
* @param path 路径 * @param path 路径
* @param events 监听的事件列表 * @param events 监听的事件列表
* @param maxDepth 当监听目录时，监听目录的最大深度，当设置值为1（或小于1）时，表示不递归监听子目录 * @param maxDepth 当监听目录时，监听目录的最大深度，当设置值为1（或小于1）时，表示不递归监听子目录
@ -111,7 +111,7 @@ public class WatchUtil {
/** /**
* 创建并初始化监听 * 创建并初始化监听
* *
* @param path 路径 * @param path 路径
* @param events 监听事件列表 * @param events 监听事件列表
* @return 监听对象 * @return 监听对象
@ -122,7 +122,7 @@ public class WatchUtil {
/** /**
* 创建并初始化监听 * 创建并初始化监听
* *
* @param path 路径 * @param path 路径
* @param events 监听事件列表 * @param events 监听事件列表
* @param maxDepth 当监听目录时，监听目录的最大深度，当设置值为1（或小于1）时，表示不递归监听子目录 * @param maxDepth 当监听目录时，监听目录的最大深度，当设置值为1（或小于1）时，表示不递归监听子目录
@ -135,7 +135,7 @@ public class WatchUtil {
// ---------------------------------------------------------------------------------------------------------- createAll // ---------------------------------------------------------------------------------------------------------- createAll
/** /**
* 创建并初始化监听，监听所有事件 * 创建并初始化监听，监听所有事件
* *
* @param url URL * @param url URL
* @param watcher {@link Watcher} * @param watcher {@link Watcher}
* @return {@link WatchMonitor} * @return {@link WatchMonitor}
@ -143,10 +143,10 @@ public class WatchUtil {
public static WatchMonitor createAll(URL url, Watcher watcher) { public static WatchMonitor createAll(URL url, Watcher watcher) {
return createAll(url, 0, watcher); return createAll(url, 0, watcher);
} }
/** /**
* 创建并初始化监听，监听所有事件 * 创建并初始化监听，监听所有事件
* *
* @param url URL * @param url URL
* @param maxDepth 当监听目录时，监听目录的最大深度，当设置值为1（或小于1）时，表示不递归监听子目录 * @param maxDepth 当监听目录时，监听目录的最大深度，当设置值为1（或小于1）时，表示不递归监听子目录
* @param watcher {@link Watcher} * @param watcher {@link Watcher}
@ -155,10 +155,10 @@ public class WatchUtil {
public static WatchMonitor createAll(URL url, int maxDepth, Watcher watcher) { public static WatchMonitor createAll(URL url, int maxDepth, Watcher watcher) {
return createAll(URLUtil.toURI(url), maxDepth, watcher); return createAll(URLUtil.toURI(url), maxDepth, watcher);
} }
/** /**
* 创建并初始化监听，监听所有事件 * 创建并初始化监听，监听所有事件
* *
* @param uri URI * @param uri URI
* @param watcher {@link Watcher} * @param watcher {@link Watcher}
* @return {@link WatchMonitor} * @return {@link WatchMonitor}
@ -166,10 +166,10 @@ public class WatchUtil {
public static WatchMonitor createAll(URI uri, Watcher watcher) { public static WatchMonitor createAll(URI uri, Watcher watcher) {
return createAll(uri, 0, watcher); return createAll(uri, 0, watcher);
} }
/** /**
* 创建并初始化监听，监听所有事件 * 创建并初始化监听，监听所有事件
* *
* @param uri URI * @param uri URI
* @param maxDepth 当监听目录时，监听目录的最大深度，当设置值为1（或小于1）时，表示不递归监听子目录 * @param maxDepth 当监听目录时，监听目录的最大深度，当设置值为1（或小于1）时，表示不递归监听子目录
* @param watcher {@link Watcher} * @param watcher {@link Watcher}
@ -181,7 +181,7 @@ public class WatchUtil {
/** /**
* 创建并初始化监听，监听所有事件 * 创建并初始化监听，监听所有事件
* *
* @param file 被监听文件 * @param file 被监听文件
* @param watcher {@link Watcher} * @param watcher {@link Watcher}
* @return {@link WatchMonitor} * @return {@link WatchMonitor}
@ -189,10 +189,10 @@ public class WatchUtil {
public static WatchMonitor createAll(File file, Watcher watcher) { public static WatchMonitor createAll(File file, Watcher watcher) {
return createAll(file, 0, watcher); return createAll(file, 0, watcher);
} }
/** /**
* 创建并初始化监听，监听所有事件 * 创建并初始化监听，监听所有事件
* *
* @param file 被监听文件 * @param file 被监听文件
* @param maxDepth 当监听目录时，监听目录的最大深度，当设置值为1（或小于1）时，表示不递归监听子目录 * @param maxDepth 当监听目录时，监听目录的最大深度，当设置值为1（或小于1）时，表示不递归监听子目录
* @param watcher {@link Watcher} * @param watcher {@link Watcher}
@ -204,7 +204,7 @@ public class WatchUtil {
/** /**
* 创建并初始化监听，监听所有事件 * 创建并初始化监听，监听所有事件
* *
* @param path 路径 * @param path 路径
* @param watcher {@link Watcher} * @param watcher {@link Watcher}
* @return {@link WatchMonitor} * @return {@link WatchMonitor}
@ -212,10 +212,10 @@ public class WatchUtil {
public static WatchMonitor createAll(String path, Watcher watcher) { public static WatchMonitor createAll(String path, Watcher watcher) {
return createAll(path, 0, watcher); return createAll(path, 0, watcher);
} }
/** /**
* 创建并初始化监听，监听所有事件 * 创建并初始化监听，监听所有事件
* *
* @param path 路径 * @param path 路径
* @param maxDepth 当监听目录时，监听目录的最大深度，当设置值为1（或小于1）时，表示不递归监听子目录 * @param maxDepth 当监听目录时，监听目录的最大深度，当设置值为1（或小于1）时，表示不递归监听子目录
* @param watcher {@link Watcher} * @param watcher {@link Watcher}
@ -227,7 +227,7 @@ public class WatchUtil {
/** /**
* 创建并初始化监听，监听所有事件 * 创建并初始化监听，监听所有事件
* *
* @param path 路径 * @param path 路径
* @param watcher {@link Watcher} * @param watcher {@link Watcher}
* @return {@link WatchMonitor} * @return {@link WatchMonitor}
@ -235,10 +235,10 @@ public class WatchUtil {
public static WatchMonitor createAll(Path path, Watcher watcher) { public static WatchMonitor createAll(Path path, Watcher watcher) {
return createAll(path, 0, watcher); return createAll(path, 0, watcher);
} }
/** /**
* 创建并初始化监听，监听所有事件 * 创建并初始化监听，监听所有事件
* *
* @param path 路径 * @param path 路径
* @param maxDepth 当监听目录时，监听目录的最大深度，当设置值为1（或小于1）时，表示不递归监听子目录 * @param maxDepth 当监听目录时，监听目录的最大深度，当设置值为1（或小于1）时，表示不递归监听子目录
* @param watcher {@link Watcher} * @param watcher {@link Watcher}
@ -249,11 +249,11 @@ public class WatchUtil {
watchMonitor.setWatcher(watcher); watchMonitor.setWatcher(watcher);
return watchMonitor; return watchMonitor;
} }
// ---------------------------------------------------------------------------------------------------------- createModify // ---------------------------------------------------------------------------------------------------------- createModify
/** /**
* 创建并初始化监听，监听修改事件 * 创建并初始化监听，监听修改事件
* *
* @param url URL * @param url URL
* @param watcher {@link Watcher} * @param watcher {@link Watcher}
* @return {@link WatchMonitor} * @return {@link WatchMonitor}
@ -262,10 +262,10 @@ public class WatchUtil {
public static WatchMonitor createModify(URL url, Watcher watcher) { public static WatchMonitor createModify(URL url, Watcher watcher) {
return createModify(url, 0, watcher); return createModify(url, 0, watcher);
} }
/** /**
* 创建并初始化监听，监听修改事件 * 创建并初始化监听，监听修改事件
* *
* @param url URL * @param url URL
* @param maxDepth 当监听目录时，监听目录的最大深度，当设置值为1（或小于1）时，表示不递归监听子目录 * @param maxDepth 当监听目录时，监听目录的最大深度，当设置值为1（或小于1）时，表示不递归监听子目录
* @param watcher {@link Watcher} * @param watcher {@link Watcher}
@ -275,10 +275,10 @@ public class WatchUtil {
public static WatchMonitor createModify(URL url, int maxDepth, Watcher watcher) { public static WatchMonitor createModify(URL url, int maxDepth, Watcher watcher) {
return createModify(URLUtil.toURI(url), maxDepth, watcher); return createModify(URLUtil.toURI(url), maxDepth, watcher);
} }
/** /**
* 创建并初始化监听，监听修改事件 * 创建并初始化监听，监听修改事件
* *
* @param uri URI * @param uri URI
* @param watcher {@link Watcher} * @param watcher {@link Watcher}
* @return {@link WatchMonitor} * @return {@link WatchMonitor}
@ -287,10 +287,10 @@ public class WatchUtil {
public static WatchMonitor createModify(URI uri, Watcher watcher) { public static WatchMonitor createModify(URI uri, Watcher watcher) {
return createModify(uri, 0, watcher); return createModify(uri, 0, watcher);
} }
/** /**
* 创建并初始化监听，监听修改事件 * 创建并初始化监听，监听修改事件
* *
* @param uri URI * @param uri URI
* @param maxDepth 当监听目录时，监听目录的最大深度，当设置值为1（或小于1）时，表示不递归监听子目录 * @param maxDepth 当监听目录时，监听目录的最大深度，当设置值为1（或小于1）时，表示不递归监听子目录
* @param watcher {@link Watcher} * @param watcher {@link Watcher}
@ -300,10 +300,10 @@ public class WatchUtil {
public static WatchMonitor createModify(URI uri, int maxDepth, Watcher watcher) { public static WatchMonitor createModify(URI uri, int maxDepth, Watcher watcher) {
return createModify(Paths.get(uri), maxDepth, watcher); return createModify(Paths.get(uri), maxDepth, watcher);
} }
/** /**
* 创建并初始化监听，监听修改事件 * 创建并初始化监听，监听修改事件
* *
* @param file 被监听文件 * @param file 被监听文件
* @param watcher {@link Watcher} * @param watcher {@link Watcher}
* @return {@link WatchMonitor} * @return {@link WatchMonitor}
@ -312,10 +312,10 @@ public class WatchUtil {
public static WatchMonitor createModify(File file, Watcher watcher) { public static WatchMonitor createModify(File file, Watcher watcher) {
return createModify(file, 0, watcher); return createModify(file, 0, watcher);
} }
/** /**
* 创建并初始化监听，监听修改事件 * 创建并初始化监听，监听修改事件
* *
* @param file 被监听文件 * @param file 被监听文件
* @param maxDepth 当监听目录时，监听目录的最大深度，当设置值为1（或小于1）时，表示不递归监听子目录 * @param maxDepth 当监听目录时，监听目录的最大深度，当设置值为1（或小于1）时，表示不递归监听子目录
* @param watcher {@link Watcher} * @param watcher {@link Watcher}
@ -325,10 +325,10 @@ public class WatchUtil {
public static WatchMonitor createModify(File file, int maxDepth, Watcher watcher) { public static WatchMonitor createModify(File file, int maxDepth, Watcher watcher) {
return createModify(file.toPath(), 0, watcher); return createModify(file.toPath(), 0, watcher);
} }
/** /**
* 创建并初始化监听，监听修改事件 * 创建并初始化监听，监听修改事件
* *
* @param path 路径 * @param path 路径
* @param watcher {@link Watcher} * @param watcher {@link Watcher}
* @return {@link WatchMonitor} * @return {@link WatchMonitor}
@ -337,10 +337,10 @@ public class WatchUtil {
public static WatchMonitor createModify(String path, Watcher watcher) { public static WatchMonitor createModify(String path, Watcher watcher) {
return createModify(path, 0, watcher); return createModify(path, 0, watcher);
} }
/** /**
* 创建并初始化监听，监听修改事件 * 创建并初始化监听，监听修改事件
* *
* @param path 路径 * @param path 路径
* @param maxDepth 当监听目录时，监听目录的最大深度，当设置值为1（或小于1）时，表示不递归监听子目录 * @param maxDepth 当监听目录时，监听目录的最大深度，当设置值为1（或小于1）时，表示不递归监听子目录
* @param watcher {@link Watcher} * @param watcher {@link Watcher}
@ -350,10 +350,10 @@ public class WatchUtil {
public static WatchMonitor createModify(String path, int maxDepth, Watcher watcher) { public static WatchMonitor createModify(String path, int maxDepth, Watcher watcher) {
return createModify(Paths.get(path), maxDepth, watcher); return createModify(Paths.get(path), maxDepth, watcher);
} }
/** /**
* 创建并初始化监听，监听修改事件 * 创建并初始化监听，监听修改事件
* *
* @param path 路径 * @param path 路径
* @param watcher {@link Watcher} * @param watcher {@link Watcher}
* @return {@link WatchMonitor} * @return {@link WatchMonitor}
@ -362,10 +362,10 @@ public class WatchUtil {
public static WatchMonitor createModify(Path path, Watcher watcher) { public static WatchMonitor createModify(Path path, Watcher watcher) {
return createModify(path, 0, watcher); return createModify(path, 0, watcher);
} }
/** /**
* 创建并初始化监听，监听修改事件 * 创建并初始化监听，监听修改事件
* *
* @param path 路径 * @param path 路径
* @param maxDepth 当监听目录时，监听目录的最大深度，当设置值为1（或小于1）时，表示不递归监听子目录 * @param maxDepth 当监听目录时，监听目录的最大深度，当设置值为1（或小于1）时，表示不递归监听子目录
* @param watcher {@link Watcher} * @param watcher {@link Watcher}

2
hutool-core/src/main/java/cn/hutool/core/io/watch/package-info.java
View File

@ -1,6 +1,6 @@
/** /**
* 基于JDK7+ WatchService的文件和目录监听封装，支持多级目录 * 基于JDK7+ WatchService的文件和目录监听封装，支持多级目录
* *
* @author looly * @author looly
* *
*/ */

22
hutool-core/src/main/java/cn/hutool/core/io/watch/watchers/DelayWatcher.java
View File

@ -17,19 +17,19 @@ import java.util.Set;
* 在监听目录或文件时，如果这个文件有修改操作，会多次触发modify方法。<br> * 在监听目录或文件时，如果这个文件有修改操作，会多次触发modify方法。<br>
* 此类通过维护一个Set将短时间内相同文件多次modify的事件合并处理触发，从而避免以上问题。<br> * 此类通过维护一个Set将短时间内相同文件多次modify的事件合并处理触发，从而避免以上问题。<br>
* 注意：延迟只针对modify事件，其它事件无效 * 注意：延迟只针对modify事件，其它事件无效
* *
* @author Looly * @author Looly
* @since 3.1.0 * @since 3.1.0
*/ */
public class DelayWatcher implements Watcher { public class DelayWatcher implements Watcher {
/** Path集合。此集合用于去重在指定delay内多次触发的文件Path */ /** Path集合。此集合用于去重在指定delay内多次触发的文件Path */
private final Set<Path> eventSet = new ConcurrentHashSet<>(); private final Set<Path> eventSet = new ConcurrentHashSet<>();
/** 实际处理 */ /** 实际处理 */
private final Watcher watcher; private final Watcher watcher;
/** 延迟，单位毫秒 */ /** 延迟，单位毫秒 */
private final long delay; private final long delay;
//---------------------------------------------------------------------------------------------------------- Constructor start //---------------------------------------------------------------------------------------------------------- Constructor start
/** /**
* 构造 * 构造
@ -45,7 +45,7 @@ public class DelayWatcher implements Watcher {
this.delay = delay; this.delay = delay;
} }
//---------------------------------------------------------------------------------------------------------- Constructor end //---------------------------------------------------------------------------------------------------------- Constructor end
@Override @Override
public void onModify(WatchEvent<?> event, Path currentPath) { public void onModify(WatchEvent<?> event, Path currentPath) {
if(this.delay < 1) { if(this.delay < 1) {
@ -54,22 +54,22 @@ public class DelayWatcher implements Watcher {
onDelayModify(event, currentPath); onDelayModify(event, currentPath);
} }
} }
@Override @Override
public void onCreate(WatchEvent<?> event, Path currentPath) { public void onCreate(WatchEvent<?> event, Path currentPath) {
watcher.onCreate(event, currentPath); watcher.onCreate(event, currentPath);
} }
@Override @Override
public void onDelete(WatchEvent<?> event, Path currentPath) { public void onDelete(WatchEvent<?> event, Path currentPath) {
watcher.onDelete(event, currentPath); watcher.onDelete(event, currentPath);
} }
@Override @Override
public void onOverflow(WatchEvent<?> event, Path currentPath) { public void onOverflow(WatchEvent<?> event, Path currentPath) {
watcher.onOverflow(event, currentPath); watcher.onOverflow(event, currentPath);
} }
//---------------------------------------------------------------------------------------------------------- Private method start //---------------------------------------------------------------------------------------------------------- Private method start
/** /**
* 触发延迟修改 * 触发延迟修改
@ -82,15 +82,15 @@ public class DelayWatcher implements Watcher {
//此事件已经被触发过，后续事件忽略，等待统一处理。 //此事件已经被触发过，后续事件忽略，等待统一处理。
return; return;
} }
//事件第一次触发，此时标记事件，并启动处理线程延迟处理，处理结束后会删除标记 //事件第一次触发，此时标记事件，并启动处理线程延迟处理，处理结束后会删除标记
eventSet.add(eventPath); eventSet.add(eventPath);
startHandleModifyThread(event, currentPath); startHandleModifyThread(event, currentPath);
} }
/** /**
* 开启处理线程 * 开启处理线程
* *
* @param event 事件 * @param event 事件
* @param currentPath 事件发生的当前Path路径 * @param currentPath 事件发生的当前Path路径
*/ */

2
hutool-core/src/main/java/cn/hutool/core/io/watch/watchers/IgnoreWatcher.java
View File

@ -8,7 +8,7 @@ import cn.hutool.core.io.watch.Watcher;
/** /**
* 跳过所有事件处理Watcher<br> * 跳过所有事件处理Watcher<br>
* 用户继承此类后实现需要监听的方法 * 用户继承此类后实现需要监听的方法
* *
* @author Looly * @author Looly
* @since 3.1.0 * @since 3.1.0
*/ */

8
hutool-core/src/main/java/cn/hutool/core/io/watch/watchers/WatcherChain.java
View File

@ -12,7 +12,7 @@ import java.util.List;
/** /**
* 观察者链<br> * 观察者链<br>
* 用于加入多个观察者 * 用于加入多个观察者
* *
* @author Looly * @author Looly
* @since 3.1.0 * @since 3.1.0
*/ */
@ -20,7 +20,7 @@ public class WatcherChain implements Watcher, Chain<Watcher, WatcherChain>{
/** 观察者列表 */ /** 观察者列表 */
final private List<Watcher> chain; final private List<Watcher> chain;
/** /**
* 创建观察者链{@link WatcherChain} * 创建观察者链{@link WatcherChain}
* @param watchers 观察者列表 * @param watchers 观察者列表
@ -29,7 +29,7 @@ public class WatcherChain implements Watcher, Chain<Watcher, WatcherChain>{
public static WatcherChain create(Watcher... watchers) { public static WatcherChain create(Watcher... watchers) {
return new WatcherChain(watchers); return new WatcherChain(watchers);
} }
/** /**
* 构造 * 构造
* @param watchers 观察者列表 * @param watchers 观察者列表
@ -37,7 +37,7 @@ public class WatcherChain implements Watcher, Chain<Watcher, WatcherChain>{
public WatcherChain(Watcher... watchers) { public WatcherChain(Watcher... watchers) {
chain = CollUtil.newArrayList(watchers); chain = CollUtil.newArrayList(watchers);
} }
@Override @Override
public void onCreate(WatchEvent<?> event, Path currentPath) { public void onCreate(WatchEvent<?> event, Path currentPath) {
for (Watcher watcher : chain) { for (Watcher watcher : chain) {

2
hutool-core/src/main/java/cn/hutool/core/io/watch/watchers/package-info.java
View File

@ -1,6 +1,6 @@
/** /**
* 文件监听中的观察者实现类，包括延迟处理、处理链等 * 文件监听中的观察者实现类，包括延迟处理、处理链等
* *
* @author looly * @author looly
* *
*/ */

4
hutool-core/src/main/java/cn/hutool/core/lang/ConsistentHash.java
View File

@ -18,14 +18,14 @@ import java.util.TreeMap;
*/ */
public class ConsistentHash<T> implements Serializable{ public class ConsistentHash<T> implements Serializable{
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
/** Hash计算对象，用于自定义hash算法 */ /** Hash计算对象，用于自定义hash算法 */
Hash32<Object> hashFunc; Hash32<Object> hashFunc;
/** 复制的节点个数 */ /** 复制的节点个数 */
private final int numberOfReplicas; private final int numberOfReplicas;
/** 一致性Hash环 */ /** 一致性Hash环 */
private final SortedMap<Integer, T> circle = new TreeMap<>(); private final SortedMap<Integer, T> circle = new TreeMap<>();
/** /**
* 构造，使用Java默认的Hash算法 * 构造，使用Java默认的Hash算法
* @param numberOfReplicas 复制的节点个数，增加每个节点的复制节点有利于负载均衡 * @param numberOfReplicas 复制的节点个数，增加每个节点的复制节点有利于负载均衡

6
hutool-core/src/main/java/cn/hutool/core/lang/Holder.java
View File

@ -13,7 +13,7 @@ public final class Holder<T> extends MutableObj<T>{
/** /**
* 新建Holder类，持有指定值，当值为空时抛出空指针异常 * 新建Holder类，持有指定值，当值为空时抛出空指针异常
* *
* @param <T> 被持有的对象类型 * @param <T> 被持有的对象类型
* @param value 值，不能为空 * @param value 值，不能为空
* @return Holder * @return Holder
@ -24,14 +24,14 @@ public final class Holder<T> extends MutableObj<T>{
} }
return new Holder<>(value); return new Holder<>(value);
} }
//--------------------------------------------------------------------------- Constructor start //--------------------------------------------------------------------------- Constructor start
/** /**
* 构造 * 构造
*/ */
public Holder() { public Holder() {
} }
/** /**
* 构造 * 构造
* @param value 被包装的对象 * @param value 被包装的对象

18
hutool-core/src/main/java/cn/hutool/core/lang/ObjectId.java
View File

@ -14,16 +14,16 @@ import cn.hutool.core.util.StrUtil;
/** /**
* MongoDB ID生成策略实现<br> * MongoDB ID生成策略实现<br>
* ObjectId由以下几部分组成： * ObjectId由以下几部分组成：
* *
* <pre> * <pre>
* 1. Time 时间戳。 * 1. Time 时间戳。
* 2. Machine 所在主机的唯一标识符，一般是机器主机名的散列值。 * 2. Machine 所在主机的唯一标识符，一般是机器主机名的散列值。
* 3. PID 进程ID。确保同一机器中不冲突 * 3. PID 进程ID。确保同一机器中不冲突
* 4. INC 自增计数器。确保同一秒内产生objectId的唯一性。 * 4. INC 自增计数器。确保同一秒内产生objectId的唯一性。
* </pre> * </pre>
* *
* 参考：http://blog.csdn.net/qxc1281/article/details/54021882 * 参考：http://blog.csdn.net/qxc1281/article/details/54021882
* *
* @author looly * @author looly
* @since 4.0.0 * @since 4.0.0
* *
@ -37,7 +37,7 @@ public class ObjectId {
/** /**
* 给定的字符串是否为有效的ObjectId * 给定的字符串是否为有效的ObjectId
* *
* @param s 字符串 * @param s 字符串
* @return 是否为有效的ObjectId * @return 是否为有效的ObjectId
*/ */
@ -70,7 +70,7 @@ public class ObjectId {
/** /**
* 获取一个objectId的bytes表现形式 * 获取一个objectId的bytes表现形式
* *
* @return objectId * @return objectId
* @since 4.1.15 * @since 4.1.15
*/ */
@ -85,7 +85,7 @@ public class ObjectId {
/** /**
* 获取一个objectId用下划线分割 * 获取一个objectId用下划线分割
* *
* @return objectId * @return objectId
*/ */
public static String next() { public static String next() {
@ -94,7 +94,7 @@ public class ObjectId {
/** /**
* 获取一个objectId * 获取一个objectId
* *
* @param withHyphen 是否包含分隔符 * @param withHyphen 是否包含分隔符
* @return objectId * @return objectId
*/ */
@ -119,7 +119,7 @@ public class ObjectId {
// ----------------------------------------------------------------------------------------- Private method start // ----------------------------------------------------------------------------------------- Private method start
/** /**
* 获取机器码片段 * 获取机器码片段
* *
* @return 机器码片段 * @return 机器码片段
*/ */
private static int getMachinePiece() { private static int getMachinePiece() {
@ -146,7 +146,7 @@ public class ObjectId {
/** /**
* 获取进程码片段 * 获取进程码片段
* *
* @return 进程码片段 * @return 进程码片段
*/ */
private static int getProcessPiece() { private static int getProcessPiece() {

12
hutool-core/src/main/java/cn/hutool/core/lang/ParameterizedTypeImpl.java
View File

@ -9,20 +9,20 @@ import cn.hutool.core.util.StrUtil;
/** /**
* {@link ParameterizedType} 接口实现，用于重新定义泛型类型 * {@link ParameterizedType} 接口实现，用于重新定义泛型类型
* *
* @author looly * @author looly
* @since 4.5.7 * @since 4.5.7
*/ */
public class ParameterizedTypeImpl implements ParameterizedType, Serializable { public class ParameterizedTypeImpl implements ParameterizedType, Serializable {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
private final Type[] actualTypeArguments; private final Type[] actualTypeArguments;
private final Type ownerType; private final Type ownerType;
private final Type rawType; private final Type rawType;
/** /**
* 构造 * 构造
* *
* @param actualTypeArguments 实际的泛型参数类型 * @param actualTypeArguments 实际的泛型参数类型
* @param ownerType 拥有者类型 * @param ownerType 拥有者类型
* @param rawType 原始类型 * @param rawType 原始类型
@ -71,7 +71,7 @@ public class ParameterizedTypeImpl implements ParameterizedType, Serializable {
/** /**
* 追加 {@code types} 到 @{code buf}，使用 {@code sep} 分隔 * 追加 {@code types} 到 @{code buf}，使用 {@code sep} 分隔
* *
* @param buf 目标 * @param buf 目标
* @param sep 分隔符 * @param sep 分隔符
* @param types 加入的类型 * @param types 加入的类型
@ -86,14 +86,14 @@ public class ParameterizedTypeImpl implements ParameterizedType, Serializable {
} else { } else {
buf.append(sep); buf.append(sep);
} }
String typeStr; String typeStr;
if(type instanceof Class) { if(type instanceof Class) {
typeStr = ((Class<?>)type).getName(); typeStr = ((Class<?>)type).getName();
}else { }else {
typeStr = StrUtil.toString(type); typeStr = StrUtil.toString(type);
} }
buf.append(typeStr); buf.append(typeStr);
} }
} }

22
hutool-core/src/main/java/cn/hutool/core/lang/Range.java
View File

@ -12,11 +12,11 @@ import java.util.concurrent.locks.ReentrantReadWriteLock;
/** /**
* 范围生成器。根据给定的初始值、结束值和步进生成一个步进列表生成器<br> * 范围生成器。根据给定的初始值、结束值和步进生成一个步进列表生成器<br>
* 由于用户自行实现{@link Steper}来定义步进，因此Range本身无法判定边界（是否达到end），需在step实现边界判定逻辑。 * 由于用户自行实现{@link Steper}来定义步进，因此Range本身无法判定边界（是否达到end），需在step实现边界判定逻辑。
* *
* <p> * <p>
* 此类使用{@link ReentrantReadWriteLock}保证线程安全 * 此类使用{@link ReentrantReadWriteLock}保证线程安全
* </p> * </p>
* *
* @author Looly * @author Looly
* *
* @param <T> 生成范围对象的类型 * @param <T> 生成范围对象的类型
@ -45,7 +45,7 @@ public class Range<T> implements Iterable<T>, Iterator<T>, Serializable {
/** /**
* 构造 * 构造
* *
* @param start 起始对象 * @param start 起始对象
* @param steper 步进 * @param steper 步进
*/ */
@ -55,7 +55,7 @@ public class Range<T> implements Iterable<T>, Iterator<T>, Serializable {
/** /**
* 构造 * 构造
* *
* @param start 起始对象（包含） * @param start 起始对象（包含）
* @param end 结束对象（包含） * @param end 结束对象（包含）
* @param steper 步进 * @param steper 步进
@ -66,7 +66,7 @@ public class Range<T> implements Iterable<T>, Iterator<T>, Serializable {
/** /**
* 构造 * 构造
* *
* @param start 起始对象 * @param start 起始对象
* @param end 结束对象 * @param end 结束对象
* @param steper 步进 * @param steper 步进
@ -86,7 +86,7 @@ public class Range<T> implements Iterable<T>, Iterator<T>, Serializable {
/** /**
* 禁用锁，调用此方法后不在 使用锁保护 * 禁用锁，调用此方法后不在 使用锁保护
* *
* @return this * @return this
* @since 4.3.1 * @since 4.3.1
*/ */
@ -143,7 +143,7 @@ public class Range<T> implements Iterable<T>, Iterator<T>, Serializable {
/** /**
* 不抛异常的获取下一步进的元素，如果获取失败返回{@code null} * 不抛异常的获取下一步进的元素，如果获取失败返回{@code null}
* *
* @param base 上一个元素 * @param base 上一个元素
* @return 下一步进 * @return 下一步进
*/ */
@ -169,7 +169,7 @@ public class Range<T> implements Iterable<T>, Iterator<T>, Serializable {
/** /**
* 重置{@link Range} * 重置{@link Range}
* *
* @return this * @return this
*/ */
public Range<T> reset() { public Range<T> reset() {
@ -186,13 +186,13 @@ public class Range<T> implements Iterable<T>, Iterator<T>, Serializable {
/** /**
* 步进接口，此接口用于实现如何对一个对象按照指定步进增加步进<br> * 步进接口，此接口用于实现如何对一个对象按照指定步进增加步进<br>
* 步进接口可以定义以下逻辑： * 步进接口可以定义以下逻辑：
* *
* <pre> * <pre>
* 1、步进规则，即对象如何做步进 * 1、步进规则，即对象如何做步进
* 2、步进大小，通过实现此接口，在实现类中定义一个对象属性，可灵活定义步进大小 * 2、步进大小，通过实现此接口，在实现类中定义一个对象属性，可灵活定义步进大小
* 3、限制range个数，通过实现此接口，在实现类中定义一个对象属性，可灵活定义limit，限制range个数 * 3、限制range个数，通过实现此接口，在实现类中定义一个对象属性，可灵活定义limit，限制range个数
* </pre> * </pre>
* *
* @author Looly * @author Looly
* *
* @param <T> 需要增加步进的对象 * @param <T> 需要增加步进的对象
@ -202,7 +202,7 @@ public class Range<T> implements Iterable<T>, Iterator<T>, Serializable {
* 增加步进<br> * 增加步进<br>
* 增加步进后的返回值如果为{@code null}则表示步进结束<br> * 增加步进后的返回值如果为{@code null}则表示步进结束<br>
* 用户需根据end参数自行定义边界，当达到边界时返回null表示结束，否则Range中边界对象无效，会导致无限循环 * 用户需根据end参数自行定义边界，当达到边界时返回null表示结束，否则Range中边界对象无效，会导致无限循环
* *
* @param current 上一次增加步进后的基础对象 * @param current 上一次增加步进后的基础对象
* @param end 结束对象 * @param end 结束对象
* @param index 当前索引（步进到第几个元素），从0开始计数 * @param index 当前索引（步进到第几个元素），从0开始计数

6
hutool-core/src/main/java/cn/hutool/core/lang/Replacer.java
View File

@ -3,7 +3,7 @@ package cn.hutool.core.lang;
/** /**
* 替换器<br> * 替换器<br>
* 通过实现此接口完成指定类型对象的替换操作，替换后的目标类型依旧为指定类型 * 通过实现此接口完成指定类型对象的替换操作，替换后的目标类型依旧为指定类型
* *
* @author looly * @author looly
* *
* @param <T> 被替换操作的类型 * @param <T> 被替换操作的类型
@ -11,10 +11,10 @@ package cn.hutool.core.lang;
*/ */
@FunctionalInterface @FunctionalInterface
public interface Replacer<T> { public interface Replacer<T> {
/** /**
* 替换指定类型为目标类型 * 替换指定类型为目标类型
* *
* @param t 被替换的对象 * @param t 被替换的对象
* @return 替代后的对象 * @return 替代后的对象
*/ */

12
hutool-core/src/main/java/cn/hutool/core/lang/TypeReference.java
View File

@ -7,17 +7,17 @@ import cn.hutool.core.util.TypeUtil;
/** /**
* Type类型参考<br> * Type类型参考<br>
* 通过构建一个类型参考子类，可以获取其泛型参数中的Type类型。例如： * 通过构建一个类型参考子类，可以获取其泛型参数中的Type类型。例如：
* *
* <pre> * <pre>
* TypeReference&lt;List&lt;String&gt;&gt; list = new TypeReference&lt;List&lt;String&gt;&gt;() {}; * TypeReference&lt;List&lt;String&gt;&gt; list = new TypeReference&lt;List&lt;String&gt;&gt;() {};
* Type t = tr.getType(); * Type t = tr.getType();
* </pre> * </pre>
* *
* 此类无法应用于通配符泛型参数（wildcard parameters），比如：{@code Class<?>} 或者 {@code List? extends CharSequence>} * 此类无法应用于通配符泛型参数（wildcard parameters），比如：{@code Class<?>} 或者 {@code List? extends CharSequence>}
* *
* <p> * <p>
* 此类参考FastJSON的TypeReference实现 * 此类参考FastJSON的TypeReference实现
* *
* @author looly * @author looly
* *
* @param <T> 需要自定义的参考类型 * @param <T> 需要自定义的参考类型
@ -37,13 +37,13 @@ public abstract class TypeReference<T> implements Type {
/** /**
* 获取用户定义的泛型参数 * 获取用户定义的泛型参数
* *
* @return 泛型参数 * @return 泛型参数
*/ */
public Type getType() { public Type getType() {
return this.type; return this.type;
} }
@Override @Override
public String toString() { public String toString() {
return this.type.toString(); return this.type.toString();

30
hutool-core/src/main/java/cn/hutool/core/lang/WeightRandom.java
View File

@ -19,11 +19,11 @@ import java.util.TreeMap;
* </p> * </p>
* 总体思路：累加每个元素的权重A(1)-B(3)-C(6)-D(10)，则4个元素的的权重管辖区间分别为[0,1)、[1,3)、[3,6)、[6,10)。<br> * 总体思路：累加每个元素的权重A(1)-B(3)-C(6)-D(10)，则4个元素的的权重管辖区间分别为[0,1)、[1,3)、[3,6)、[6,10)。<br>
* 然后随机出一个[0,10)之间的随机数。落在哪个区间，则该区间之后的元素即为按权重命中的元素。<br> * 然后随机出一个[0,10)之间的随机数。落在哪个区间，则该区间之后的元素即为按权重命中的元素。<br>
* *
* <p> * <p>
* 参考博客：https://www.cnblogs.com/waterystone/p/5708063.html * 参考博客：https://www.cnblogs.com/waterystone/p/5708063.html
* <p> * <p>
* *
* @param <T> 权重随机获取的对象类型 * @param <T> 权重随机获取的对象类型
* @author looly * @author looly
* @since 3.3.0 * @since 3.3.0
@ -55,7 +55,7 @@ public class WeightRandom<T> implements Serializable {
/** /**
* 构造 * 构造
* *
* @param weightObj 带有权重的对象 * @param weightObj 带有权重的对象
*/ */
public WeightRandom(WeightObj<T> weightObj) { public WeightRandom(WeightObj<T> weightObj) {
@ -67,7 +67,7 @@ public class WeightRandom<T> implements Serializable {
/** /**
* 构造 * 构造
* *
* @param weightObjs 带有权重的对象 * @param weightObjs 带有权重的对象
*/ */
public WeightRandom(Iterable<WeightObj<T>> weightObjs) { public WeightRandom(Iterable<WeightObj<T>> weightObjs) {
@ -81,7 +81,7 @@ public class WeightRandom<T> implements Serializable {
/** /**
* 构造 * 构造
* *
* @param weightObjs 带有权重的对象 * @param weightObjs 带有权重的对象
*/ */
public WeightRandom(WeightObj<T>[] weightObjs) { public WeightRandom(WeightObj<T>[] weightObjs) {
@ -94,7 +94,7 @@ public class WeightRandom<T> implements Serializable {
/** /**
* 增加对象 * 增加对象
* *
* @param obj 对象 * @param obj 对象
* @param weight 权重 * @param weight 权重
* @return this * @return this
@ -105,7 +105,7 @@ public class WeightRandom<T> implements Serializable {
/** /**
* 增加对象权重 * 增加对象权重
* *
* @param weightObj 权重对象 * @param weightObj 权重对象
* @return this * @return this
*/ */
@ -122,7 +122,7 @@ public class WeightRandom<T> implements Serializable {
/** /**
* 清空权重表 * 清空权重表
* *
* @return this * @return this
*/ */
public WeightRandom<T> clear() { public WeightRandom<T> clear() {
@ -134,7 +134,7 @@ public class WeightRandom<T> implements Serializable {
/** /**
* 下一个随机对象 * 下一个随机对象
* *
* @return 随机对象 * @return 随机对象
*/ */
public T next() { public T next() {
@ -149,7 +149,7 @@ public class WeightRandom<T> implements Serializable {
/** /**
* 带有权重的对象包装 * 带有权重的对象包装
* *
* @author looly * @author looly
* *
* @param <T> 对象类型 * @param <T> 对象类型
@ -162,7 +162,7 @@ public class WeightRandom<T> implements Serializable {
/** /**
* 构造 * 构造
* *
* @param obj 对象 * @param obj 对象
* @param weight 权重 * @param weight 权重
*/ */
@ -173,7 +173,7 @@ public class WeightRandom<T> implements Serializable {
/** /**
* 获取对象 * 获取对象
* *
* @return 对象 * @return 对象
*/ */
public T getObj() { public T getObj() {
@ -182,7 +182,7 @@ public class WeightRandom<T> implements Serializable {
/** /**
* 设置对象 * 设置对象
* *
* @param obj 对象 * @param obj 对象
*/ */
public void setObj(T obj) { public void setObj(T obj) {
@ -191,7 +191,7 @@ public class WeightRandom<T> implements Serializable {
/** /**
* 获取权重 * 获取权重
* *
* @return 权重 * @return 权重
*/ */
public double getWeight() { public double getWeight() {
@ -231,5 +231,5 @@ public class WeightRandom<T> implements Serializable {
return Double.doubleToLongBits(weight) == Double.doubleToLongBits(other.weight); return Double.doubleToLongBits(weight) == Double.doubleToLongBits(other.weight);
} }
} }
} }