expression) {
- return uncheck(expression, new RuntimeException());
+ return uncheck(expression, RuntimeException::new);
}
@@ -89,10 +89,10 @@ public class CheckedUtil {
*
* @param expression 运行时传入的参数类型
* @param 运行时传入的参数类型
- * @return cn.hutool.core.lang.func.VoidFunc
+ * @return {@link VoidFuncRt}
*/
public static
VoidFuncRt
uncheck(VoidFunc
expression) {
- return uncheck(expression, new RuntimeException());
+ return uncheck(expression, RuntimeException::new);
}
/**
@@ -100,10 +100,10 @@ public class CheckedUtil {
* 如此一来，代码中就不用显示的try-catch转化成运行时异常
*
* @param expression 运行时传入的参数类型
- * @return cn.hutool.core.lang.func.VoidFunc0
+ * @return {@link VoidFunc0Rt}
*/
public static VoidFunc0Rt uncheck(VoidFunc0 expression) {
- return uncheck(expression, new RuntimeException());
+ return uncheck(expression, RuntimeException::new);
}
/**
@@ -112,110 +112,106 @@ public class CheckedUtil {
*
* @param expression 运行时传入的参数类型
* @param
运行时传入的参数类型
- * @return cn.hutool.core.lang.func.VoidFunc1
+ * @return {@link VoidFunc1Rt}
*/
public static
VoidFunc1Rt
uncheck(VoidFunc1
expression) {
- return uncheck(expression, new RuntimeException());
+ return uncheck(expression, RuntimeException::new);
}
/**
- * 接收一个可以转化成 cn.hutool.core.lang.func.Func的Lambda表达式，和一个RuntimeException，当执行表达式抛出任何异常的时候，都会转化成运行时异常
+ * 接收一个可以转化成 cn.hutool.core.lang.func.Func的Lambda表达式，和一个可以把Exception转化成RuntimeExceptionde的表达式，当执行表达式抛出任何异常的时候，都会转化成运行时异常
* 如此一来，代码中就不用显示的try-catch转化成运行时异常
*
- * @param expression Lambda表达式
- * @param rte 期望抛出的运行时异常
- * @param
运行时传入的参数类型
- * @param 最终返回的数据类型
- * @return cn.hutool.core.lang.func.Func
+ * @param expression Lambda表达式
+ * @param rteSupplier 转化运行时异常的表达式
+ * @param 运行时传入的参数类型
+ * @param 最终返回的数据类型
+ * @return {@link FuncRt}
*/
- public static FuncRt uncheck(Func expression, RuntimeException rte) {
+ public static FuncRt uncheck(Func expression, Supplier1 rteSupplier) {
Objects.requireNonNull(expression, "expression can not be null");
return t -> {
try {
return expression.call(t);
} catch (Exception e) {
- if (rte == null) {
+ if (rteSupplier == null) {
throw new RuntimeException(e);
} else {
- rte.initCause(e);
- throw rte;
+ throw rteSupplier.get(e);
}
}
};
}
/**
- * 接收一个可以转化成 cn.hutool.core.lang.func.Func0的Lambda表达式，和一个RuntimeException，当执行表达式抛出任何异常的时候，都会转化成运行时异常
+ * 接收一个可以转化成 cn.hutool.core.lang.func.Func0的Lambda表达式，和一个可以把Exception转化成RuntimeExceptionde的表达式，当执行表达式抛出任何异常的时候，都会转化成运行时异常
* 如此一来，代码中就不用显示的try-catch转化成运行时异常
*
- * @param expression Lambda表达式
- * @param rte 期望抛出的运行时异常
- * @param 最终返回的数据类型
- * @return cn.hutool.core.lang.func.Func0
+ * @param expression Lambda表达式
+ * @param rteSupplier 转化运行时异常的表达式
+ * @param 最终返回的数据类型
+ * @return {@link Func0Rt}
*/
- public static Func0Rt uncheck(Func0 expression, RuntimeException rte) {
+ public static Func0Rt uncheck(Func0 expression, Supplier1 rteSupplier) {
Objects.requireNonNull(expression, "expression can not be null");
return () -> {
try {
return expression.call();
} catch (Exception e) {
- if (rte == null) {
+ if (rteSupplier == null) {
throw new RuntimeException(e);
} else {
- rte.initCause(e);
- throw rte;
+ throw rteSupplier.get(e);
}
}
};
}
/**
- * 接收一个可以转化成 cn.hutool.core.lang.func.Func1的Lambda表达式，和一个RuntimeException，当执行表达式抛出任何异常的时候，都会转化成运行时异常
+ * 接收一个可以转化成 cn.hutool.core.lang.func.Func1的Lambda表达式，和一个可以把Exception转化成RuntimeExceptionde的表达式，当执行表达式抛出任何异常的时候，都会转化成运行时异常
* 如此一来，代码中就不用显示的try-catch转化成运行时异常
*
- * @param expression Lambda表达式
- * @param rte 期望抛出的运行时异常
- * @param 运行时传入的参数类型
- * @param 最终返回的数据类型
- * @return cn.hutool.core.lang.func.Func1
+ * @param expression Lambda表达式
+ * @param rteSupplier 转化运行时异常的表达式
+ * @param 运行时传入的参数类型
+ * @param 最终返回的数据类型
+ * @return {@link Func1Rt}
*/
- public static Func1Rt uncheck(Func1 expression, RuntimeException rte) {
+ public static Func1Rt uncheck(Func1 expression, Supplier1 rteSupplier) {
Objects.requireNonNull(expression, "expression can not be null");
return t -> {
try {
return expression.call(t);
} catch (Exception e) {
- if (rte == null) {
+ if (rteSupplier == null) {
throw new RuntimeException(e);
} else {
- rte.initCause(e);
- throw rte;
+ throw rteSupplier.get(e);
}
}
};
}
/**
- * 接收一个可以转化成 cn.hutool.core.lang.func.VoidFunc的Lambda表达式，和一个RuntimeException，当执行表达式抛出任何异常的时候，都会转化成运行时异常
+ * 接收一个可以转化成 cn.hutool.core.lang.func.VoidFunc的Lambda表达式，和一个可以把Exception转化成RuntimeExceptionde的表达式，当执行表达式抛出任何异常的时候，都会转化成运行时异常
* 如此一来，代码中就不用显示的try-catch转化成运行时异常
*
- * @param expression Lambda表达式
- * @param rte 期望抛出的运行时异常
- * @param 运行时传入的参数类型
- * @return cn.hutool.core.lang.func.VoidFunc
+ * @param expression Lambda表达式
+ * @param rteSupplier 转化运行时异常的表达式
+ * @param
运行时传入的参数类型
+ * @return {@link VoidFuncRt}
*/
- public static
VoidFuncRt
uncheck(VoidFunc
expression, RuntimeException rte) {
+ public static
VoidFuncRt
uncheck(VoidFunc
expression, Supplier1 rteSupplier) {
Objects.requireNonNull(expression, "expression can not be null");
return t -> {
try {
expression.call(t);
} catch (Exception e) {
- if (rte == null) {
+ if (rteSupplier == null) {
throw new RuntimeException(e);
} else {
- rte.initCause(e);
- throw rte;
+ throw rteSupplier.get(e);
}
}
};
@@ -228,7 +224,7 @@ public class CheckedUtil {
*
* @param expression Lambda表达式
* @param rte 期望抛出的运行时异常
- * @return cn.hutool.core.lang.func.VoidFunc0
+ * @return {@link VoidFunc0Rt}
*/
public static VoidFunc0Rt uncheck(VoidFunc0 expression, RuntimeException rte) {
Objects.requireNonNull(expression, "expression can not be null");
@@ -246,27 +242,48 @@ public class CheckedUtil {
};
}
+ /**
+ * 接收一个可以转化成 cn.hutool.core.lang.func.VoidFunc0的Lambda表达式，和一个可以把Exception转化成RuntimeExceptionde的表达式，当执行表达式抛出任何异常的时候，都会转化成运行时异常
+ * 如此一来，代码中就不用显示的try-catch转化成运行时异常
+ *
+ * @param expression Lambda表达式
+ * @param rteSupplier 转化运行时异常的表达式
+ * @return {@link VoidFunc0Rt}
+ */
+ public static VoidFunc0Rt uncheck(VoidFunc0 expression, Supplier1 rteSupplier) {
+ Objects.requireNonNull(expression, "expression can not be null");
+ return () -> {
+ try {
+ expression.call();
+ } catch (Exception e) {
+ if (rteSupplier == null) {
+ throw new RuntimeException(e);
+ } else {
+ throw rteSupplier.get(e);
+ }
+ }
+ };
+ }
/**
* 接收一个可以转化成 cn.hutool.core.lang.func.VoidFunc1的Lambda表达式，和一个RuntimeException，当执行表达式抛出任何异常的时候，都会转化成运行时异常
* 如此一来，代码中就不用显示的try-catch转化成运行时异常
*
- * @param expression Lambda表达式
- * @param rte 期望抛出的运行时异常
- * @param 运行时传入的参数类型
- * @return cn.hutool.core.lang.func.VoidFunc1
+ * @param expression Lambda表达式
+ * @param rteSupplier 转化运行时异常的表达式
+ * @param
运行时传入的参数类型
+ * @return {@link VoidFunc1Rt}
*/
- public static
VoidFunc1Rt
uncheck(VoidFunc1
expression, RuntimeException rte) {
+ public static
VoidFunc1Rt
uncheck(VoidFunc1
expression, Supplier1 rteSupplier) {
Objects.requireNonNull(expression, "expression can not be null");
return t -> {
try {
expression.call(t);
} catch (Exception e) {
- if (rte == null) {
+ if (rteSupplier == null) {
throw new RuntimeException(e);
} else {
- rte.initCause(e);
- throw rte;
+ throw rteSupplier.get(e);
}
}
};
@@ -274,27 +291,33 @@ public class CheckedUtil {
public interface FuncRt extends Func {
@SuppressWarnings("unchecked")
+ @Override
R call(P... parameters) throws RuntimeException;
}
public interface Func0Rt extends Func0 {
+ @Override
R call() throws RuntimeException;
}
public interface Func1Rt extends Func1 {
+ @Override
R call(P parameter) throws RuntimeException;
}
public interface VoidFuncRt extends VoidFunc
{
@SuppressWarnings("unchecked")
+ @Override
void call(P... parameters) throws RuntimeException;
}
public interface VoidFunc0Rt extends VoidFunc0 {
+ @Override
void call() throws RuntimeException;
}
public interface VoidFunc1Rt
extends VoidFunc1
{
+ @Override
void call(P parameter) throws RuntimeException;
}
diff --git a/hutool-core/src/main/java/cn/hutool/core/io/FileUtil.java b/hutool-core/src/main/java/cn/hutool/core/io/FileUtil.java
index 3d4b80858..e0622f7fc 100644
--- a/hutool-core/src/main/java/cn/hutool/core/io/FileUtil.java
+++ b/hutool-core/src/main/java/cn/hutool/core/io/FileUtil.java
@@ -13,6 +13,7 @@ import cn.hutool.core.io.file.Tailer;
import cn.hutool.core.io.resource.ResourceUtil;
import cn.hutool.core.io.unit.DataSizeUtil;
import cn.hutool.core.lang.Assert;
+import cn.hutool.core.thread.ThreadUtil;
import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.CharUtil;
import cn.hutool.core.util.CharsetUtil;
@@ -32,6 +33,7 @@ import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
+import java.io.LineNumberReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.RandomAccessFile;
@@ -40,7 +42,11 @@ import java.net.URI;
import java.net.URL;
import java.net.URLConnection;
import java.nio.charset.Charset;
-import java.nio.file.*;
+import java.nio.file.DirectoryNotEmptyException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.StandardCopyOption;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
@@ -526,24 +532,39 @@ public class FileUtil extends PathUtil {
/**
* 计算目录或文件的总大小
* 当给定对象为文件时，直接调用 {@link File#length()}
- * 当给定对象为目录时，遍历目录下的所有文件和目录，递归计算其大小，求和返回
+ * 当给定对象为目录时，遍历目录下的所有文件和目录，递归计算其大小，求和返回
+ * 此方法不包括目录本身的占用空间大小。
*
* @param file 目录或文件,null或者文件不存在返回0
* @return 总大小，bytes长度
*/
public static long size(File file) {
+ return size(file, false);
+ }
+
+ /**
+ * 计算目录或文件的总大小
+ * 当给定对象为文件时，直接调用 {@link File#length()}
+ * 当给定对象为目录时，遍历目录下的所有文件和目录，递归计算其大小，求和返回
+ *
+ * @param file 目录或文件,null或者文件不存在返回0
+ * @param includeDirSize 是否包括每层目录本身的大小
+ * @return 总大小，bytes长度
+ * @since 5.7.21
+ */
+ public static long size(File file, boolean includeDirSize) {
if (null == file || false == file.exists() || isSymlink(file)) {
return 0;
}
if (file.isDirectory()) {
- long size = 0L;
+ long size = includeDirSize ? file.length() : 0;
File[] subFiles = file.listFiles();
if (ArrayUtil.isEmpty(subFiles)) {
return 0L;// empty directory
}
for (File subFile : subFiles) {
- size += size(subFile);
+ size += size(subFile, includeDirSize);
}
return size;
} else {
@@ -551,6 +572,31 @@ public class FileUtil extends PathUtil {
}
}
+ /**
+ * 计算文件的总行数
+ * 读取文件采用系统默认编码，一般乱码不会造成行数错误。
+ *
+ * @param file 文件
+ * @return 该文件总行数
+ * @since 5.7.22
+ */
+ public static int getTotalLines(File file) {
+ if (false == isFile(file)) {
+ throw new IORuntimeException("Input must be a File");
+ }
+ try (final LineNumberReader lineNumberReader = new LineNumberReader(new java.io.FileReader(file))) {
+ // 设置起始为1
+ lineNumberReader.setLineNumber(1);
+ // 跳过文件中内容
+ //noinspection ResultOfMethodCallIgnored
+ lineNumberReader.skip(Long.MAX_VALUE);
+ // 获取当前行号
+ return lineNumberReader.getLineNumber();
+ } catch (IOException e) {
+ throw new IORuntimeException(e);
+ }
+ }
+
/**
* 给定文件或目录的最后修改时间是否晚于给定时间
*
@@ -811,7 +857,7 @@ public class FileUtil extends PathUtil {
/**
* 创建文件夹，会递归自动创建其不存在的父文件夹，如果存在直接返回此文件夹
- * 此方法不对File对象类型做判断，如果File不存在，无法判断其类型
+ * 此方法不对File对象类型做判断，如果File不存在，无法判断其类型
*
* @param dir 目录
* @return 创建的目录
@@ -821,12 +867,48 @@ public class FileUtil extends PathUtil {
return null;
}
if (false == dir.exists()) {
- //noinspection ResultOfMethodCallIgnored
- dir.mkdirs();
+ mkdirsSafely(dir, 5, 1);
}
return dir;
}
+ /**
+ * 安全地级联创建目录 (确保并发环境下能创建成功)
+ *
+ *
+ * 并发环境下，假设 test 目录不存在，如果线程A mkdirs "test/A" 目录，线程B mkdirs "test/B"目录，
+ * 其中一个线程可能会失败，进而导致以下代码抛出 FileNotFoundException 异常
+ *
+ * file.getParentFile().mkdirs(); // 父目录正在被另一个线程创建中，返回 false
+ * file.createNewFile(); // 抛出 IO 异常，因为该线程无法感知到父目录已被创建
+ *
+ *
+ * @param dir 待创建的目录
+ * @param tryCount 最大尝试次数
+ * @param sleepMillis 线程等待的毫秒数
+ * @return true表示创建成功，false表示创建失败
+ * @since 5.7.21
+ * @author z8g
+ */
+ public static boolean mkdirsSafely(File dir, int tryCount, long sleepMillis) {
+ if (dir == null) {
+ return false;
+ }
+ if (dir.isDirectory()) {
+ return true;
+ }
+ for (int i = 1; i <= tryCount; i++) { // 高并发场景下，可以看到 i 处于 1 ~ 3 之间
+ // 如果文件已存在，也会返回 false，所以该值不能作为是否能创建的依据，因此不对其进行处理
+ //noinspection ResultOfMethodCallIgnored
+ dir.mkdirs();
+ if (dir.exists()) {
+ return true;
+ }
+ ThreadUtil.sleep(sleepMillis);
+ }
+ return dir.exists();
+ }
+
/**
* 创建临时文件
* 创建后的文件名为 prefix[Randon].tmp
@@ -839,6 +921,54 @@ public class FileUtil extends PathUtil {
return createTempFile("hutool", null, dir, true);
}
+ /**
+ * 在默认临时文件目录下创建临时文件，创建后的文件名为 prefix[Randon].tmp。
+ * 默认临时文件目录由系统属性 {@code java.io.tmpdir} 指定。
+ * 在 UNIX 系统上，此属性的默认值通常是 {@code "tmp"} 或 {@code "vartmp"}；
+ * 在 Microsoft Windows 系统上，它通常是 {@code "C:\\WINNT\\TEMP"}。
+ * 调用 Java 虚拟机时，可以为该系统属性赋予不同的值，但不保证对该属性的编程更改对该方法使用的临时目录有任何影响。
+ * @return 临时文件
+ * @throws IORuntimeException IO异常
+ * @since 5.7.22
+ */
+ public static File createTempFile() throws IORuntimeException {
+ return createTempFile("hutool", null, null, true);
+ }
+
+ /**
+ * 在默认临时文件目录下创建临时文件，创建后的文件名为 prefix[Randon].suffix。
+ * 默认临时文件目录由系统属性 {@code java.io.tmpdir} 指定。
+ * 在 UNIX 系统上，此属性的默认值通常是 {@code "tmp"} 或 {@code "vartmp"}；
+ * 在 Microsoft Windows 系统上，它通常是 {@code "C:\\WINNT\\TEMP"}。
+ * 调用 Java 虚拟机时，可以为该系统属性赋予不同的值，但不保证对该属性的编程更改对该方法使用的临时目录有任何影响。
+ * @param suffix 后缀，如果null则使用默认.tmp
+ * @param isReCreat 是否重新创建文件（删掉原来的，创建新的）
+ * @return 临时文件
+ * @throws IORuntimeException IO异常
+ * @since 5.7.22
+ */
+ public static File createTempFile(String suffix, boolean isReCreat) throws IORuntimeException {
+ return createTempFile("hutool", suffix, null, isReCreat);
+ }
+
+ /**
+ * 在默认临时文件目录下创建临时文件，创建后的文件名为 prefix[Randon].suffix。
+ * 默认临时文件目录由系统属性 {@code java.io.tmpdir} 指定。
+ * 在 UNIX 系统上，此属性的默认值通常是 {@code "tmp"} 或 {@code "vartmp"}；
+ * 在 Microsoft Windows 系统上，它通常是 {@code "C:\\WINNT\\TEMP"}。
+ * 调用 Java 虚拟机时，可以为该系统属性赋予不同的值，但不保证对该属性的编程更改对该方法使用的临时目录有任何影响。
+ *
+ * @param prefix 前缀，至少3个字符
+ * @param suffix 后缀，如果null则使用默认.tmp
+ * @param isReCreat 是否重新创建文件（删掉原来的，创建新的）
+ * @return 临时文件
+ * @throws IORuntimeException IO异常
+ * @since 5.7.22
+ */
+ public static File createTempFile(String prefix, String suffix, boolean isReCreat) throws IORuntimeException {
+ return createTempFile(prefix, suffix, null, isReCreat);
+ }
+
/**
* 创建临时文件
* 创建后的文件名为 prefix[Randon].tmp
diff --git a/hutool-core/src/main/java/cn/hutool/core/io/NioUtil.java b/hutool-core/src/main/java/cn/hutool/core/io/NioUtil.java
index 2db343457..806105051 100644
--- a/hutool-core/src/main/java/cn/hutool/core/io/NioUtil.java
+++ b/hutool-core/src/main/java/cn/hutool/core/io/NioUtil.java
@@ -87,12 +87,49 @@ public class NioUtil {
Assert.notNull(outChannel, "Out channel is null!");
try {
- return inChannel.transferTo(0, inChannel.size(), outChannel);
+ return copySafely(inChannel, outChannel);
} catch (IOException e) {
throw new IORuntimeException(e);
}
}
+ /**
+ * 文件拷贝实现
+ *
+ *
+ * FileChannel#transferTo 或 FileChannel#transferFrom 的实现是平台相关的，需要确保低版本平台的兼容性
+ * 例如 android 7以下平台在使用 ZipInputStream 解压文件的过程中，
+ * 通过 FileChannel#transferFrom 传输到文件时，其返回值可能小于 totalBytes，不处理将导致文件内容缺失
+ *
+ * // 错误写法，dstChannel.transferFrom 返回值小于 zipEntry.getSize()，导致解压后文件内容缺失
+ * try (InputStream srcStream = zipFile.getInputStream(zipEntry);
+ * ReadableByteChannel srcChannel = Channels.newChannel(srcStream);
+ * FileOutputStream fos = new FileOutputStream(saveFile);
+ * FileChannel dstChannel = fos.getChannel()) {
+ * dstChannel.transferFrom(srcChannel, 0, zipEntry.getSize());
+ * }
+ *
+ *
+ * @param inChannel 输入通道
+ * @param outChannel 输出通道
+ * @return 输入通道的字节数
+ * @throws IOException 发生IO错误
+ * @link http://androidxref.com/6.0.1_r10/xref/libcore/luni/src/main/java/java/nio/FileChannelImpl.java
+ * @link http://androidxref.com/7.0.0_r1/xref/libcore/ojluni/src/main/java/sun/nio/ch/FileChannelImpl.java
+ * @link http://androidxref.com/7.0.0_r1/xref/libcore/ojluni/src/main/native/FileChannelImpl.c
+ * @author z8g
+ * @since 5.7.21
+ */
+ private static long copySafely(FileChannel inChannel, FileChannel outChannel) throws IOException {
+ final long totalBytes = inChannel.size();
+ for (long pos = 0, remaining = totalBytes; remaining > 0; ) { // 确保文件内容不会缺失
+ final long writeBytes = inChannel.transferTo(pos, remaining, outChannel); // 实际传输的字节数
+ pos += writeBytes;
+ remaining -= writeBytes;
+ }
+ return totalBytes;
+ }
+
/**
* 拷贝流，使用NIO，不会关闭channel
*
diff --git a/hutool-core/src/main/java/cn/hutool/core/io/checksum/CRC16.java b/hutool-core/src/main/java/cn/hutool/core/io/checksum/CRC16.java
index 0743ed5e3..26126a658 100644
--- a/hutool-core/src/main/java/cn/hutool/core/io/checksum/CRC16.java
+++ b/hutool-core/src/main/java/cn/hutool/core/io/checksum/CRC16.java
@@ -17,7 +17,7 @@ public class CRC16 implements Checksum, Serializable {
private final CRC16Checksum crc16;
- public CRC16(){
+ public CRC16() {
this(new CRC16IBM());
}
@@ -26,10 +26,31 @@ public class CRC16 implements Checksum, Serializable {
*
* @param crc16Checksum {@link CRC16Checksum} 实现
*/
- public CRC16(CRC16Checksum crc16Checksum){
+ public CRC16(CRC16Checksum crc16Checksum) {
this.crc16 = crc16Checksum;
}
+ /**
+ * 获取16进制的CRC16值
+ *
+ * @return 16进制的CRC16值
+ * @since 5.7.22
+ */
+ public String getHexValue() {
+ return this.crc16.getHexValue();
+ }
+
+ /**
+ * 获取16进制的CRC16值
+ *
+ * @param isPadding 不足4位时，是否填充0以满足位数
+ * @return 16进制的CRC16值，4位
+ * @since 5.7.22
+ */
+ public String getHexValue(boolean isPadding) {
+ return crc16.getHexValue(isPadding);
+ }
+
@Override
public long getValue() {
return crc16.getValue();
diff --git a/hutool-core/src/main/java/cn/hutool/core/io/resource/FileResource.java b/hutool-core/src/main/java/cn/hutool/core/io/resource/FileResource.java
index cb4179b95..3fcdea20a 100644
--- a/hutool-core/src/main/java/cn/hutool/core/io/resource/FileResource.java
+++ b/hutool-core/src/main/java/cn/hutool/core/io/resource/FileResource.java
@@ -20,6 +20,7 @@ public class FileResource implements Resource, Serializable {
private static final long serialVersionUID = 1L;
private final File file;
+ private final long lastModified;
private final String name;
// ----------------------------------------------------------------------- Constructor start
@@ -60,6 +61,7 @@ public class FileResource implements Resource, Serializable {
public FileResource(File file, String fileName) {
Assert.notNull(file, "File must be not null !");
this.file = file;
+ this.lastModified = file.lastModified();
this.name = ObjectUtil.defaultIfNull(fileName, file::getName);
}
@@ -89,6 +91,11 @@ public class FileResource implements Resource, Serializable {
return this.file;
}
+ @Override
+ public boolean isModified() {
+ return this.lastModified != file.lastModified();
+ }
+
/**
* 返回路径
* @return 返回URL路径
diff --git a/hutool-core/src/main/java/cn/hutool/core/io/resource/MultiResource.java b/hutool-core/src/main/java/cn/hutool/core/io/resource/MultiResource.java
index 8464aa808..608265bce 100644
--- a/hutool-core/src/main/java/cn/hutool/core/io/resource/MultiResource.java
+++ b/hutool-core/src/main/java/cn/hutool/core/io/resource/MultiResource.java
@@ -63,6 +63,11 @@ public class MultiResource implements Resource, Iterable, Iterator
+ * 一般用于文件类资源，检查文件是否被修改过。
+ *
+ * @return 是否变更
+ * @since 5.7.21
+ */
+ default boolean isModified(){
+ return false;
+ }
+
/**
* 将资源内容写出到流，不关闭输出流，但是关闭资源流
*
diff --git a/hutool-core/src/main/java/cn/hutool/core/io/resource/ResourceUtil.java b/hutool-core/src/main/java/cn/hutool/core/io/resource/ResourceUtil.java
index c6b18ac44..49b7d90ec 100644
--- a/hutool-core/src/main/java/cn/hutool/core/io/resource/ResourceUtil.java
+++ b/hutool-core/src/main/java/cn/hutool/core/io/resource/ResourceUtil.java
@@ -1,9 +1,10 @@
package cn.hutool.core.io.resource;
-import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.collection.EnumerationIter;
+import cn.hutool.core.collection.IterUtil;
import cn.hutool.core.io.FileUtil;
import cn.hutool.core.io.IORuntimeException;
+import cn.hutool.core.lang.Filter;
import cn.hutool.core.util.CharsetUtil;
import cn.hutool.core.util.ClassLoaderUtil;
import cn.hutool.core.util.StrUtil;
@@ -21,7 +22,6 @@ import java.util.List;
* Resource资源工具类
*
* @author Looly
- *
*/
public class ResourceUtil {
@@ -40,7 +40,7 @@ public class ResourceUtil {
* 读取Classpath下的资源为字符串
*
* @param resource 可以是绝对路径，也可以是相对路径（相对ClassPath）
- * @param charset 编码
+ * @param charset 编码
* @return 资源内容
* @since 3.1.1
*/
@@ -102,7 +102,7 @@ public class ResourceUtil {
* 从ClassPath资源中获取{@link BufferedReader}
*
* @param resource ClassPath资源
- * @param charset 编码
+ * @param charset 编码
* @return {@link InputStream}
* @since 3.1.2
*/
@@ -139,13 +139,24 @@ public class ResourceUtil {
* @return 资源列表
*/
public static List getResources(String resource) {
- final Enumeration resources;
- try {
- resources = ClassLoaderUtil.getClassLoader().getResources(resource);
- } catch (IOException e) {
- throw new IORuntimeException(e);
- }
- return CollUtil.newArrayList(resources);
+ return getResources(resource, null);
+ }
+
+ /**
+ * 获取指定路径下的资源列表
+ * 路径格式必须为目录格式,用/分隔，例如:
+ *
+ *
+ * config/a
+ * spring/xml
+ *
+ *
+ * @param resource 资源路径
+ * @param filter 过滤器，用于过滤不需要的资源，{@code null}表示不过滤，保留所有元素
+ * @return 资源列表
+ */
+ public static List getResources(String resource, Filter filter) {
+ return IterUtil.filterToList(getResourceIter(resource), filter);
}
/**
@@ -174,7 +185,7 @@ public class ResourceUtil {
/**
* 获得资源相对路径对应的URL
*
- * @param resource 资源相对路径，{@code null}和""都表示classpath根路径
+ * @param resource 资源相对路径，{@code null}和""都表示classpath根路径
* @param baseClass 基准Class，获得的相对路径相对于此Class所在路径，如果为{@code null}则相对ClassPath
* @return {@link URL}
*/
@@ -192,8 +203,8 @@ public class ResourceUtil {
* @since 3.2.1
*/
public static Resource getResourceObj(String path) {
- if(StrUtil.isNotBlank(path)) {
- if(path.startsWith(URLUtil.FILE_URL_PREFIX) || FileUtil.isAbsolutePath(path)) {
+ if (StrUtil.isNotBlank(path)) {
+ if (path.startsWith(URLUtil.FILE_URL_PREFIX) || FileUtil.isAbsolutePath(path)) {
return new FileResource(path);
}
}
diff --git a/hutool-core/src/main/java/cn/hutool/core/io/resource/UrlResource.java b/hutool-core/src/main/java/cn/hutool/core/io/resource/UrlResource.java
index fd6b23044..21f24b2ef 100644
--- a/hutool-core/src/main/java/cn/hutool/core/io/resource/UrlResource.java
+++ b/hutool-core/src/main/java/cn/hutool/core/io/resource/UrlResource.java
@@ -7,6 +7,7 @@ import cn.hutool.core.util.URLUtil;
import java.io.File;
import java.io.InputStream;
import java.io.Serializable;
+import java.net.URI;
import java.net.URL;
/**
@@ -18,9 +19,19 @@ public class UrlResource implements Resource, Serializable{
private static final long serialVersionUID = 1L;
protected URL url;
+ private long lastModified = 0;
protected String name;
//-------------------------------------------------------------------------------------- Constructor start
+ /**
+ * 构造
+ * @param uri URI
+ * @since 5.7.21
+ */
+ public UrlResource(URI uri) {
+ this(URLUtil.url(uri), null);
+ }
+
/**
* 构造
* @param url URL
@@ -36,6 +47,9 @@ public class UrlResource implements Resource, Serializable{
*/
public UrlResource(URL url, String name) {
this.url = url;
+ if(null != url && URLUtil.URL_PROTOCOL_FILE.equals(url.getProtocol())){
+ this.lastModified = FileUtil.file(url).lastModified();
+ }
this.name = ObjectUtil.defaultIfNull(name, () -> (null != url ? FileUtil.getName(url.getPath()) : null));
}
@@ -68,6 +82,12 @@ public class UrlResource implements Resource, Serializable{
return URLUtil.getStream(url);
}
+ @Override
+ public boolean isModified() {
+ // lastModified == 0表示此资源非文件资源
+ return (0 != this.lastModified) && this.lastModified != getFile().lastModified();
+ }
+
/**
* 获得File
* @return {@link File}
diff --git a/hutool-core/src/main/java/cn/hutool/core/io/resource/VfsResource.java b/hutool-core/src/main/java/cn/hutool/core/io/resource/VfsResource.java
new file mode 100755
index 000000000..2295d97c2
--- /dev/null
+++ b/hutool-core/src/main/java/cn/hutool/core/io/resource/VfsResource.java
@@ -0,0 +1,107 @@
+package cn.hutool.core.io.resource;
+
+import cn.hutool.core.lang.Assert;
+import cn.hutool.core.util.ClassLoaderUtil;
+import cn.hutool.core.util.ReflectUtil;
+
+import java.io.InputStream;
+import java.lang.reflect.Method;
+import java.net.URL;
+
+/**
+ * VFS资源封装
+ * 支持VFS 3.x on JBoss AS 6+，JBoss AS 7 and WildFly 8+
+ * 参考：org.springframework.core.io.VfsUtils
+ *
+ * @author looly, Spring
+ * @since 5.7.21
+ */
+public class VfsResource implements Resource {
+ private static final String VFS3_PKG = "org.jboss.vfs.";
+
+ private static final Method VIRTUAL_FILE_METHOD_EXISTS;
+ private static final Method VIRTUAL_FILE_METHOD_GET_INPUT_STREAM;
+ private static final Method VIRTUAL_FILE_METHOD_GET_SIZE;
+ private static final Method VIRTUAL_FILE_METHOD_GET_LAST_MODIFIED;
+ private static final Method VIRTUAL_FILE_METHOD_TO_URL;
+ private static final Method VIRTUAL_FILE_METHOD_GET_NAME;
+
+ static {
+ Class virtualFile = ClassLoaderUtil.loadClass(VFS3_PKG + "VirtualFile");
+ try {
+ VIRTUAL_FILE_METHOD_EXISTS = virtualFile.getMethod("exists");
+ VIRTUAL_FILE_METHOD_GET_INPUT_STREAM = virtualFile.getMethod("openStream");
+ VIRTUAL_FILE_METHOD_GET_SIZE = virtualFile.getMethod("getSize");
+ VIRTUAL_FILE_METHOD_GET_LAST_MODIFIED = virtualFile.getMethod("getLastModified");
+ VIRTUAL_FILE_METHOD_TO_URL = virtualFile.getMethod("toURL");
+ VIRTUAL_FILE_METHOD_GET_NAME = virtualFile.getMethod("getName");
+ } catch (NoSuchMethodException ex) {
+ throw new IllegalStateException("Could not detect JBoss VFS infrastructure", ex);
+ }
+ }
+
+ /**
+ * org.jboss.vfs.VirtualFile实例对象
+ */
+ private final Object virtualFile;
+ private final long lastModified;
+
+ /**
+ * 构造
+ *
+ * @param resource org.jboss.vfs.VirtualFile实例对象
+ */
+ public VfsResource(Object resource) {
+ Assert.notNull(resource, "VirtualFile must not be null");
+ this.virtualFile = resource;
+ this.lastModified = getLastModified();
+ }
+
+ /**
+ * VFS文件是否存在
+ *
+ * @return 文件是否存在
+ */
+ public boolean exists() {
+ return ReflectUtil.invoke(virtualFile, VIRTUAL_FILE_METHOD_EXISTS);
+ }
+
+ @Override
+ public String getName() {
+ return ReflectUtil.invoke(virtualFile, VIRTUAL_FILE_METHOD_GET_NAME);
+ }
+
+ @Override
+ public URL getUrl() {
+ return ReflectUtil.invoke(virtualFile, VIRTUAL_FILE_METHOD_TO_URL);
+ }
+
+ @Override
+ public InputStream getStream() {
+ return ReflectUtil.invoke(virtualFile, VIRTUAL_FILE_METHOD_GET_INPUT_STREAM);
+ }
+
+ @Override
+ public boolean isModified() {
+ return this.lastModified != getLastModified();
+ }
+
+ /**
+ * 获得VFS文件最后修改时间
+ *
+ * @return 最后修改时间
+ */
+ public long getLastModified() {
+ return ReflectUtil.invoke(virtualFile, VIRTUAL_FILE_METHOD_GET_LAST_MODIFIED);
+ }
+
+ /**
+ * 获取VFS文件大小
+ *
+ * @return VFS文件大小
+ */
+ public long size() {
+ return ReflectUtil.invoke(virtualFile, VIRTUAL_FILE_METHOD_GET_SIZE);
+ }
+
+}
diff --git a/hutool-core/src/main/java/cn/hutool/core/lang/func/Consumer3.java b/hutool-core/src/main/java/cn/hutool/core/lang/func/Consumer3.java
new file mode 100644
index 000000000..b40a2c387
--- /dev/null
+++ b/hutool-core/src/main/java/cn/hutool/core/lang/func/Consumer3.java
@@ -0,0 +1,23 @@
+package cn.hutool.core.lang.func;
+
+/**
+ * 3参数Consumer
+ *
+ * @param 参数一类型
+ * @param 参数二类型
+ * @param 参数三类型
+ * @author TomXin
+ * @since 5.7.22
+ */
+@FunctionalInterface
+public interface Consumer3 {
+
+ /**
+ * 接收参数方法
+ *
+ * @param p1 参数一
+ * @param p2 参数二
+ * @param p3 参数三
+ */
+ void accept(P1 p1, P2 p2, P3 p3);
+}
diff --git a/hutool-core/src/main/java/cn/hutool/core/lang/func/Supplier1.java b/hutool-core/src/main/java/cn/hutool/core/lang/func/Supplier1.java
new file mode 100755
index 000000000..376c91a2a
--- /dev/null
+++ b/hutool-core/src/main/java/cn/hutool/core/lang/func/Supplier1.java
@@ -0,0 +1,32 @@
+package cn.hutool.core.lang.func;
+
+import java.util.function.Supplier;
+
+/**
+ * 1参数Supplier
+ *
+ * @param 目标 类型
+ * @param 参数一 类型
+ * @author TomXin
+ * @since 5.7.21
+ */
+@FunctionalInterface
+public interface Supplier1 {
+ /**
+ * 生成实例的方法
+ *
+ * @param p1 参数一
+ * @return 目标对象
+ */
+ T get(P1 p1);
+
+ /**
+ * 将带有参数的Supplier转换为无参{@link Supplier}
+ *
+ * @param p1 参数1
+ * @return {@link Supplier}
+ */
+ default Supplier toSupplier(P1 p1) {
+ return () -> get(p1);
+ }
+}
diff --git a/hutool-core/src/main/java/cn/hutool/core/lang/func/Supplier2.java b/hutool-core/src/main/java/cn/hutool/core/lang/func/Supplier2.java
new file mode 100755
index 000000000..6d5e9ce80
--- /dev/null
+++ b/hutool-core/src/main/java/cn/hutool/core/lang/func/Supplier2.java
@@ -0,0 +1,36 @@
+package cn.hutool.core.lang.func;
+
+import java.util.function.Supplier;
+
+/**
+ * 两个参数的Supplier
+ *
+ * @param 目标 类型
+ * @param 参数一 类型
+ * @param 参数二 类型
+ * @author TomXin
+ * @since 5.7.21
+ */
+@FunctionalInterface
+public interface Supplier2 {
+
+ /**
+ * 生成实例的方法
+ *
+ * @param p1 参数一
+ * @param p2 参数二
+ * @return 目标对象
+ */
+ T get(P1 p1, P2 p2);
+
+ /**
+ * 将带有参数的Supplier转换为无参{@link Supplier}
+ *
+ * @param p1 参数1
+ * @param p2 参数2
+ * @return {@link Supplier}
+ */
+ default Supplier toSupplier(P1 p1, P2 p2) {
+ return () -> get(p1, p2);
+ }
+}
diff --git a/hutool-core/src/main/java/cn/hutool/core/lang/func/Supplier3.java b/hutool-core/src/main/java/cn/hutool/core/lang/func/Supplier3.java
new file mode 100755
index 000000000..50324e55b
--- /dev/null
+++ b/hutool-core/src/main/java/cn/hutool/core/lang/func/Supplier3.java
@@ -0,0 +1,39 @@
+package cn.hutool.core.lang.func;
+
+import java.util.function.Supplier;
+
+/**
+ * 3参数Supplier
+ *
+ * @param 目标类型
+ * @param 参数一类型
+ * @param 参数二类型
+ * @param 参数三类型
+ * @author TomXin
+ * @since 5.7.21
+ */
+@FunctionalInterface
+public interface Supplier3 {
+
+ /**
+ * 生成实例的方法
+ *
+ * @param p1 参数一
+ * @param p2 参数二
+ * @param p3 参数三
+ * @return 目标对象
+ */
+ T get(P1 p1, P2 p2, P3 p3);
+
+ /**
+ * 将带有参数的Supplier转换为无参{@link Supplier}
+ *
+ * @param p1 参数1
+ * @param p2 参数2
+ * @param p3 参数3
+ * @return {@link Supplier}
+ */
+ default Supplier toSupplier(P1 p1, P2 p2, P3 p3) {
+ return () -> get(p1, p2, p3);
+ }
+}
diff --git a/hutool-core/src/main/java/cn/hutool/core/lang/func/Supplier4.java b/hutool-core/src/main/java/cn/hutool/core/lang/func/Supplier4.java
new file mode 100755
index 000000000..c715b8693
--- /dev/null
+++ b/hutool-core/src/main/java/cn/hutool/core/lang/func/Supplier4.java
@@ -0,0 +1,42 @@
+package cn.hutool.core.lang.func;
+
+import java.util.function.Supplier;
+
+/**
+ * 4参数Supplier
+ *
+ * @param 目标 类型
+ * @param 参数一 类型
+ * @param 参数二 类型
+ * @param 参数三 类型
+ * @param 参数四 类型
+ * @author TomXin
+ * @since 5.7.21
+ */
+@FunctionalInterface
+public interface Supplier4 {
+
+ /**
+ * 生成实例的方法
+ *
+ * @param p1 参数一
+ * @param p2 参数二
+ * @param p3 参数三
+ * @param p4 参数四
+ * @return 目标对象
+ */
+ T get(P1 p1, P2 p2, P3 p3, P4 p4);
+
+ /**
+ * 将带有参数的Supplier转换为无参{@link Supplier}
+ *
+ * @param p1 参数1
+ * @param p2 参数2
+ * @param p3 参数3
+ * @param p4 参数4
+ * @return {@link Supplier}
+ */
+ default Supplier toSupplier(P1 p1, P2 p2, P3 p3, P4 p4) {
+ return () -> get(p1, p2, p3, p4);
+ }
+}
diff --git a/hutool-core/src/main/java/cn/hutool/core/lang/func/Supplier5.java b/hutool-core/src/main/java/cn/hutool/core/lang/func/Supplier5.java
new file mode 100755
index 000000000..121a2ce9c
--- /dev/null
+++ b/hutool-core/src/main/java/cn/hutool/core/lang/func/Supplier5.java
@@ -0,0 +1,45 @@
+package cn.hutool.core.lang.func;
+
+import java.util.function.Supplier;
+
+/**
+ * 5参数Supplier
+ *
+ * @param 目标 类型
+ * @param 参数一 类型
+ * @param 参数二 类型
+ * @param 参数三 类型
+ * @param 参数四 类型
+ * @param 参数五 类型
+ * @author TomXin
+ * @since 5.7.21
+ */
+@FunctionalInterface
+public interface Supplier5 {
+
+ /**
+ * 生成实例的方法
+ *
+ * @param p1 参数一
+ * @param p2 参数二
+ * @param p3 参数三
+ * @param p4 参数四
+ * @param p5 参数五
+ * @return 目标对象
+ */
+ T get(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5);
+
+ /**
+ * 将带有参数的Supplier转换为无参{@link Supplier}
+ *
+ * @param p1 参数1
+ * @param p2 参数2
+ * @param p3 参数3
+ * @param p4 参数4
+ * @param p5 参数5
+ * @return {@link Supplier}
+ */
+ default Supplier toSupplier(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) {
+ return () -> get(p1, p2, p3, p4, p5);
+ }
+}
diff --git a/hutool-core/src/main/java/cn/hutool/core/lang/hash/CityHash.java b/hutool-core/src/main/java/cn/hutool/core/lang/hash/CityHash.java
index aad2da056..b5558ea74 100644
--- a/hutool-core/src/main/java/cn/hutool/core/lang/hash/CityHash.java
+++ b/hutool-core/src/main/java/cn/hutool/core/lang/hash/CityHash.java
@@ -1,5 +1,7 @@
package cn.hutool.core.lang.hash;
+import cn.hutool.core.util.ByteUtil;
+
import java.util.Arrays;
/**
@@ -140,11 +142,11 @@ public class CityHash {
len = (len - 1) & ~63;
int pos = 0;
do {
- x = rotate(x + y + v.getLowValue() + fetch64(data, pos + 8), 37) * k1;
- y = rotate(y + v.getHighValue() + fetch64(data, pos + 48), 42) * k1;
+ x = rotate64(x + y + v.getLowValue() + fetch64(data, pos + 8), 37) * k1;
+ y = rotate64(y + v.getHighValue() + fetch64(data, pos + 48), 42) * k1;
x ^= w.getHighValue();
y += v.getLowValue() + fetch64(data, pos + 40);
- z = rotate(z + w.getLowValue(), 33) * k1;
+ z = rotate64(z + w.getLowValue(), 33) * k1;
v = weakHashLen32WithSeeds(data, pos, v.getHighValue() * k1, x + w.getLowValue());
w = weakHashLen32WithSeeds(data, pos + 32, z + w.getHighValue(), y + fetch64(data, pos + 16));
// swap z,x value
@@ -221,19 +223,19 @@ public class CityHash {
long x = seed.getLowValue();
long y = seed.getHighValue();
long z = len * k1;
- v.setLowValue(rotate(y ^ k1, 49) * k1 + fetch64(byteArray, start));
- v.setHighValue(rotate(v.getLowValue(), 42) * k1 + fetch64(byteArray, start + 8));
- w.setLowValue(rotate(y + z, 35) * k1 + x);
- w.setHighValue(rotate(x + fetch64(byteArray, start + 88), 53) * k1);
+ v.setLowValue(rotate64(y ^ k1, 49) * k1 + fetch64(byteArray, start));
+ v.setHighValue(rotate64(v.getLowValue(), 42) * k1 + fetch64(byteArray, start + 8));
+ w.setLowValue(rotate64(y + z, 35) * k1 + x);
+ w.setHighValue(rotate64(x + fetch64(byteArray, start + 88), 53) * k1);
// This is the same inner loop as CityHash64(), manually unrolled.
int pos = start;
do {
- x = rotate(x + y + v.getLowValue() + fetch64(byteArray, pos + 8), 37) * k1;
- y = rotate(y + v.getHighValue() + fetch64(byteArray, pos + 48), 42) * k1;
+ x = rotate64(x + y + v.getLowValue() + fetch64(byteArray, pos + 8), 37) * k1;
+ y = rotate64(y + v.getHighValue() + fetch64(byteArray, pos + 48), 42) * k1;
x ^= w.getHighValue();
y += v.getLowValue() + fetch64(byteArray, pos + 40);
- z = rotate(z + w.getLowValue(), 33) * k1;
+ z = rotate64(z + w.getLowValue(), 33) * k1;
v = weakHashLen32WithSeeds(byteArray, pos, v.getHighValue() * k1, x + w.getLowValue());
w = weakHashLen32WithSeeds(byteArray, pos + 32, z + w.getHighValue(), y + fetch64(byteArray, pos + 16));
@@ -241,11 +243,11 @@ public class CityHash {
x = z;
z = swapValue;
pos += 64;
- x = rotate(x + y + v.getLowValue() + fetch64(byteArray, pos + 8), 37) * k1;
- y = rotate(y + v.getHighValue() + fetch64(byteArray, pos + 48), 42) * k1;
+ x = rotate64(x + y + v.getLowValue() + fetch64(byteArray, pos + 8), 37) * k1;
+ y = rotate64(y + v.getHighValue() + fetch64(byteArray, pos + 48), 42) * k1;
x ^= w.getHighValue();
y += v.getLowValue() + fetch64(byteArray, pos + 40);
- z = rotate(z + w.getLowValue(), 33) * k1;
+ z = rotate64(z + w.getLowValue(), 33) * k1;
v = weakHashLen32WithSeeds(byteArray, pos, v.getHighValue() * k1, x + w.getLowValue());
w = weakHashLen32WithSeeds(byteArray, pos + 32, z + w.getHighValue(), y + fetch64(byteArray, pos + 16));
swapValue = x;
@@ -254,16 +256,16 @@ public class CityHash {
pos += 64;
len -= 128;
} while (len >= 128);
- x += rotate(v.getLowValue() + z, 49) * k0;
- y = y * k0 + rotate(w.getHighValue(), 37);
- z = z * k0 + rotate(w.getLowValue(), 27);
+ x += rotate64(v.getLowValue() + z, 49) * k0;
+ y = y * k0 + rotate64(w.getHighValue(), 37);
+ z = z * k0 + rotate64(w.getLowValue(), 27);
w.setLowValue(w.getLowValue() * 9);
v.setLowValue(v.getLowValue() * k0);
// If 0 < len < 128, hash up to 4 chunks of 32 bytes each from the end of s.
for (int tail_done = 0; tail_done < len; ) {
tail_done += 32;
- y = rotate(x + y, 42) * k0 + v.getHighValue();
+ y = rotate64(x + y, 42) * k0 + v.getHighValue();
w.setLowValue(w.getLowValue() + fetch64(byteArray, pos + len - tail_done + 16));
x = x * k0 + w.getLowValue();
z += w.getHighValue() + fetch64(byteArray, pos + len - tail_done);
@@ -321,8 +323,8 @@ public class CityHash {
long mul = k2 + len * 2L;
long a = fetch64(byteArray, 0) + k2;
long b = fetch64(byteArray, len - 8);
- long c = rotate(b, 37) * mul + a;
- long d = (rotate(a, 25) + b) * mul;
+ long c = rotate64(b, 37) * mul + a;
+ long d = (rotate64(a, 25) + b) * mul;
return hashLen16(c, d, mul);
}
if (len >= 4) {
@@ -349,8 +351,8 @@ public class CityHash {
long b = fetch64(byteArray, 8);
long c = fetch64(byteArray, len - 8) * mul;
long d = fetch64(byteArray, len - 16) * k2;
- return hashLen16(rotate(a + b, 43) + rotate(c, 30) + d,
- a + rotate(b + k2, 18) + c, mul);
+ return hashLen16(rotate64(a + b, 43) + rotate64(c, 30) + d,
+ a + rotate64(b + k2, 18) + c, mul);
}
private static long hashLen33to64(byte[] byteArray) {
@@ -364,10 +366,10 @@ public class CityHash {
long f = fetch64(byteArray, 24) * 9;
long g = fetch64(byteArray, len - 8);
long h = fetch64(byteArray, len - 16) * mul;
- long u = rotate(a + g, 43) + (rotate(b, 30) + c) * 9;
+ long u = rotate64(a + g, 43) + (rotate64(b, 30) + c) * 9;
long v = ((a + g) ^ d) + f + 1;
long w = Long.reverseBytes((u + v) * mul) + h;
- long x = rotate(e + f, 42) + c;
+ long x = rotate64(e + f, 42) + c;
long y = (Long.reverseBytes((v + w) * mul) + g) * mul;
long z = e + f + c;
a = Long.reverseBytes((x + z) * mul + y) + b;
@@ -375,37 +377,15 @@ public class CityHash {
return b + x;
}
- private static long loadUnaligned64(final byte[] byteArray, final int start) {
- long result = 0;
- OrderIter orderIter = new OrderIter(8);
- while (orderIter.hasNext()) {
- int next = orderIter.next();
- long value = (byteArray[next + start] & 0xffL) << (next * 8);
- result |= value;
- }
- return result;
- }
-
- private static int loadUnaligned32(final byte[] byteArray, final int start) {
- int result = 0;
- OrderIter orderIter = new OrderIter(4);
- while (orderIter.hasNext()) {
- int next = orderIter.next();
- int value = (byteArray[next + start] & 0xff) << (next * 8);
- result |= value;
- }
- return result;
- }
-
- private static long fetch64(byte[] byteArray, final int start) {
- return loadUnaligned64(byteArray, start);
+ private static long fetch64(byte[] byteArray, int start) {
+ return ByteUtil.bytesToLong(byteArray, start, ByteUtil.CPU_ENDIAN);
}
private static int fetch32(byte[] byteArray, final int start) {
- return loadUnaligned32(byteArray, start);
+ return ByteUtil.bytesToInt(byteArray, start, ByteUtil.CPU_ENDIAN);
}
- private static long rotate(long val, int shift) {
+ private static long rotate64(long val, int shift) {
// Avoid shifting by 64: doing so yields an undefined result.
return shift == 0 ? val : ((val >>> shift) | (val << (64 - shift)));
}
@@ -465,11 +445,11 @@ public class CityHash {
private static Number128 weakHashLen32WithSeeds(
long w, long x, long y, long z, long a, long b) {
a += w;
- b = rotate(b + a + z, 21);
+ b = rotate64(b + a + z, 21);
long c = a;
a += x;
a += y;
- b += rotate(a, 44);
+ b += rotate64(a, 44);
return new Number128(a + z, b + c);
}
@@ -515,24 +495,5 @@ public class CityHash {
b = hashLen16(d, b);
return new Number128(a ^ b, hashLen16(b, a));
}
-
- private static class OrderIter {
- private static final boolean IS_LITTLE_ENDIAN = "little".equals(System.getProperty("sun.cpu.endian"));
-
- private final int size;
- private int index;
-
- OrderIter(int size) {
- this.size = size;
- }
-
- boolean hasNext() {
- return index < size;
- }
-
- int next() {
- return IS_LITTLE_ENDIAN ? index++ : (size - 1 - index++);
- }
- }
//------------------------------------------------------------------------------------------------------- Private method end
}
diff --git a/hutool-core/src/main/java/cn/hutool/core/lang/hash/MetroHash.java b/hutool-core/src/main/java/cn/hutool/core/lang/hash/MetroHash.java
new file mode 100644
index 000000000..bbf40c882
--- /dev/null
+++ b/hutool-core/src/main/java/cn/hutool/core/lang/hash/MetroHash.java
@@ -0,0 +1,217 @@
+package cn.hutool.core.lang.hash;
+
+import cn.hutool.core.util.ByteUtil;
+
+import java.nio.ByteOrder;
+import java.util.Arrays;
+
+/**
+ * Apache 发布的MetroHash算法，是一组用于非加密用例的最先进的哈希函数。
+ * 除了卓越的性能外，他们还以算法生成而著称。
+ *
+ *
+ * 官方实现：https://github.com/jandrewrogers/MetroHash
+ * 官方文档：http://www.jandrewrogers.com/2015/05/27/metrohash/
+ * Go语言实现：https://github.com/linvon/cuckoo-filter/blob/main/vendor/github.com/dgryski/go-metro/
+ * @author li
+ */
+public class MetroHash {
+
+ /**
+ * hash64 种子加盐
+ */
+ private final static long k0_64 = 0xD6D018F5;
+ private final static long k1_64 = 0xA2AA033B;
+ private final static long k2_64 = 0x62992FC1;
+ private final static long k3_64 = 0x30BC5B29;
+
+ /**
+ * hash128 种子加盐
+ */
+ private final static long k0_128 = 0xC83A91E1;
+ private final static long k1_128 = 0x8648DBDB;
+ private final static long k2_128 = 0x7BDEC03B;
+ private final static long k3_128 = 0x2F5870A5;
+
+ public static long hash64(byte[] data) {
+ return hash64(data, 1337);
+ }
+
+ public static Number128 hash128(byte[] data) {
+ return hash128(data, 1337);
+ }
+
+ public static long hash64(byte[] data, long seed) {
+ byte[] buffer = data;
+ long hash = (seed + k2_64) * k0_64;
+
+ long v0, v1, v2, v3;
+ v0 = hash;
+ v1 = hash;
+ v2 = hash;
+ v3 = hash;
+
+ if (buffer.length >= 32) {
+
+ while (buffer.length >= 32) {
+ v0 += littleEndian64(buffer, 0) * k0_64;
+ v0 = rotateLeft64(v0, -29) + v2;
+ v1 += littleEndian64(buffer, 8) * k1_64;
+ v1 = rotateLeft64(v1, -29) + v3;
+ v2 += littleEndian64(buffer, 24) * k2_64;
+ v2 = rotateLeft64(v2, -29) + v0;
+ v3 += littleEndian64(buffer, 32) * k3_64;
+ v3 = rotateLeft64(v3, -29) + v1;
+ buffer = Arrays.copyOfRange(buffer, 32, buffer.length);
+ }
+
+ v2 ^= rotateLeft64(((v0 + v3) * k0_64) + v1, -37) * k1_64;
+ v3 ^= rotateLeft64(((v1 + v2) * k1_64) + v0, -37) * k0_64;
+ v0 ^= rotateLeft64(((v0 + v2) * k0_64) + v3, -37) * k1_64;
+ v1 ^= rotateLeft64(((v1 + v3) * k1_64) + v2, -37) * k0_64;
+ hash += v0 ^ v1;
+ }
+
+ if (buffer.length >= 16) {
+ v0 = hash + littleEndian64(buffer, 0) * k2_64;
+ v0 = rotateLeft64(v0, -29) * k3_64;
+ v1 = hash + littleEndian64(buffer, 8) * k2_64;
+ v1 = rotateLeft64(v1, -29) * k3_64;
+ v0 ^= rotateLeft64(v0 * k0_64, -21) + v1;
+ v1 ^= rotateLeft64(v1 * k3_64, -21) + v0;
+ hash += v1;
+ buffer = Arrays.copyOfRange(buffer, 16, buffer.length);
+ }
+
+ if (buffer.length >= 8) {
+ hash += littleEndian64(buffer, 0) * k3_64;
+ buffer = Arrays.copyOfRange(buffer, 8, buffer.length);
+ hash ^= rotateLeft64(hash, -55) * k1_64;
+ }
+
+ if (buffer.length >= 4) {
+ hash += (long) littleEndian32(Arrays.copyOfRange(buffer, 0, 4)) * k3_64;
+ hash ^= rotateLeft64(hash, -26) * k1_64;
+ buffer = Arrays.copyOfRange(buffer, 4, buffer.length);
+ }
+
+ if (buffer.length >= 2) {
+ hash += (long) littleEndian16(Arrays.copyOfRange(buffer, 0, 2)) * k3_64;
+ buffer = Arrays.copyOfRange(buffer, 2, buffer.length);
+ hash ^= rotateLeft64(hash, -48) * k1_64;
+ }
+
+ if (buffer.length >= 1) {
+ hash += (long) buffer[0] * k3_64;
+ hash ^= rotateLeft64(hash, -38) * k1_64;
+ }
+
+ hash ^= rotateLeft64(hash, -28);
+ hash *= k0_64;
+ hash ^= rotateLeft64(hash, -29);
+
+ return hash;
+ }
+
+ public static Number128 hash128(byte[] data, long seed) {
+ byte[] buffer = data;
+
+ long v0, v1, v2, v3;
+
+ v0 = (seed - k0_128) * k3_128;
+ v1 = (seed + k1_128) * k2_128;
+
+ if (buffer.length >= 32) {
+ v2 = (seed + k0_128) * k2_128;
+ v3 = (seed - k1_128) * k3_128;
+
+ while (buffer.length >= 32) {
+ v0 += littleEndian64(buffer, 0) * k0_128;
+ buffer = Arrays.copyOfRange(buffer, 8, buffer.length);
+ v0 = rotateRight(v0, 29) + v2;
+ v1 += littleEndian64(buffer, 0) * k1_128;
+ buffer = Arrays.copyOfRange(buffer, 8, buffer.length);
+ v1 = rotateRight(v1, 29) + v3;
+ v2 += littleEndian64(buffer, 0) * k2_128;
+ buffer = Arrays.copyOfRange(buffer, 8, buffer.length);
+ v2 = rotateRight(v2, 29) + v0;
+ v3 = littleEndian64(buffer, 0) * k3_128;
+ buffer = Arrays.copyOfRange(buffer, 8, buffer.length);
+ v3 = rotateRight(v3, 29) + v1;
+ }
+
+ v2 ^= rotateRight(((v0 + v3) * k0_128) + v1, 21) * k1_128;
+ v3 ^= rotateRight(((v1 + v2) * k1_128) + v0, 21) * k0_128;
+ v0 ^= rotateRight(((v0 + v2) * k0_128) + v3, 21) * k1_128;
+ v1 ^= rotateRight(((v1 + v3) * k1_128) + v2, 21) * k0_128;
+ }
+
+ if (buffer.length >= 16) {
+ v0 += littleEndian64(buffer, 0) * k2_128;
+ buffer = Arrays.copyOfRange(buffer, 8, buffer.length);
+ v0 = rotateRight(v0, 33) * k3_128;
+ v1 += littleEndian64(buffer, 0) * k2_128;
+ buffer = Arrays.copyOfRange(buffer, 8, buffer.length);
+ v1 = rotateRight(v1, 33) * k3_128;
+ v0 ^= rotateRight((v0 * k2_128) + v1, 45) + k1_128;
+ v1 ^= rotateRight((v1 * k3_128) + v0, 45) + k0_128;
+ }
+
+ if (buffer.length >= 8) {
+ v0 += littleEndian64(buffer, 0) * k2_128;
+ buffer = Arrays.copyOfRange(buffer, 8, buffer.length);
+ v0 = rotateRight(v0, 33) * k3_128;
+ v0 ^= rotateRight((v0 * k2_128) + v1, 27) * k1_128;
+ }
+
+ if (buffer.length >= 4) {
+ v1 += (long) littleEndian32(buffer) * k2_128;
+ buffer = Arrays.copyOfRange(buffer, 4, buffer.length);
+ v1 = rotateRight(v1, 33) * k3_128;
+ v1 ^= rotateRight((v1 * k3_128) + v0, 46) * k0_128;
+ }
+
+ if (buffer.length >= 2) {
+ v0 += (long) littleEndian16(buffer) * k2_128;
+ buffer = Arrays.copyOfRange(buffer, 2, buffer.length);
+ v0 = rotateRight(v0, 33) * k3_128;
+ v0 ^= rotateRight((v0 * k2_128) * v1, 22) * k1_128;
+ }
+
+ if (buffer.length >= 1) {
+ v1 += (long) buffer[0] * k2_128;
+ v1 = rotateRight(v1, 33) * k3_128;
+ v1 ^= rotateRight((v1 * k3_128) + v0, 58) * k0_128;
+ }
+
+ v0 += rotateRight((v0 * k0_128) + v1, 13);
+ v1 += rotateRight((v1 * k1_128) + v0, 37);
+ v0 += rotateRight((v0 * k2_128) + v1, 13);
+ v1 += rotateRight((v1 * k3_128) + v0, 37);
+
+ return new Number128(v0, v1);
+ }
+
+
+ private static long littleEndian64(byte[] b, int start) {
+ return ByteUtil.bytesToLong(b, start, ByteOrder.LITTLE_ENDIAN);
+ }
+
+ private static int littleEndian32(byte[] b) {
+ return (int) b[0] | (int) b[1] << 8 | (int) b[2] << 16 | (int) b[3] << 24;
+ }
+
+ private static int littleEndian16(byte[] b) {
+ return ByteUtil.bytesToShort(b, ByteOrder.LITTLE_ENDIAN);
+ }
+
+ private static long rotateLeft64(long x, int k) {
+ int n = 64;
+ int s = k & (n - 1);
+ return x << s | x >> (n - s);
+ }
+
+ private static long rotateRight(long val, int shift) {
+ return (val >> shift) | (val << (64 - shift));
+ }
+}
diff --git a/hutool-core/src/main/java/cn/hutool/core/lang/hash/MurmurHash.java b/hutool-core/src/main/java/cn/hutool/core/lang/hash/MurmurHash.java
index b3dd26961..94826602b 100644
--- a/hutool-core/src/main/java/cn/hutool/core/lang/hash/MurmurHash.java
+++ b/hutool-core/src/main/java/cn/hutool/core/lang/hash/MurmurHash.java
@@ -1,9 +1,11 @@
package cn.hutool.core.lang.hash;
+import cn.hutool.core.util.ByteUtil;
import cn.hutool.core.util.CharsetUtil;
import cn.hutool.core.util.StrUtil;
import java.io.Serializable;
+import java.nio.ByteOrder;
import java.nio.charset.Charset;
/**
@@ -41,6 +43,7 @@ public class MurmurHash implements Serializable{
private static final int DEFAULT_SEED = 0;
private static final Charset DEFAULT_CHARSET = CharsetUtil.CHARSET_UTF_8;
+ private static final ByteOrder DEFAULT_ORDER = ByteOrder.LITTLE_ENDIAN;
/**
* Murmur3 32-bit Hash值计算
@@ -76,11 +79,8 @@ public class MurmurHash implements Serializable{
// body
for (int i = 0; i < nblocks; i++) {
- int i_4 = i << 2;
- int k = (data[i_4] & 0xff) //
- | ((data[i_4 + 1] & 0xff) << 8) //
- | ((data[i_4 + 2] & 0xff) << 16) //
- | ((data[i_4 + 3] & 0xff) << 24);
+ int i4 = i << 2;
+ int k = ByteUtil.bytesToInt(data, i4, DEFAULT_ORDER);
// mix functions
k *= C1_32;
@@ -157,14 +157,7 @@ public class MurmurHash implements Serializable{
// body
for (int i = 0; i < nblocks; i++) {
final int i8 = i << 3;
- long k = ((long) data[i8] & 0xff) //
- | (((long) data[i8 + 1] & 0xff) << 8) //
- | (((long) data[i8 + 2] & 0xff) << 16) //
- | (((long) data[i8 + 3] & 0xff) << 24) //
- | (((long) data[i8 + 4] & 0xff) << 32)//
- | (((long) data[i8 + 5] & 0xff) << 40) //
- | (((long) data[i8 + 6] & 0xff) << 48) //
- | (((long) data[i8 + 7] & 0xff) << 56);
+ long k = ByteUtil.bytesToLong(data, i8, DEFAULT_ORDER);
// mix functions
k *= C1;
@@ -241,23 +234,8 @@ public class MurmurHash implements Serializable{
// body
for (int i = 0; i < nblocks; i++) {
final int i16 = i << 4;
- long k1 = ((long) data[i16] & 0xff) //
- | (((long) data[i16 + 1] & 0xff) << 8) //
- | (((long) data[i16 + 2] & 0xff) << 16) //
- | (((long) data[i16 + 3] & 0xff) << 24) //
- | (((long) data[i16 + 4] & 0xff) << 32) //
- | (((long) data[i16 + 5] & 0xff) << 40) //
- | (((long) data[i16 + 6] & 0xff) << 48) //
- | (((long) data[i16 + 7] & 0xff) << 56);
-
- long k2 = ((long) data[i16 + 8] & 0xff) //
- | (((long) data[i16 + 9] & 0xff) << 8) //
- | (((long) data[i16 + 10] & 0xff) << 16) //
- | (((long) data[i16 + 11] & 0xff) << 24) //
- | (((long) data[i16 + 12] & 0xff) << 32) //
- | (((long) data[i16 + 13] & 0xff) << 40) //
- | (((long) data[i16 + 14] & 0xff) << 48) //
- | (((long) data[i16 + 15] & 0xff) << 56);
+ long k1 = ByteUtil.bytesToLong(data, i16, DEFAULT_ORDER);
+ long k2 = ByteUtil.bytesToLong(data, i16 + 8, DEFAULT_ORDER);
// mix functions for k1
k1 *= C1;
diff --git a/hutool-core/src/main/java/cn/hutool/core/lang/hash/Number128.java b/hutool-core/src/main/java/cn/hutool/core/lang/hash/Number128.java
index 4f6301095..12e0a8c35 100644
--- a/hutool-core/src/main/java/cn/hutool/core/lang/hash/Number128.java
+++ b/hutool-core/src/main/java/cn/hutool/core/lang/hash/Number128.java
@@ -6,7 +6,7 @@ package cn.hutool.core.lang.hash;
* @author hexiufeng
* @since 5.2.5
*/
-public class Number128 extends Number{
+public class Number128 extends Number {
private static final long serialVersionUID = 1L;
private long lowValue;
@@ -23,22 +23,47 @@ public class Number128 extends Number{
this.highValue = highValue;
}
+ /**
+ * 获取低位值
+ *
+ * @return 地位值
+ */
public long getLowValue() {
return lowValue;
}
- public long getHighValue() {
- return highValue;
- }
-
+ /**
+ * 设置低位值
+ *
+ * @param lowValue 低位值
+ */
public void setLowValue(long lowValue) {
this.lowValue = lowValue;
}
+ /**
+ * 获取高位值
+ *
+ * @return 高位值
+ */
+ public long getHighValue() {
+ return highValue;
+ }
+
+ /**
+ * 设置高位值
+ *
+ * @param hiValue 高位值
+ */
public void setHighValue(long hiValue) {
this.highValue = hiValue;
}
+ /**
+ * 获取高低位数组，long[0]：低位，long[1]：高位
+ *
+ * @return 高低位数组，long[0]：低位，long[1]：高位
+ */
public long[] getLongArray() {
return new long[]{lowValue, highValue};
}
diff --git a/hutool-core/src/main/java/cn/hutool/core/lang/tree/TreeBuilder.java b/hutool-core/src/main/java/cn/hutool/core/lang/tree/TreeBuilder.java
index 37af3f94a..ebc1e0c13 100644
--- a/hutool-core/src/main/java/cn/hutool/core/lang/tree/TreeBuilder.java
+++ b/hutool-core/src/main/java/cn/hutool/core/lang/tree/TreeBuilder.java
@@ -228,7 +228,6 @@ public class TreeBuilder implements Builder> {
}
final Map> eTreeMap = MapUtil.sortByValue(this.idTreeMap, false);
- List> rootTreeList = CollUtil.newArrayList();
E parentId;
for (Tree node : eTreeMap.values()) {
if (null == node) {
@@ -237,7 +236,6 @@ public class TreeBuilder implements Builder> {
parentId = node.getParentId();
if (ObjectUtil.equals(this.root.getId(), parentId)) {
this.root.addChildren(node);
- rootTreeList.add(node);
continue;
}
diff --git a/hutool-core/src/main/java/cn/hutool/core/map/CaseInsensitiveTreeMap.java b/hutool-core/src/main/java/cn/hutool/core/map/CaseInsensitiveTreeMap.java
new file mode 100755
index 000000000..7f8b065f6
--- /dev/null
+++ b/hutool-core/src/main/java/cn/hutool/core/map/CaseInsensitiveTreeMap.java
@@ -0,0 +1,73 @@
+package cn.hutool.core.map;
+
+import java.util.Comparator;
+import java.util.Map;
+import java.util.SortedMap;
+import java.util.TreeMap;
+
+/**
+ * 忽略大小写的{@link TreeMap}
+ * 对KEY忽略大小写，get("Value")和get("value")获得的值相同，put进入的值也会被覆盖
+ *
+ * @author Looly
+ *
+ * @param 键类型
+ * @param 值类型
+ * @since 3.3.1
+ */
+public class CaseInsensitiveTreeMap extends CustomKeyMap {
+ private static final long serialVersionUID = 4043263744224569870L;
+
+ // ------------------------------------------------------------------------- Constructor start
+ /**
+ * 构造
+ */
+ public CaseInsensitiveTreeMap() {
+ this((Comparator) null);
+ }
+
+ /**
+ * 构造
+ *
+ * @param m Map
+ * @since 3.1.2
+ */
+ public CaseInsensitiveTreeMap(Map m) {
+ this();
+ this.putAll(m);
+ }
+
+ /**
+ * 构造
+ *
+ * @param m Map
+ * @since 3.1.2
+ */
+ public CaseInsensitiveTreeMap(SortedMap m) {
+ super(new TreeMap(m));
+ }
+
+ /**
+ * 构造
+ *
+ * @param comparator 比较器，{@code null}表示使用默认比较器
+ */
+ public CaseInsensitiveTreeMap(Comparator comparator) {
+ super(new TreeMap<>(comparator));
+ }
+ // ------------------------------------------------------------------------- Constructor end
+
+ /**
+ * 将Key转为小写
+ *
+ * @param key KEY
+ * @return 小写KEY
+ */
+ @Override
+ protected Object customKey(Object key) {
+ if (key instanceof CharSequence) {
+ key = key.toString().toLowerCase();
+ }
+ return key;
+ }
+}
diff --git a/hutool-core/src/main/java/cn/hutool/core/map/MapBuilder.java b/hutool-core/src/main/java/cn/hutool/core/map/MapBuilder.java
index a8409e6d0..5840d9204 100644
--- a/hutool-core/src/main/java/cn/hutool/core/map/MapBuilder.java
+++ b/hutool-core/src/main/java/cn/hutool/core/map/MapBuilder.java
@@ -1,6 +1,8 @@
package cn.hutool.core.map;
-import java.io.Serializable;
+
+import cn.hutool.core.builder.Builder;
+
import java.util.Map;
import java.util.function.Supplier;
@@ -11,7 +13,7 @@ import java.util.function.Supplier;
* @param Value类型
* @since 3.1.1
*/
-public class MapBuilder implements Serializable {
+public class MapBuilder implements Builder> {
private static final long serialVersionUID = 1L;
private final Map map;
@@ -133,6 +135,7 @@ public class MapBuilder implements Serializable {
* @return 创建后的map
* @since 3.3.0
*/
+ @Override
public Map build() {
return map();
}
diff --git a/hutool-core/src/main/java/cn/hutool/core/net/DefaultTrustManager.java b/hutool-core/src/main/java/cn/hutool/core/net/DefaultTrustManager.java
index 65b112564..103c6d45a 100644
--- a/hutool-core/src/main/java/cn/hutool/core/net/DefaultTrustManager.java
+++ b/hutool-core/src/main/java/cn/hutool/core/net/DefaultTrustManager.java
@@ -15,7 +15,7 @@ import java.security.cert.X509Certificate;
public class DefaultTrustManager extends X509ExtendedTrustManager {
/**
- * 默认的全局单例默认信任管理器，，默认信任所有客户端和服务端证书
+ * 默认的全局单例默认信任管理器，默认信任所有客户端和服务端证书
* @since 5.7.8
*/
public static DefaultTrustManager INSTANCE = new DefaultTrustManager();
diff --git a/hutool-core/src/main/java/cn/hutool/core/net/SSLContextBuilder.java b/hutool-core/src/main/java/cn/hutool/core/net/SSLContextBuilder.java
index 8a0efced2..f7c783dc1 100644
--- a/hutool-core/src/main/java/cn/hutool/core/net/SSLContextBuilder.java
+++ b/hutool-core/src/main/java/cn/hutool/core/net/SSLContextBuilder.java
@@ -1,5 +1,6 @@
package cn.hutool.core.net;
+import cn.hutool.core.builder.Builder;
import cn.hutool.core.io.IORuntimeException;
import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.StrUtil;
@@ -20,14 +21,15 @@ import java.security.SecureRandom;
* {@link TrustManager}，默认{@link DefaultTrustManager}，即信任全部
* {@link SecureRandom}
*
- *
+ *
* 构建后可获得{@link SSLContext}，通过调用{@link SSLContext#getSocketFactory()}获取{@link javax.net.ssl.SSLSocketFactory}
*
* @author Looly
* @since 5.5.2
*/
-public class SSLContextBuilder implements SSLProtocols {
-
+public class SSLContextBuilder implements SSLProtocols, Builder {
+ private static final long serialVersionUID = 1L;
+
private String protocol = TLS;
private KeyManager[] keyManagers;
private TrustManager[] trustManagers = {DefaultTrustManager.INSTANCE};
@@ -99,10 +101,21 @@ public class SSLContextBuilder implements SSLProtocols {
* 构建{@link SSLContext}
*
* @return {@link SSLContext}
- * @throws NoSuchAlgorithmException 无此算法
- * @throws KeyManagementException Key管理异常
*/
- public SSLContext build() throws NoSuchAlgorithmException, KeyManagementException {
+ @Override
+ public SSLContext build() {
+ return buildQuietly();
+ }
+
+ /**
+ * 构建{@link SSLContext}需要处理异常
+ *
+ * @return {@link SSLContext}
+ * @throws NoSuchAlgorithmException 无此算法异常
+ * @throws KeyManagementException 密钥管理异常
+ * @since 5.7.22
+ */
+ public SSLContext buildChecked() throws NoSuchAlgorithmException, KeyManagementException {
SSLContext sslContext = SSLContext.getInstance(protocol);
sslContext.init(this.keyManagers, this.trustManagers, this.secureRandom);
return sslContext;
@@ -116,7 +129,7 @@ public class SSLContextBuilder implements SSLProtocols {
*/
public SSLContext buildQuietly() throws IORuntimeException {
try {
- return build();
+ return buildChecked();
} catch (GeneralSecurityException e) {
throw new IORuntimeException(e);
}
diff --git a/hutool-core/src/main/java/cn/hutool/core/net/SSLUtil.java b/hutool-core/src/main/java/cn/hutool/core/net/SSLUtil.java
index 8519f94e0..d608467a0 100644
--- a/hutool-core/src/main/java/cn/hutool/core/net/SSLUtil.java
+++ b/hutool-core/src/main/java/cn/hutool/core/net/SSLUtil.java
@@ -23,7 +23,7 @@ public class SSLUtil {
* @since 5.7.8
*/
public static SSLContext createSSLContext(String protocol) throws IORuntimeException{
- return SSLContextBuilder.create().setProtocol(protocol).buildQuietly();
+ return SSLContextBuilder.create().setProtocol(protocol).build();
}
/**
@@ -55,6 +55,6 @@ public class SSLUtil {
return SSLContextBuilder.create()
.setProtocol(protocol)
.setKeyManagers(keyManagers)
- .setTrustManagers(trustManagers).buildQuietly();
+ .setTrustManagers(trustManagers).build();
}
}
diff --git a/hutool-core/src/main/java/cn/hutool/core/net/url/UrlBuilder.java b/hutool-core/src/main/java/cn/hutool/core/net/url/UrlBuilder.java
index 708e9721a..0a9adc1a8 100644
--- a/hutool-core/src/main/java/cn/hutool/core/net/url/UrlBuilder.java
+++ b/hutool-core/src/main/java/cn/hutool/core/net/url/UrlBuilder.java
@@ -1,12 +1,12 @@
package cn.hutool.core.net.url;
+import cn.hutool.core.builder.Builder;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.net.RFC3986;
import cn.hutool.core.util.CharsetUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.core.util.URLUtil;
-import java.io.Serializable;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URISyntaxException;
@@ -26,7 +26,7 @@ import java.nio.charset.Charset;
* @see Uniform Resource Identifier
* @since 5.3.1
*/
-public final class UrlBuilder implements Serializable {
+public final class UrlBuilder implements Builder {
private static final long serialVersionUID = 1L;
private static final String DEFAULT_SCHEME = "http";
@@ -468,6 +468,7 @@ public final class UrlBuilder implements Serializable {
*
* @return URL字符串
*/
+ @Override
public String build() {
return toURL().toString();
}
diff --git a/hutool-core/src/main/java/cn/hutool/core/net/url/UrlQuery.java b/hutool-core/src/main/java/cn/hutool/core/net/url/UrlQuery.java
index e7507503e..46c6de15f 100644
--- a/hutool-core/src/main/java/cn/hutool/core/net/url/UrlQuery.java
+++ b/hutool-core/src/main/java/cn/hutool/core/net/url/UrlQuery.java
@@ -279,6 +279,12 @@ public class UrlQuery {
return sb.toString();
}
+ /**
+ * 生成查询字符串，类似于aaa=111&bbb=222
+ * 此方法不对任何特殊字符编码，仅用于输出显示
+ *
+ * @return 查询字符串
+ */
@Override
public String toString() {
return build(null);
diff --git a/hutool-core/src/main/java/cn/hutool/core/stream/CollectorUtil.java b/hutool-core/src/main/java/cn/hutool/core/stream/CollectorUtil.java
index 82821897d..5d9c9d87a 100644
--- a/hutool-core/src/main/java/cn/hutool/core/stream/CollectorUtil.java
+++ b/hutool-core/src/main/java/cn/hutool/core/stream/CollectorUtil.java
@@ -8,12 +8,14 @@ import java.util.EnumSet;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
+import java.util.List;
import java.util.StringJoiner;
import java.util.function.BiConsumer;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collector;
+import java.util.stream.Collectors;
/**
* 可变的汇聚操作{@link Collector} 相关工具封装
@@ -140,6 +142,18 @@ public class CollectorUtil {
return groupingBy(classifier, HashMap::new, downstream);
}
+ /**
+ * 提供对null值友好的groupingBy操作的{@link Collector}实现
+ *
+ * @param classifier 分组依据
+ * @param 实体类型
+ * @param 实体中的分组依据对应类型，也是Map中key的类型
+ * @return {@link Collector}
+ */
+ public static Collector>>
+ groupingBy(Function classifier) {
+ return groupingBy(classifier, Collectors.toList());
+ }
/**
* 对null友好的 toMap 操作的 {@link Collector}实现，默认使用HashMap
diff --git a/hutool-core/src/main/java/cn/hutool/core/text/AntPathMatcher.java b/hutool-core/src/main/java/cn/hutool/core/text/AntPathMatcher.java
new file mode 100755
index 000000000..aabc3e97b
--- /dev/null
+++ b/hutool-core/src/main/java/cn/hutool/core/text/AntPathMatcher.java
@@ -0,0 +1,942 @@
+package cn.hutool.core.text;
+
+
+import cn.hutool.core.util.StrUtil;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Ant风格的路径匹配器。
+ * 来自Spring-core和Ant
+ *
+ * 匹配URL的规则如下：
+ *
+ * - {@code ?} 匹配单个字符
+ * - {@code *} 匹配0个或多个字符
+ * - {@code **} 0个或多个路径中的目录节点
+ * - {@code {hutool:[a-z]+}} 匹配以"hutool"命名的正则 {@code [a-z]+}
+ *
+ *
+ * 例子:
+ *
+ * - {@code com/t?st.jsp} — 匹配 {@code com/test.jsp} 或 {@code com/tast.jsp} 或 {@code com/txst.jsp}
+ * - {@code com/*.jsp} — 匹配{@code com}目录下全部 {@code .jsp}文件
+ * - {@code com/**/test.jsp} — 匹配{@code com}目录下全部 {@code test.jsp}文件
+ * - {@code cn/hutool/**/*.jsp} — 匹配{@code cn/hutool}路径下全部{@code .jsp} 文件
+ * - {@code org/**/servlet/bla.jsp} — 匹配{@code cn/hutool/servlet/bla.jsp} 或{@code cn/hutool/testing/servlet/bla.jsp} 或 {@code org/servlet/bla.jsp}
+ * - {@code com/{filename:\\w+}.jsp} 匹配 {@code com/test.jsp} 并将 {@code test} 关联到 {@code filename} 变量
+ *
+ *
+ * 注意: 表达式和路径必须都为绝对路径或都为相对路径。
+ *
+ * @author Alef Arendsen, Juergen Hoeller, Rob Harrop, Arjen Poutsma, Rossen Stoyanchev, Sam Brannen, Vladislav Kisel
+ * @since 5.7.22
+ */
+public class AntPathMatcher {
+
+ /**
+ * Default path separator: "/".
+ */
+ public static final String DEFAULT_PATH_SEPARATOR = StrUtil.SLASH;
+
+ private static final int CACHE_TURNOFF_THRESHOLD = 65536;
+
+ private static final Pattern VARIABLE_PATTERN = Pattern.compile("\\{[^/]+?}");
+
+ private static final char[] WILDCARD_CHARS = {'*', '?', '{'};
+
+ private String pathSeparator;
+
+ private PathSeparatorPatternCache pathSeparatorPatternCache;
+
+ private boolean caseSensitive = true;
+
+ private boolean trimTokens = false;
+
+ private volatile Boolean cachePatterns;
+
+ private final Map tokenizedPatternCache = new ConcurrentHashMap<>(256);
+
+ private final Map stringMatcherCache = new ConcurrentHashMap<>(256);
+
+
+ /**
+ * 使用 {@link #DEFAULT_PATH_SEPARATOR} 作为分隔符构造
+ */
+ public AntPathMatcher() {
+ this(DEFAULT_PATH_SEPARATOR);
+ }
+
+ /**
+ * 使用自定义的分隔符构造
+ *
+ * @param pathSeparator the path separator to use, must not be {@code null}.
+ * @since 4.1
+ */
+ public AntPathMatcher(String pathSeparator) {
+ if (null == pathSeparator) {
+ pathSeparator = DEFAULT_PATH_SEPARATOR;
+ }
+ setPathSeparator(pathSeparator);
+ }
+
+
+ /**
+ * 设置路径分隔符
+ *
+ * @param pathSeparator 分隔符，{@code null}表示使用默认分隔符{@link #DEFAULT_PATH_SEPARATOR}
+ * @return this
+ */
+ public AntPathMatcher setPathSeparator(String pathSeparator) {
+ if (null == pathSeparator) {
+ pathSeparator = DEFAULT_PATH_SEPARATOR;
+ }
+ this.pathSeparator = pathSeparator;
+ this.pathSeparatorPatternCache = new PathSeparatorPatternCache(this.pathSeparator);
+ return this;
+ }
+
+ /**
+ * 设置是否大小写敏感，默认为{@code true}
+ *
+ * @param caseSensitive 是否大小写敏感
+ * @return this
+ */
+ public AntPathMatcher setCaseSensitive(boolean caseSensitive) {
+ this.caseSensitive = caseSensitive;
+ return this;
+ }
+
+ /**
+ * 设置是否去除路径节点两边的空白符，默认为{@code false}
+ *
+ * @param trimTokens 是否去除路径节点两边的空白符
+ * @return this
+ */
+ public AntPathMatcher setTrimTokens(boolean trimTokens) {
+ this.trimTokens = trimTokens;
+ return this;
+ }
+
+ /**
+ * Specify whether to cache parsed pattern metadata for patterns passed
+ * into this matcher's {@link #match} method. A value of {@code true}
+ * activates an unlimited pattern cache; a value of {@code false} turns
+ * the pattern cache off completely.
+ * Default is for the cache to be on, but with the variant to automatically
+ * turn it off when encountering too many patterns to cache at runtime
+ * (the threshold is 65536), assuming that arbitrary permutations of patterns
+ * are coming in, with little chance for encountering a recurring pattern.
+ *
+ * @param cachePatterns 是否缓存表达式
+ * @see #getStringMatcher(String)
+ */
+ public AntPathMatcher setCachePatterns(boolean cachePatterns) {
+ this.cachePatterns = cachePatterns;
+ return this;
+ }
+
+ /**
+ * 判断给定路径是否是表达式
+ *
+ * @param path 路径
+ * @return 是否为表达式
+ */
+ public boolean isPattern(String path) {
+ if (path == null) {
+ return false;
+ }
+ boolean uriVar = false;
+ final int length = path.length();
+ char c;
+ for (int i = 0; i < length; i++) {
+ c = path.charAt(i);
+ // 含有通配符
+ if (c == '*' || c == '?') {
+ return true;
+ }
+ if (c == CharPool.DELIM_START) {
+ uriVar = true;
+ continue;
+ }
+ if (c == CharPool.DELIM_END && uriVar) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * 给定路径是否匹配表达式
+ *
+ * @param pattern 表达式
+ * @param path 路径
+ * @return 是否匹配
+ */
+ public boolean match(String pattern, String path) {
+ return doMatch(pattern, path, true, null);
+ }
+
+ /**
+ * 前置部分匹配
+ *
+ * @param pattern 表达式
+ * @param path 路径
+ * @return 是否匹配
+ */
+ public boolean matchStart(String pattern, String path) {
+ return doMatch(pattern, path, false, null);
+ }
+
+ /**
+ * 执行匹配，判断给定的{@code path}是否匹配{@code pattern}
+ *
+ * @param pattern 表达式
+ * @param path 路径
+ * @param fullMatch 是否全匹配。{@code true} 表示全路径匹配，{@code false}表示只匹配开始
+ * @param uriTemplateVariables 变量映射
+ * @return {@code true} 表示提供的 {@code path} 匹配, {@code false} 表示不匹配
+ */
+ protected boolean doMatch(String pattern, String path, boolean fullMatch, Map uriTemplateVariables) {
+ if (path == null || path.startsWith(this.pathSeparator) != pattern.startsWith(this.pathSeparator)) {
+ return false;
+ }
+
+ final String[] pattDirs = tokenizePattern(pattern);
+ if (fullMatch && this.caseSensitive && false == isPotentialMatch(path, pattDirs)) {
+ return false;
+ }
+
+ final String[] pathDirs = tokenizePath(path);
+ int pattIdxStart = 0;
+ int pattIdxEnd = pattDirs.length - 1;
+ int pathIdxStart = 0;
+ int pathIdxEnd = pathDirs.length - 1;
+
+ // Match all elements up to the first **
+ while (pattIdxStart <= pattIdxEnd && pathIdxStart <= pathIdxEnd) {
+ String pattDir = pattDirs[pattIdxStart];
+ if ("**".equals(pattDir)) {
+ break;
+ }
+ if (notMatchStrings(pattDir, pathDirs[pathIdxStart], uriTemplateVariables)) {
+ return false;
+ }
+ pattIdxStart++;
+ pathIdxStart++;
+ }
+
+ if (pathIdxStart > pathIdxEnd) {
+ // Path is exhausted, only match if rest of pattern is * or **'s
+ if (pattIdxStart > pattIdxEnd) {
+ return (pattern.endsWith(this.pathSeparator) == path.endsWith(this.pathSeparator));
+ }
+ if (false == fullMatch) {
+ return true;
+ }
+ if (pattIdxStart == pattIdxEnd && pattDirs[pattIdxStart].equals("*") && path.endsWith(this.pathSeparator)) {
+ return true;
+ }
+ for (int i = pattIdxStart; i <= pattIdxEnd; i++) {
+ if (false == pattDirs[i].equals("**")) {
+ return false;
+ }
+ }
+ return true;
+ } else if (pattIdxStart > pattIdxEnd) {
+ // String not exhausted, but pattern is. Failure.
+ return false;
+ } else if (false == fullMatch && "**".equals(pattDirs[pattIdxStart])) {
+ // Path start definitely matches due to "**" part in pattern.
+ return true;
+ }
+
+ // up to last '**'
+ while (pattIdxStart <= pattIdxEnd && pathIdxStart <= pathIdxEnd) {
+ String pattDir = pattDirs[pattIdxEnd];
+ if (pattDir.equals("**")) {
+ break;
+ }
+ if (notMatchStrings(pattDir, pathDirs[pathIdxEnd], uriTemplateVariables)) {
+ return false;
+ }
+ pattIdxEnd--;
+ pathIdxEnd--;
+ }
+ if (pathIdxStart > pathIdxEnd) {
+ // String is exhausted
+ for (int i = pattIdxStart; i <= pattIdxEnd; i++) {
+ if (false == pattDirs[i].equals("**")) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ while (pattIdxStart != pattIdxEnd && pathIdxStart <= pathIdxEnd) {
+ int patIdxTmp = -1;
+ for (int i = pattIdxStart + 1; i <= pattIdxEnd; i++) {
+ if (pattDirs[i].equals("**")) {
+ patIdxTmp = i;
+ break;
+ }
+ }
+ if (patIdxTmp == pattIdxStart + 1) {
+ // '**/**' situation, so skip one
+ pattIdxStart++;
+ continue;
+ }
+ // Find the pattern between padIdxStart & padIdxTmp in str between
+ // strIdxStart & strIdxEnd
+ int patLength = (patIdxTmp - pattIdxStart - 1);
+ int strLength = (pathIdxEnd - pathIdxStart + 1);
+ int foundIdx = -1;
+
+ strLoop:
+ for (int i = 0; i <= strLength - patLength; i++) {
+ for (int j = 0; j < patLength; j++) {
+ String subPat = pattDirs[pattIdxStart + j + 1];
+ String subStr = pathDirs[pathIdxStart + i + j];
+ if (notMatchStrings(subPat, subStr, uriTemplateVariables)) {
+ continue strLoop;
+ }
+ }
+ foundIdx = pathIdxStart + i;
+ break;
+ }
+
+ if (foundIdx == -1) {
+ return false;
+ }
+
+ pattIdxStart = patIdxTmp;
+ pathIdxStart = foundIdx + patLength;
+ }
+
+ for (int i = pattIdxStart; i <= pattIdxEnd; i++) {
+ if (false == pattDirs[i].equals("**")) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ private boolean isPotentialMatch(String path, String[] pattDirs) {
+ if (!this.trimTokens) {
+ int pos = 0;
+ for (String pattDir : pattDirs) {
+ int skipped = skipSeparator(path, pos, this.pathSeparator);
+ pos += skipped;
+ skipped = skipSegment(path, pos, pattDir);
+ if (skipped < pattDir.length()) {
+ return (skipped > 0 || (pattDir.length() > 0 && isWildcardChar(pattDir.charAt(0))));
+ }
+ pos += skipped;
+ }
+ }
+ return true;
+ }
+
+ private int skipSegment(String path, int pos, String prefix) {
+ int skipped = 0;
+ for (int i = 0; i < prefix.length(); i++) {
+ char c = prefix.charAt(i);
+ if (isWildcardChar(c)) {
+ return skipped;
+ }
+ int currPos = pos + skipped;
+ if (currPos >= path.length()) {
+ return 0;
+ }
+ if (c == path.charAt(currPos)) {
+ skipped++;
+ }
+ }
+ return skipped;
+ }
+
+ private int skipSeparator(String path, int pos, String separator) {
+ int skipped = 0;
+ while (path.startsWith(separator, pos + skipped)) {
+ skipped += separator.length();
+ }
+ return skipped;
+ }
+
+ private boolean isWildcardChar(char c) {
+ for (char candidate : WILDCARD_CHARS) {
+ if (c == candidate) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Tokenize the given path pattern into parts, based on this matcher's settings.
+ * Performs caching based on {@link #setCachePatterns}, delegating to
+ * {@link #tokenizePath(String)} for the actual tokenization algorithm.
+ *
+ * @param pattern the pattern to tokenize
+ * @return the tokenized pattern parts
+ */
+ protected String[] tokenizePattern(String pattern) {
+ String[] tokenized = null;
+ Boolean cachePatterns = this.cachePatterns;
+ if (cachePatterns == null || cachePatterns) {
+ tokenized = this.tokenizedPatternCache.get(pattern);
+ }
+ if (tokenized == null) {
+ tokenized = tokenizePath(pattern);
+ if (cachePatterns == null && this.tokenizedPatternCache.size() >= CACHE_TURNOFF_THRESHOLD) {
+ // Try to adapt to the runtime situation that we're encountering:
+ // There are obviously too many different patterns coming in here...
+ // So let's turn off the cache since the patterns are unlikely to be reoccurring.
+ deactivatePatternCache();
+ return tokenized;
+ }
+ if (cachePatterns == null || cachePatterns) {
+ this.tokenizedPatternCache.put(pattern, tokenized);
+ }
+ }
+ return tokenized;
+ }
+
+ private void deactivatePatternCache() {
+ this.cachePatterns = false;
+ this.tokenizedPatternCache.clear();
+ this.stringMatcherCache.clear();
+ }
+
+ /**
+ * Tokenize the given path into parts, based on this matcher's settings.
+ *
+ * @param path the path to tokenize
+ * @return the tokenized path parts
+ */
+ protected String[] tokenizePath(String path) {
+ return StrSplitter.splitToArray(path, this.pathSeparator, 0, this.trimTokens, true);
+ }
+
+ /**
+ * Test whether or not a string matches against a pattern.
+ *
+ * @param pattern the pattern to match against (never {@code null})
+ * @param str the String which must be matched against the pattern (never {@code null})
+ * @return {@code true} if the string matches against the pattern, or {@code false} otherwise
+ */
+ private boolean notMatchStrings(String pattern, String str, Map uriTemplateVariables) {
+ return false == getStringMatcher(pattern).matchStrings(str, uriTemplateVariables);
+ }
+
+ /**
+ * Build or retrieve an {@link AntPathStringMatcher} for the given pattern.
+ * The default implementation checks this AntPathMatcher's internal cache
+ * (see {@link #setCachePatterns}), creating a new AntPathStringMatcher instance
+ * if no cached copy is found.
+ *
When encountering too many patterns to cache at runtime (the threshold is 65536),
+ * it turns the default cache off, assuming that arbitrary permutations of patterns
+ * are coming in, with little chance for encountering a recurring pattern.
+ *
This method may be overridden to implement a custom cache strategy.
+ *
+ * @param pattern the pattern to match against (never {@code null})
+ * @return a corresponding AntPathStringMatcher (never {@code null})
+ * @see #setCachePatterns
+ */
+ protected AntPathStringMatcher getStringMatcher(String pattern) {
+ AntPathStringMatcher matcher = null;
+ Boolean cachePatterns = this.cachePatterns;
+ if (cachePatterns == null || cachePatterns) {
+ matcher = this.stringMatcherCache.get(pattern);
+ }
+ if (matcher == null) {
+ matcher = new AntPathStringMatcher(pattern, this.caseSensitive);
+ if (cachePatterns == null && this.stringMatcherCache.size() >= CACHE_TURNOFF_THRESHOLD) {
+ // Try to adapt to the runtime situation that we're encountering:
+ // There are obviously too many different patterns coming in here...
+ // So let's turn off the cache since the patterns are unlikely to be reoccurring.
+ deactivatePatternCache();
+ return matcher;
+ }
+ if (cachePatterns == null || cachePatterns) {
+ this.stringMatcherCache.put(pattern, matcher);
+ }
+ }
+ return matcher;
+ }
+
+ /**
+ * Given a pattern and a full path, determine the pattern-mapped part.
For example:
+ * - '{@code /docs/cvs/commit.html}' and '{@code /docs/cvs/commit.html} → ''
+ * - '{@code /docs/*}' and '{@code /docs/cvs/commit} → '{@code cvs/commit}'
+ * - '{@code /docs/cvs/*.html}' and '{@code /docs/cvs/commit.html} → '{@code commit.html}'
+ * - '{@code /docs/**}' and '{@code /docs/cvs/commit} → '{@code cvs/commit}'
+ * - '{@code /docs/**\/*.html}' and '{@code /docs/cvs/commit.html} → '{@code cvs/commit.html}'
+ * - '{@code /*.html}' and '{@code /docs/cvs/commit.html} → '{@code docs/cvs/commit.html}'
+ * - '{@code *.html}' and '{@code /docs/cvs/commit.html} → '{@code /docs/cvs/commit.html}'
+ * - '{@code *}' and '{@code /docs/cvs/commit.html} → '{@code /docs/cvs/commit.html}'
+ * Assumes that {@link #match} returns {@code true} for '{@code pattern}' and '{@code path}', but
+ * does not enforce this.
+ *
+ * @param pattern 表达式
+ * @param path 路径
+ * @return 表达式匹配到的部分
+ */
+ public String extractPathWithinPattern(String pattern, String path) {
+ String[] patternParts = tokenizePath(pattern);
+ String[] pathParts = tokenizePath(path);
+ StringBuilder builder = new StringBuilder();
+ boolean pathStarted = false;
+
+ for (int segment = 0; segment < patternParts.length; segment++) {
+ String patternPart = patternParts[segment];
+ if (patternPart.indexOf('*') > -1 || patternPart.indexOf('?') > -1) {
+ for (; segment < pathParts.length; segment++) {
+ if (pathStarted || (segment == 0 && !pattern.startsWith(this.pathSeparator))) {
+ builder.append(this.pathSeparator);
+ }
+ builder.append(pathParts[segment]);
+ pathStarted = true;
+ }
+ }
+ }
+
+ return builder.toString();
+ }
+
+ public Map extractUriTemplateVariables(String pattern, String path) {
+ Map variables = new LinkedHashMap<>();
+ boolean result = doMatch(pattern, path, true, variables);
+ if (!result) {
+ throw new IllegalStateException("Pattern \"" + pattern + "\" is not a match for \"" + path + "\"");
+ }
+ return variables;
+ }
+
+ /**
+ * Combine two patterns into a new pattern.
+ * This implementation simply concatenates the two patterns, unless
+ * the first pattern contains a file extension match (e.g., {@code *.html}).
+ * In that case, the second pattern will be merged into the first. Otherwise,
+ * an {@code IllegalArgumentException} will be thrown.
+ *
Examples
+ *
+ * | Pattern 1 | Pattern 2 | Result |
|---|
+ * | {@code null} | {@code null} | |
+ * | /hotels | {@code null} | /hotels |
+ * | {@code null} | /hotels | /hotels |
+ * | /hotels | /bookings | /hotels/bookings |
+ * | /hotels | bookings | /hotels/bookings |
+ * | /hotels/* | /bookings | /hotels/bookings |
+ * | /hotels/** | /bookings | /hotels/**/bookings |
+ * | /hotels | {hotel} | /hotels/{hotel} |
+ * | /hotels/* | {hotel} | /hotels/{hotel} |
+ * | /hotels/** | {hotel} | /hotels/**/{hotel} |
+ * | /*.html | /hotels.html | /hotels.html |
+ * | /*.html | /hotels | /hotels.html |
+ * | /*.html | /*.txt | {@code IllegalArgumentException} |
+ *
+ *
+ * @param pattern1 the first pattern
+ * @param pattern2 the second pattern
+ * @return the combination of the two patterns
+ * @throws IllegalArgumentException if the two patterns cannot be combined
+ */
+ public String combine(String pattern1, String pattern2) {
+ if (StrUtil.isEmpty(pattern1) && StrUtil.isEmpty(pattern2)) {
+ return StrUtil.EMPTY;
+ }
+ if (StrUtil.isEmpty(pattern1)) {
+ return pattern2;
+ }
+ if (StrUtil.isEmpty(pattern2)) {
+ return pattern1;
+ }
+
+ boolean pattern1ContainsUriVar = (pattern1.indexOf('{') != -1);
+ if (!pattern1.equals(pattern2) && !pattern1ContainsUriVar && match(pattern1, pattern2)) {
+ // /* + /hotel -> /hotel ; "/*.*" + "/*.html" -> /*.html
+ // However /user + /user -> /usr/user ; /{foo} + /bar -> /{foo}/bar
+ return pattern2;
+ }
+
+ // /hotels/* + /booking -> /hotels/booking
+ // /hotels/* + booking -> /hotels/booking
+ if (pattern1.endsWith(this.pathSeparatorPatternCache.getEndsOnWildCard())) {
+ return concat(pattern1.substring(0, pattern1.length() - 2), pattern2);
+ }
+
+ // /hotels/** + /booking -> /hotels/**/booking
+ // /hotels/** + booking -> /hotels/**/booking
+ if (pattern1.endsWith(this.pathSeparatorPatternCache.getEndsOnDoubleWildCard())) {
+ return concat(pattern1, pattern2);
+ }
+
+ int starDotPos1 = pattern1.indexOf("*.");
+ if (pattern1ContainsUriVar || starDotPos1 == -1 || this.pathSeparator.equals(".")) {
+ // simply concatenate the two patterns
+ return concat(pattern1, pattern2);
+ }
+
+ String ext1 = pattern1.substring(starDotPos1 + 1);
+ int dotPos2 = pattern2.indexOf('.');
+ String file2 = (dotPos2 == -1 ? pattern2 : pattern2.substring(0, dotPos2));
+ String ext2 = (dotPos2 == -1 ? "" : pattern2.substring(dotPos2));
+ boolean ext1All = (ext1.equals(".*") || ext1.isEmpty());
+ boolean ext2All = (ext2.equals(".*") || ext2.isEmpty());
+ if (!ext1All && !ext2All) {
+ throw new IllegalArgumentException("Cannot combine patterns: " + pattern1 + " vs " + pattern2);
+ }
+ String ext = (ext1All ? ext2 : ext1);
+ return file2 + ext;
+ }
+
+ private String concat(String path1, String path2) {
+ boolean path1EndsWithSeparator = path1.endsWith(this.pathSeparator);
+ boolean path2StartsWithSeparator = path2.startsWith(this.pathSeparator);
+
+ if (path1EndsWithSeparator && path2StartsWithSeparator) {
+ return path1 + path2.substring(1);
+ } else if (path1EndsWithSeparator || path2StartsWithSeparator) {
+ return path1 + path2;
+ } else {
+ return path1 + this.pathSeparator + path2;
+ }
+ }
+
+ /**
+ * Given a full path, returns a {@link Comparator} suitable for sorting patterns in order of
+ * explicitness.
+ * This {@code Comparator} will {@linkplain List#sort(Comparator) sort}
+ * a list so that more specific patterns (without URI templates or wild cards) come before
+ * generic patterns. So given a list with the following patterns, the returned comparator
+ * will sort this list so that the order will be as indicated.
+ *
+ * - {@code /hotels/new}
+ * - {@code /hotels/{hotel}}
+ * - {@code /hotels/*}
+ *
+ * The full path given as parameter is used to test for exact matches. So when the given path
+ * is {@code /hotels/2}, the pattern {@code /hotels/2} will be sorted before {@code /hotels/1}.
+ *
+ * @param path the full path to use for comparison
+ * @return a comparator capable of sorting patterns in order of explicitness
+ */
+ public Comparator getPatternComparator(String path) {
+ return new AntPatternComparator(path);
+ }
+
+
+ /**
+ * Tests whether or not a string matches against a pattern via a {@link Pattern}.
+ * The pattern may contain special characters: '*' means zero or more characters; '?' means one and
+ * only one character; '{' and '}' indicate a URI template pattern. For example /users/{user}.
+ */
+ protected static class AntPathStringMatcher {
+
+ private static final Pattern GLOB_PATTERN = Pattern.compile("\\?|\\*|\\{((?:\\{[^/]+?}|[^/{}]|\\\\[{}])+?)}");
+
+ private static final String DEFAULT_VARIABLE_PATTERN = "((?s).*)";
+
+ private final String rawPattern;
+
+ private final boolean caseSensitive;
+
+ private final boolean exactMatch;
+
+ private final Pattern pattern;
+
+ private final List variableNames = new ArrayList<>();
+
+ public AntPathStringMatcher(String pattern, boolean caseSensitive) {
+ this.rawPattern = pattern;
+ this.caseSensitive = caseSensitive;
+ StringBuilder patternBuilder = new StringBuilder();
+ Matcher matcher = GLOB_PATTERN.matcher(pattern);
+ int end = 0;
+ while (matcher.find()) {
+ patternBuilder.append(quote(pattern, end, matcher.start()));
+ String match = matcher.group();
+ if ("?".equals(match)) {
+ patternBuilder.append('.');
+ } else if ("*".equals(match)) {
+ patternBuilder.append(".*");
+ } else if (match.startsWith("{") && match.endsWith("}")) {
+ int colonIdx = match.indexOf(':');
+ if (colonIdx == -1) {
+ patternBuilder.append(DEFAULT_VARIABLE_PATTERN);
+ this.variableNames.add(matcher.group(1));
+ } else {
+ String variablePattern = match.substring(colonIdx + 1, match.length() - 1);
+ patternBuilder.append('(');
+ patternBuilder.append(variablePattern);
+ patternBuilder.append(')');
+ String variableName = match.substring(1, colonIdx);
+ this.variableNames.add(variableName);
+ }
+ }
+ end = matcher.end();
+ }
+ // No glob pattern was found, this is an exact String match
+ if (end == 0) {
+ this.exactMatch = true;
+ this.pattern = null;
+ } else {
+ this.exactMatch = false;
+ patternBuilder.append(quote(pattern, end, pattern.length()));
+ this.pattern = (this.caseSensitive ? Pattern.compile(patternBuilder.toString()) :
+ Pattern.compile(patternBuilder.toString(), Pattern.CASE_INSENSITIVE));
+ }
+ }
+
+ private String quote(String s, int start, int end) {
+ if (start == end) {
+ return "";
+ }
+ return Pattern.quote(s.substring(start, end));
+ }
+
+ /**
+ * Main entry point.
+ *
+ * @return {@code true} if the string matches against the pattern, or {@code false} otherwise.
+ */
+ public boolean matchStrings(String str, Map uriTemplateVariables) {
+ if (this.exactMatch) {
+ return this.caseSensitive ? this.rawPattern.equals(str) : this.rawPattern.equalsIgnoreCase(str);
+ } else if (this.pattern != null) {
+ Matcher matcher = this.pattern.matcher(str);
+ if (matcher.matches()) {
+ if (uriTemplateVariables != null) {
+ if (this.variableNames.size() != matcher.groupCount()) {
+ throw new IllegalArgumentException("The number of capturing groups in the pattern segment " +
+ this.pattern + " does not match the number of URI template variables it defines, " +
+ "which can occur if capturing groups are used in a URI template regex. " +
+ "Use non-capturing groups instead.");
+ }
+ for (int i = 1; i <= matcher.groupCount(); i++) {
+ String name = this.variableNames.get(i - 1);
+ if (name.startsWith("*")) {
+ throw new IllegalArgumentException("Capturing patterns (" + name + ") are not " +
+ "supported by the AntPathMatcher. Use the PathPatternParser instead.");
+ }
+ String value = matcher.group(i);
+ uriTemplateVariables.put(name, value);
+ }
+ }
+ return true;
+ }
+ }
+ return false;
+ }
+
+ }
+
+
+ /**
+ * The default {@link Comparator} implementation returned by
+ * {@link #getPatternComparator(String)}.
+ * In order, the most "generic" pattern is determined by the following:
+ *
+ * - if it's null or a capture all pattern (i.e. it is equal to "/**")
+ * - if the other pattern is an actual match
+ * - if it's a catch-all pattern (i.e. it ends with "**"
+ * - if it's got more "*" than the other pattern
+ * - if it's got more "{foo}" than the other pattern
+ * - if it's shorter than the other pattern
+ *
+ */
+ protected static class AntPatternComparator implements Comparator {
+
+ private final String path;
+
+ public AntPatternComparator(String path) {
+ this.path = path;
+ }
+
+ /**
+ * Compare two patterns to determine which should match first, i.e. which
+ * is the most specific regarding the current path.
+ *
+ * @param pattern1 表达式1
+ * @param pattern2 表达式2
+ * @return a negative integer, zero, or a positive integer as pattern1 is
+ * more specific, equally specific, or less specific than pattern2.
+ */
+ @Override
+ public int compare(String pattern1, String pattern2) {
+ PatternInfo info1 = new PatternInfo(pattern1);
+ PatternInfo info2 = new PatternInfo(pattern2);
+
+ if (info1.isLeastSpecific() && info2.isLeastSpecific()) {
+ return 0;
+ } else if (info1.isLeastSpecific()) {
+ return 1;
+ } else if (info2.isLeastSpecific()) {
+ return -1;
+ }
+
+ boolean pattern1EqualsPath = pattern1.equals(this.path);
+ boolean pattern2EqualsPath = pattern2.equals(this.path);
+ if (pattern1EqualsPath && pattern2EqualsPath) {
+ return 0;
+ } else if (pattern1EqualsPath) {
+ return -1;
+ } else if (pattern2EqualsPath) {
+ return 1;
+ }
+
+ if (info1.isPrefixPattern() && info2.isPrefixPattern()) {
+ return info2.getLength() - info1.getLength();
+ } else if (info1.isPrefixPattern() && info2.getDoubleWildcards() == 0) {
+ return 1;
+ } else if (info2.isPrefixPattern() && info1.getDoubleWildcards() == 0) {
+ return -1;
+ }
+
+ if (info1.getTotalCount() != info2.getTotalCount()) {
+ return info1.getTotalCount() - info2.getTotalCount();
+ }
+
+ if (info1.getLength() != info2.getLength()) {
+ return info2.getLength() - info1.getLength();
+ }
+
+ if (info1.getSingleWildcards() < info2.getSingleWildcards()) {
+ return -1;
+ } else if (info2.getSingleWildcards() < info1.getSingleWildcards()) {
+ return 1;
+ }
+
+ if (info1.getUriVars() < info2.getUriVars()) {
+ return -1;
+ } else if (info2.getUriVars() < info1.getUriVars()) {
+ return 1;
+ }
+
+ return 0;
+ }
+
+
+ /**
+ * Value class that holds information about the pattern, e.g. number of
+ * occurrences of "*", "**", and "{" pattern elements.
+ */
+ private static class PatternInfo {
+
+ private final String pattern;
+ private int uriVars;
+ private int singleWildcards;
+ private int doubleWildcards;
+ private boolean catchAllPattern;
+ private boolean prefixPattern;
+ private Integer length;
+
+ public PatternInfo(String pattern) {
+ this.pattern = pattern;
+ if (this.pattern != null) {
+ initCounters();
+ this.catchAllPattern = this.pattern.equals("/**");
+ this.prefixPattern = !this.catchAllPattern && this.pattern.endsWith("/**");
+ }
+ if (this.uriVars == 0) {
+ this.length = (this.pattern != null ? this.pattern.length() : 0);
+ }
+ }
+
+ protected void initCounters() {
+ int pos = 0;
+ if (this.pattern != null) {
+ while (pos < this.pattern.length()) {
+ if (this.pattern.charAt(pos) == '{') {
+ this.uriVars++;
+ pos++;
+ } else if (this.pattern.charAt(pos) == '*') {
+ if (pos + 1 < this.pattern.length() && this.pattern.charAt(pos + 1) == '*') {
+ this.doubleWildcards++;
+ pos += 2;
+ } else if (pos > 0 && !this.pattern.substring(pos - 1).equals(".*")) {
+ this.singleWildcards++;
+ pos++;
+ } else {
+ pos++;
+ }
+ } else {
+ pos++;
+ }
+ }
+ }
+ }
+
+ public int getUriVars() {
+ return this.uriVars;
+ }
+
+ public int getSingleWildcards() {
+ return this.singleWildcards;
+ }
+
+ public int getDoubleWildcards() {
+ return this.doubleWildcards;
+ }
+
+ public boolean isLeastSpecific() {
+ return (this.pattern == null || this.catchAllPattern);
+ }
+
+ public boolean isPrefixPattern() {
+ return this.prefixPattern;
+ }
+
+ public int getTotalCount() {
+ return this.uriVars + this.singleWildcards + (2 * this.doubleWildcards);
+ }
+
+ /**
+ * Returns the length of the given pattern, where template variables are considered to be 1 long.
+ *
+ * @return 长度
+ */
+ public int getLength() {
+ if (this.length == null) {
+ this.length = (this.pattern != null ?
+ VARIABLE_PATTERN.matcher(this.pattern).replaceAll("#").length() : 0);
+ }
+ return this.length;
+ }
+ }
+ }
+
+
+ /**
+ * A simple cache for patterns that depend on the configured path separator.
+ */
+ private static class PathSeparatorPatternCache {
+
+ private final String endsOnWildCard;
+
+ private final String endsOnDoubleWildCard;
+
+ public PathSeparatorPatternCache(String pathSeparator) {
+ this.endsOnWildCard = pathSeparator + "*";
+ this.endsOnDoubleWildCard = pathSeparator + "**";
+ }
+
+ public String getEndsOnWildCard() {
+ return this.endsOnWildCard;
+ }
+
+ public String getEndsOnDoubleWildCard() {
+ return this.endsOnDoubleWildCard;
+ }
+ }
+
+}
diff --git a/hutool-core/src/main/java/cn/hutool/core/text/CharSequenceUtil.java b/hutool-core/src/main/java/cn/hutool/core/text/CharSequenceUtil.java
index 2d7bcad89..4a308c14d 100644
--- a/hutool-core/src/main/java/cn/hutool/core/text/CharSequenceUtil.java
+++ b/hutool-core/src/main/java/cn/hutool/core/text/CharSequenceUtil.java
@@ -3601,6 +3601,46 @@ public class CharSequenceUtil {
return stringBuilder.toString();
}
+ /**
+ * 替换指定字符串的指定区间内字符为指定字符串，字符串只重复一次
+ * 此方法使用{@link String#codePoints()}完成拆分替换
+ *
+ * @param str 字符串
+ * @param startInclude 开始位置（包含）
+ * @param endExclude 结束位置（不包含）
+ * @param replacedStr 被替换的字符串
+ * @return 替换后的字符串
+ * @since 3.2.1
+ */
+ public static String replace(CharSequence str, int startInclude, int endExclude, CharSequence replacedStr) {
+ if (isEmpty(str)) {
+ return str(str);
+ }
+ final String originalStr = str(str);
+ int[] strCodePoints = originalStr.codePoints().toArray();
+ final int strLength = strCodePoints.length;
+ if (startInclude > strLength) {
+ return originalStr;
+ }
+ if (endExclude > strLength) {
+ endExclude = strLength;
+ }
+ if (startInclude > endExclude) {
+ // 如果起始位置大于结束位置，不替换
+ return originalStr;
+ }
+
+ final StringBuilder stringBuilder = new StringBuilder();
+ for (int i = 0; i < startInclude; i++) {
+ stringBuilder.append(new String(strCodePoints, i, 1));
+ }
+ stringBuilder.append(replacedStr);
+ for (int i = endExclude; i < strLength; i++) {
+ stringBuilder.append(new String(strCodePoints, i, 1));
+ }
+ return stringBuilder.toString();
+ }
+
/**
* 替换所有正则匹配的文本，并使用自定义函数决定如何替换
* replaceFun可以通过{@link Matcher}提取出匹配到的内容的不同部分，然后经过重新处理、组装变成新的内容放回原位。
diff --git a/hutool-core/src/main/java/cn/hutool/core/text/StrJoiner.java b/hutool-core/src/main/java/cn/hutool/core/text/StrJoiner.java
index bfebd8703..13f252fcb 100644
--- a/hutool-core/src/main/java/cn/hutool/core/text/StrJoiner.java
+++ b/hutool-core/src/main/java/cn/hutool/core/text/StrJoiner.java
@@ -12,7 +12,14 @@ import java.util.Iterator;
import java.util.function.Function;
/**
- * 字符串连接器（拼接器），通过给定的字符串和多个元素，拼接为一个字符串
+ * 字符串连接器（拼接器），通过给定的字符串和多个元素，拼接为一个字符串
+ * 相较于{@link java.util.StringJoiner}提供更加灵活的配置，包括：
+ *
@@ -142,18 +142,18 @@ We provide the T-Shirt and Sweater with Hutool Logo, please visit the shop：