+
-
- 
+
+ 
@@ -37,10 +37,9 @@
-
+
-
-
+
+
@@ -37,10 +37,9 @@
- -- 主页：https://hutool.cn/ | https://www.hutool.club/ -- + -- 主页：https://hutool.cn/ --
- -- QQ群③：555368316 -- -- QQ群④：718802356 --
@@ -77,13 +76,13 @@ Hutool的存在就是为了减少代码搜索成本，避免网络上参差不 | -------------------|---------------------------------------------------------------------------------- | | hutool-aop | JDK动态代理封装，提供非IOC下的切面支持 | | hutool-bloomFilter | 布隆过滤，提供一些Hash算法的布隆过滤 | -| hutool-cache | 简单缓存实现 | +| hutool-cache | 简单缓存实现 | | hutool-core | 核心，包括Bean操作、日期、各种Util等 | | hutool-cron | 定时任务模块，提供类Crontab表达式的定时任务 | -| hutool-crypto | 加密解密模块，提供对称、非对称和摘要算法封装 | +| hutool-crypto | 加密解密模块，提供对称、非对称和摘要算法封装 | | hutool-db | JDBC封装后的数据操作，基于ActiveRecord思想 | | hutool-dfa | 基于DFA模型的多关键字查找 | -| hutool-extra | 扩展模块，对第三方封装（模板引擎、邮件、Servlet、二维码、Emoji、FTP、分词等） | +| hutool-extra | 扩展模块，对第三方封装（模板引擎、邮件、Servlet、二维码、Emoji、FTP、分词等） | | hutool-http | 基于HttpUrlConnection的Http客户端封装 | | hutool-log | 自动识别日志实现的日志门面 | | hutool-script | 脚本执行封装，例如Javascript | @@ -91,7 +90,7 @@ Hutool的存在就是为了减少代码搜索成本，避免网络上参差不 | hutool-system | 系统参数调用封装（JVM信息等） | | hutool-json | JSON实现 | | hutool-captcha | 图片验证码实现 | -| hutool-poi | 针对POI中Excel的封装 | +| hutool-poi | 针对POI中Excel和Word的封装 | | hutool-socket | 基于Java的NIO和AIO的Socket封装 | 可以根据需求对每个模块单独引入，也可以通过引入`hutool-all`方式引入所有模块。 @@ -101,10 +100,11 @@ Hutool的存在就是为了减少代码搜索成本，避免网络上参差不 ## 文档 [中文文档](https://www.hutool.cn/docs/) -[中文文档（备用）](https://www.hutool.club/docs/) [参考API](https://apidoc.gitee.com/loolly/hutool/) +[视频介绍](https://www.bilibili.com/video/BV1bQ4y1M7d9?p=2) + ------------------------------------------------------------------------------- ## 安装 @@ -116,24 +116,24 @@ Hutool的存在就是为了减少代码搜索成本，避免网络上参差不- * Hutool是Hu + tool的自造词，前者致敬我的“前任公司”，后者为工具之意，谐音“糊涂”，寓意追求“万事都作糊涂观，无所谓失，无所谓得”的境界。 + * Hutool是一个小而全的Java工具类库，通过静态方法封装，降低相关API的学习成本，提高工作效率，使Java拥有函数式语言般的优雅，让Java语言也可以“甜甜的”。 *
* *
- * Hutool是一个Java工具包，也只是一个工具包，它帮助我们简化每一行代码，减少每一个方法，让Java语言也可以“甜甜的”。
- * Hutool最初是我项目中“util”包的一个整理，后来慢慢积累并加入更多非业务相关功能，并广泛学习其它开源项目精髓，经过自己整理修改，最终形成丰富的开源工具集。
+ * Hutool中的工具方法来自于每个用户的精雕细琢，它涵盖了Java开发底层代码中的方方面面，它既是大型项目开发中解决小问题的利器，也是小型项目中的效率担当；
*
Hutool是项目中“util”包友好的替代，它节省了开发人员对项目中公用类和公用工具方法的封装时间，使开发专注于业务，同时可以最大限度的避免封装不完善带来的bug。
* * @author Looly * diff --git a/hutool-aop/pom.xml b/hutool-aop/pom.xml index dcba385ba..b13f5e5eb 100644 --- a/hutool-aop/pom.xml +++ b/hutool-aop/pom.xml @@ -9,7 +9,7 @@prune 策略0表示无大小限制 */
+ /**
+ * 返回缓存容量，0表示无大小限制
+ */
protected int capacity;
- /** 缓存失效时长， 0 表示无限制，单位毫秒 */
+ /**
+ * 缓存失效时长， 0 表示无限制，单位毫秒
+ */
protected long timeout;
- /** 每个对象是否有单独的失效时长，用于决定清理过期对象是否有必要。 */
+ /**
+ * 每个对象是否有单独的失效时长，用于决定清理过期对象是否有必要。
+ */
protected boolean existCustomTimeout;
- /** 命中数 */
+ /**
+ * 命中数
+ */
protected int hitCount;
- /** 丢失数 */
+ /**
+ * 丢失数
+ */
protected int missCount;
// ---------------------------------------------------------------- put start
@@ -53,20 +58,19 @@ public abstract class AbstractCache+ * 1、是否存在只有无参数的getXXX方法或者isXXX方法 + * 2、是否存在public类型的字段 + *+ * + * @param clazz 待测试类 + * @return 是否为可读的Bean对象 + * @see #hasGetter(Class) + * @see #hasPublicField(Class) + */ + public static boolean isReadableBean(Class clazz) { + return hasGetter(clazz) || hasPublicField(clazz); + } + /** * 判断是否为Bean对象，判定方法是： * @@ -53,6 +70,7 @@ public class BeanUtil { * @param clazz 待测试类 * @return 是否为Bean对象 * @see #hasSetter(Class) + * @see #hasPublicField(Class) */ public static boolean isBean(Class clazz) { return hasSetter(clazz) || hasPublicField(clazz); @@ -458,7 +476,7 @@ public class BeanUtil { * @since 5.2.4 */ public static
{@link Object#equals(Object)} 方法的构建器
* @@ -39,830 +39,828 @@ import cn.hutool.core.util.ArrayUtil; * return EqualsBuilder.reflectionEquals(this, obj); * } * - * */ public class EqualsBuilder implements Builder- * A registry of objects used by reflection methods to detect cyclical object references and avoid infinite loops. - *
- * - * @since 3.0 - */ - private static final ThreadLocal+ * A registry of objects used by reflection methods to detect cyclical object references and avoid infinite loops. + *
+ * + * @since 3.0 + */ + private static final ThreadLocal- * Returns the registry of object pairs being traversed by the reflection - * methods in the current thread. - *
- * - * @return Set the registry of objects being traversed - * @since 3.0 - */ - static Set+ * Returns the registry of object pairs being traversed by the reflection + * methods in the current thread. + *
+ * + * @return Set the registry of objects being traversed + * @since 3.0 + */ + static Set- * Converters value pair into a register pair. - *
- * - * @param lhsthis object
- * @param rhs the other object
- *
- * @return the pair
- */
- static Pair+ * Converters value pair into a register pair. + *
+ * + * @param lhsthis object
+ * @param rhs the other object
+ * @return the pair
+ */
+ static Pair
- * Returns true if the registry contains the given object pair.
- * Used by the reflection methods to avoid infinite loops.
- * Objects might be swapped therefore a check is needed if the object pair
- * is registered in given or swapped order.
- *
this object to lookup in registry
- * @param rhs the other object to lookup on registry
- * @return boolean true if the registry contains the given object.
- * @since 3.0
- */
- static boolean isRegistered(final Object lhs, final Object rhs) {
- final Set
+ * Returns true if the registry contains the given object pair.
+ * Used by the reflection methods to avoid infinite loops.
+ * Objects might be swapped therefore a check is needed if the object pair
+ * is registered in given or swapped order.
+ *
this object to lookup in registry
+ * @param rhs the other object to lookup on registry
+ * @return boolean true if the registry contains the given object.
+ * @since 3.0
+ */
+ static boolean isRegistered(final Object lhs, final Object rhs) {
+ final Set- * Registers the given object pair. - * Used by the reflection methods to avoid infinite loops. - *
- * - * @param lhsthis object to register
- * @param rhs the other object to register
- */
- static void register(final Object lhs, final Object rhs) {
- synchronized (EqualsBuilder.class) {
- if (getRegistry() == null) {
- REGISTRY.set(new HashSet+ * Registers the given object pair. + * Used by the reflection methods to avoid infinite loops. + *
+ * + * @param lhsthis object to register
+ * @param rhs the other object to register
+ */
+ static void register(final Object lhs, final Object rhs) {
+ synchronized (EqualsBuilder.class) {
+ if (getRegistry() == null) {
+ REGISTRY.set(new HashSet<>());
+ }
+ }
- final Set- * Unregisters the given object pair. - *
- * - *
- * Used by the reflection methods to avoid infinite loops.
- *
- * @param lhs
+ * Unregisters the given object pair.
+ *
+ * Used by the reflection methods to avoid infinite loops.
+ *
+ * @param lhs 反射检查两个对象是否equals，此方法检查对象及其父对象的属性（包括私有属性）是否equals 反射检查两个对象是否equals，此方法检查对象及其父对象的属性（包括私有属性）是否equals 反射检查两个对象是否equals，此方法检查对象及其父对象的属性（包括私有属性）是否equals 反射检查两个对象是否equals，此方法检查对象及其父对象的属性（包括私有属性）是否equals This method uses reflection to determine if the two It uses If the TestTransients parameter is set to Static fields will not be tested. Superclass fields will be included. This method uses reflection to determine if the two It uses If the TestTransients parameter is set to Static fields will not be tested. Superclass fields will be included. This method uses reflection to determine if the two It uses If the testTransients parameter is set to Static fields will not be included. Superclass fields will be appended
- * up to and including the specified superclass. A null superclass is treated
- * as java.lang.Object. This method uses reflection to determine if the two It uses If the testTransients parameter is set to Static fields will not be included. Superclass fields will be appended
+ * up to and including the specified superclass. A null superclass is treated
+ * as java.lang.Object. Appends the fields and values defined by the given object of the
- * given Class. Appends the fields and values defined by the given object of the
+ * given Class. Adds the result of Adds the result of Test if two Test if two
- * Test if two
+ * Test if two Test if two Test if two Test if two Test if two Test if two Test if two Test if two Test if two Test if two This handles NaNs, Infinities, and It is compatible with the hash code generated by
- * Test if two This handles NaNs, Infinities, and It is compatible with the hash code generated by
+ * Test if two This handles NaNs, Infinities, and It is compatible with the hash code generated by
- * Test if two This handles NaNs, Infinities, and It is compatible with the hash code generated by
+ * Test if two Test if two Performs a deep comparison of two This also will be called for the top level of
- * multi-dimensional, ragged, and multi-typed arrays. Performs a deep comparison of two This also will be called for the top level of
+ * multi-dimensional, ragged, and multi-typed arrays. Deep comparison of array of The method {@link #append(long, long)} is used. Deep comparison of array of The method {@link #append(long, long)} is used. Deep comparison of array of The method {@link #append(int, int)} is used. Deep comparison of array of The method {@link #append(int, int)} is used. Deep comparison of array of The method {@link #append(short, short)} is used. Deep comparison of array of The method {@link #append(short, short)} is used. Deep comparison of array of The method {@link #append(char, char)} is used. Deep comparison of array of The method {@link #append(char, char)} is used. Deep comparison of array of The method {@link #append(byte, byte)} is used. Deep comparison of array of The method {@link #append(byte, byte)} is used. Deep comparison of array of The method {@link #append(double, double)} is used. Deep comparison of array of The method {@link #append(double, double)} is used. Deep comparison of array of The method {@link #append(float, float)} is used. Deep comparison of array of The method {@link #append(float, float)} is used. Deep comparison of array of The method {@link #append(boolean, boolean)} is used. Deep comparison of array of The method {@link #append(boolean, boolean)} is used. Returns Returns Returns Returns this object to unregister
- * @param rhs the other object to unregister
- * @since 3.0
- */
- static void unregister(final Object lhs, final Object rhs) {
- Setthis object to unregister
+ * @param rhs the other object to unregister
+ * @since 3.0
+ */
+ static void unregister(final Object lhs, final Object rhs) {
+ Settrue
- */
- public static boolean reflectionEquals(final Object lhs, final Object rhs, final Collectiontrue
+ */
+ public static boolean reflectionEquals(final Object lhs, final Object rhs, final Collectiontrue
- */
- public static boolean reflectionEquals(final Object lhs, final Object rhs, final String... excludeFields) {
- return reflectionEquals(lhs, rhs, false, null, excludeFields);
- }
+ /**
+ * true
+ */
+ public static boolean reflectionEquals(final Object lhs, final Object rhs, final String... excludeFields) {
+ return reflectionEquals(lhs, rhs, false, null, excludeFields);
+ }
- /**
- * Objects
- * are equal.AccessibleObject.setAccessible to gain access to private
- * fields. This means that it will throw a security exception if run under
- * a security manager, if the permissions are not set up correctly. It is also
- * not as efficient as testing explicitly. Non-primitive fields are compared using
- * equals().true, transient
- * members will be tested, otherwise they are ignored, as they are likely
- * derived fields, and not part of the value of the Object.this object
- * @param rhs the other object
- * @param testTransients whether to include transient fields
- * @return true if the two Objects have tested equals.
- */
- public static boolean reflectionEquals(final Object lhs, final Object rhs, final boolean testTransients) {
- return reflectionEquals(lhs, rhs, testTransients, null);
- }
+ /**
+ * Objects
+ * are equal.AccessibleObject.setAccessible to gain access to private
+ * fields. This means that it will throw a security exception if run under
+ * a security manager, if the permissions are not set up correctly. It is also
+ * not as efficient as testing explicitly. Non-primitive fields are compared using
+ * equals().true, transient
+ * members will be tested, otherwise they are ignored, as they are likely
+ * derived fields, and not part of the value of the Object.this object
+ * @param rhs the other object
+ * @param testTransients whether to include transient fields
+ * @return true if the two Objects have tested equals.
+ */
+ public static boolean reflectionEquals(final Object lhs, final Object rhs, final boolean testTransients) {
+ return reflectionEquals(lhs, rhs, testTransients, null);
+ }
- /**
- * Objects
- * are equal.AccessibleObject.setAccessible to gain access to private
- * fields. This means that it will throw a security exception if run under
- * a security manager, if the permissions are not set up correctly. It is also
- * not as efficient as testing explicitly. Non-primitive fields are compared using
- * equals().true, transient
- * members will be tested, otherwise they are ignored, as they are likely
- * derived fields, and not part of the value of the Object.this object
- * @param rhs the other object
- * @param testTransients whether to include transient fields
- * @param reflectUpToClass the superclass to reflect up to (inclusive),
- * may be null
- * @param excludeFields array of field names to exclude from testing
- * @return true if the two Objects have tested equals.
- * @since 2.0
- */
- public static boolean reflectionEquals(final Object lhs, final Object rhs, final boolean testTransients, final Class reflectUpToClass,
- final String... excludeFields) {
- if (lhs == rhs) {
- return true;
- }
- if (lhs == null || rhs == null) {
- return false;
- }
- // Find the leaf class since there may be transients in the leaf
- // class or in classes between the leaf and root.
- // If we are not testing transients or a subclass has no ivars,
- // then a subclass can test equals to a superclass.
- final Class lhsClass = lhs.getClass();
- final Class rhsClass = rhs.getClass();
- Class testClass;
- if (lhsClass.isInstance(rhs)) {
- testClass = lhsClass;
- if (!rhsClass.isInstance(lhs)) {
- // rhsClass is a subclass of lhsClass
- testClass = rhsClass;
- }
- } else if (rhsClass.isInstance(lhs)) {
- testClass = rhsClass;
- if (!lhsClass.isInstance(rhs)) {
- // lhsClass is a subclass of rhsClass
- testClass = lhsClass;
- }
- } else {
- // The two classes are not related.
- return false;
- }
- final EqualsBuilder equalsBuilder = new EqualsBuilder();
- try {
- if (testClass.isArray()) {
- equalsBuilder.append(lhs, rhs);
- } else {
- reflectionAppend(lhs, rhs, testClass, equalsBuilder, testTransients, excludeFields);
- while (testClass.getSuperclass() != null && testClass != reflectUpToClass) {
- testClass = testClass.getSuperclass();
- reflectionAppend(lhs, rhs, testClass, equalsBuilder, testTransients, excludeFields);
- }
- }
- } catch (final IllegalArgumentException e) {
- // In this case, we tried to test a subclass vs. a superclass and
- // the subclass has ivars or the ivars are transient and
- // we are testing transients.
- // If a subclass has ivars that we are trying to test them, we get an
- // exception and we know that the objects are not equal.
- return false;
- }
- return equalsBuilder.isEquals();
- }
+ /**
+ * Objects
+ * are equal.AccessibleObject.setAccessible to gain access to private
+ * fields. This means that it will throw a security exception if run under
+ * a security manager, if the permissions are not set up correctly. It is also
+ * not as efficient as testing explicitly. Non-primitive fields are compared using
+ * equals().true, transient
+ * members will be tested, otherwise they are ignored, as they are likely
+ * derived fields, and not part of the value of the Object.this object
+ * @param rhs the other object
+ * @param testTransients whether to include transient fields
+ * @param reflectUpToClass the superclass to reflect up to (inclusive),
+ * may be null
+ * @param excludeFields array of field names to exclude from testing
+ * @return true if the two Objects have tested equals.
+ * @since 2.0
+ */
+ public static boolean reflectionEquals(final Object lhs, final Object rhs, final boolean testTransients, final Class reflectUpToClass,
+ final String... excludeFields) {
+ if (lhs == rhs) {
+ return true;
+ }
+ if (lhs == null || rhs == null) {
+ return false;
+ }
+ // Find the leaf class since there may be transients in the leaf
+ // class or in classes between the leaf and root.
+ // If we are not testing transients or a subclass has no ivars,
+ // then a subclass can test equals to a superclass.
+ final Class lhsClass = lhs.getClass();
+ final Class rhsClass = rhs.getClass();
+ Class testClass;
+ if (lhsClass.isInstance(rhs)) {
+ testClass = lhsClass;
+ if (!rhsClass.isInstance(lhs)) {
+ // rhsClass is a subclass of lhsClass
+ testClass = rhsClass;
+ }
+ } else if (rhsClass.isInstance(lhs)) {
+ testClass = rhsClass;
+ if (!lhsClass.isInstance(rhs)) {
+ // lhsClass is a subclass of rhsClass
+ testClass = lhsClass;
+ }
+ } else {
+ // The two classes are not related.
+ return false;
+ }
+ final EqualsBuilder equalsBuilder = new EqualsBuilder();
+ try {
+ if (testClass.isArray()) {
+ equalsBuilder.append(lhs, rhs);
+ } else {
+ reflectionAppend(lhs, rhs, testClass, equalsBuilder, testTransients, excludeFields);
+ while (testClass.getSuperclass() != null && testClass != reflectUpToClass) {
+ testClass = testClass.getSuperclass();
+ reflectionAppend(lhs, rhs, testClass, equalsBuilder, testTransients, excludeFields);
+ }
+ }
+ } catch (final IllegalArgumentException e) {
+ // In this case, we tried to test a subclass vs. a superclass and
+ // the subclass has ivars or the ivars are transient and
+ // we are testing transients.
+ // If a subclass has ivars that we are trying to test them, we get an
+ // exception and we know that the objects are not equal.
+ return false;
+ }
+ return equalsBuilder.isEquals();
+ }
- /**
- * super.equals() to this builder.super.equals()
- * @return EqualsBuilder - used to chain calls.
- * @since 2.0
- */
- public EqualsBuilder appendSuper(final boolean superEquals) {
- if (isEquals == false) {
- return this;
- }
- isEquals = superEquals;
- return this;
- }
+ /**
+ * super.equals() to this builder.super.equals()
+ * @return EqualsBuilder - used to chain calls.
+ * @since 2.0
+ */
+ public EqualsBuilder appendSuper(final boolean superEquals) {
+ if (isEquals == false) {
+ return this;
+ }
+ isEquals = superEquals;
+ return this;
+ }
- //-------------------------------------------------------------------------
+ //-------------------------------------------------------------------------
- /**
- * Objects are equal using their
- * equals method.Objects are equal using their
+ * equals method.long s are equal.
- * long
- * @param rhs
- * the right hand long
- * @return EqualsBuilder - used to chain calls.
- */
- public EqualsBuilder append(final long lhs, final long rhs) {
- if (isEquals == false) {
- return this;
- }
- isEquals = (lhs == rhs);
- return this;
- }
+ /**
+ * long s are equal.
+ * long
+ * @param rhs the right hand long
+ * @return EqualsBuilder - used to chain calls.
+ */
+ public EqualsBuilder append(final long lhs, final long rhs) {
+ if (isEquals == false) {
+ return this;
+ }
+ isEquals = (lhs == rhs);
+ return this;
+ }
- /**
- * ints are equal.int
- * @param rhs the right hand int
- * @return EqualsBuilder - used to chain calls.
- */
- public EqualsBuilder append(final int lhs, final int rhs) {
- if (isEquals == false) {
- return this;
- }
- isEquals = (lhs == rhs);
- return this;
- }
+ /**
+ * ints are equal.int
+ * @param rhs the right hand int
+ * @return EqualsBuilder - used to chain calls.
+ */
+ public EqualsBuilder append(final int lhs, final int rhs) {
+ if (isEquals == false) {
+ return this;
+ }
+ isEquals = (lhs == rhs);
+ return this;
+ }
- /**
- * shorts are equal.short
- * @param rhs the right hand short
- * @return EqualsBuilder - used to chain calls.
- */
- public EqualsBuilder append(final short lhs, final short rhs) {
- if (isEquals == false) {
- return this;
- }
- isEquals = (lhs == rhs);
- return this;
- }
+ /**
+ * shorts are equal.short
+ * @param rhs the right hand short
+ * @return EqualsBuilder - used to chain calls.
+ */
+ public EqualsBuilder append(final short lhs, final short rhs) {
+ if (isEquals == false) {
+ return this;
+ }
+ isEquals = (lhs == rhs);
+ return this;
+ }
- /**
- * chars are equal.char
- * @param rhs the right hand char
- * @return EqualsBuilder - used to chain calls.
- */
- public EqualsBuilder append(final char lhs, final char rhs) {
- if (isEquals == false) {
- return this;
- }
- isEquals = (lhs == rhs);
- return this;
- }
+ /**
+ * chars are equal.char
+ * @param rhs the right hand char
+ * @return EqualsBuilder - used to chain calls.
+ */
+ public EqualsBuilder append(final char lhs, final char rhs) {
+ if (isEquals == false) {
+ return this;
+ }
+ isEquals = (lhs == rhs);
+ return this;
+ }
- /**
- * bytes are equal.byte
- * @param rhs the right hand byte
- * @return EqualsBuilder - used to chain calls.
- */
- public EqualsBuilder append(final byte lhs, final byte rhs) {
- if (isEquals == false) {
- return this;
- }
- isEquals = (lhs == rhs);
- return this;
- }
+ /**
+ * bytes are equal.byte
+ * @param rhs the right hand byte
+ * @return EqualsBuilder - used to chain calls.
+ */
+ public EqualsBuilder append(final byte lhs, final byte rhs) {
+ if (isEquals == false) {
+ return this;
+ }
+ isEquals = (lhs == rhs);
+ return this;
+ }
- /**
- * doubles are equal by testing that the
- * pattern of bits returned by doubleToLong are equal.-0.0.HashCodeBuilder.double
- * @param rhs the right hand double
- * @return EqualsBuilder - used to chain calls.
- */
- public EqualsBuilder append(final double lhs, final double rhs) {
- if (isEquals == false) {
- return this;
- }
- return append(Double.doubleToLongBits(lhs), Double.doubleToLongBits(rhs));
- }
+ /**
+ * doubles are equal by testing that the
+ * pattern of bits returned by doubleToLong are equal.-0.0.HashCodeBuilder.double
+ * @param rhs the right hand double
+ * @return EqualsBuilder - used to chain calls.
+ */
+ public EqualsBuilder append(final double lhs, final double rhs) {
+ if (isEquals == false) {
+ return this;
+ }
+ return append(Double.doubleToLongBits(lhs), Double.doubleToLongBits(rhs));
+ }
- /**
- * floats are equal byt testing that the
- * pattern of bits returned by doubleToLong are equal.-0.0.HashCodeBuilder.float
- * @param rhs the right hand float
- * @return EqualsBuilder - used to chain calls.
- */
- public EqualsBuilder append(final float lhs, final float rhs) {
- if (isEquals == false) {
- return this;
- }
- return append(Float.floatToIntBits(lhs), Float.floatToIntBits(rhs));
- }
+ /**
+ * floats are equal byt testing that the
+ * pattern of bits returned by doubleToLong are equal.-0.0.HashCodeBuilder.float
+ * @param rhs the right hand float
+ * @return EqualsBuilder - used to chain calls.
+ */
+ public EqualsBuilder append(final float lhs, final float rhs) {
+ if (isEquals == false) {
+ return this;
+ }
+ return append(Float.floatToIntBits(lhs), Float.floatToIntBits(rhs));
+ }
- /**
- * booleanss are equal.boolean
- * @param rhs the right hand boolean
- * @return EqualsBuilder - used to chain calls.
- */
- public EqualsBuilder append(final boolean lhs, final boolean rhs) {
- if (isEquals == false) {
- return this;
- }
- isEquals = (lhs == rhs);
- return this;
- }
+ /**
+ * booleanss are equal.boolean
+ * @param rhs the right hand boolean
+ * @return EqualsBuilder - used to chain calls.
+ */
+ public EqualsBuilder append(final boolean lhs, final boolean rhs) {
+ if (isEquals == false) {
+ return this;
+ }
+ isEquals = (lhs == rhs);
+ return this;
+ }
- /**
- * Object arrays.Object[]
- * @param rhs the right hand Object[]
- * @return EqualsBuilder - used to chain calls.
- */
- public EqualsBuilder append(final Object[] lhs, final Object[] rhs) {
- if (isEquals == false) {
- return this;
- }
- if (lhs == rhs) {
- return this;
- }
- if (lhs == null || rhs == null) {
- this.setEquals(false);
- return this;
- }
- if (lhs.length != rhs.length) {
- this.setEquals(false);
- return this;
- }
- for (int i = 0; i < lhs.length && isEquals; ++i) {
- append(lhs[i], rhs[i]);
- }
- return this;
- }
+ /**
+ * Object arrays.Object[]
+ * @param rhs the right hand Object[]
+ * @return EqualsBuilder - used to chain calls.
+ */
+ public EqualsBuilder append(final Object[] lhs, final Object[] rhs) {
+ if (isEquals == false) {
+ return this;
+ }
+ if (lhs == rhs) {
+ return this;
+ }
+ if (lhs == null || rhs == null) {
+ this.setEquals(false);
+ return this;
+ }
+ if (lhs.length != rhs.length) {
+ this.setEquals(false);
+ return this;
+ }
+ for (int i = 0; i < lhs.length && isEquals; ++i) {
+ append(lhs[i], rhs[i]);
+ }
+ return this;
+ }
- /**
- * long. Length and all
- * values are compared.long[]
- * @param rhs the right hand long[]
- * @return EqualsBuilder - used to chain calls.
- */
- public EqualsBuilder append(final long[] lhs, final long[] rhs) {
- if (isEquals == false) {
- return this;
- }
- if (lhs == rhs) {
- return this;
- }
- if (lhs == null || rhs == null) {
- this.setEquals(false);
- return this;
- }
- if (lhs.length != rhs.length) {
- this.setEquals(false);
- return this;
- }
- for (int i = 0; i < lhs.length && isEquals; ++i) {
- append(lhs[i], rhs[i]);
- }
- return this;
- }
+ /**
+ * long. Length and all
+ * values are compared.long[]
+ * @param rhs the right hand long[]
+ * @return EqualsBuilder - used to chain calls.
+ */
+ public EqualsBuilder append(final long[] lhs, final long[] rhs) {
+ if (isEquals == false) {
+ return this;
+ }
+ if (lhs == rhs) {
+ return this;
+ }
+ if (lhs == null || rhs == null) {
+ this.setEquals(false);
+ return this;
+ }
+ if (lhs.length != rhs.length) {
+ this.setEquals(false);
+ return this;
+ }
+ for (int i = 0; i < lhs.length && isEquals; ++i) {
+ append(lhs[i], rhs[i]);
+ }
+ return this;
+ }
- /**
- * int. Length and all
- * values are compared.int[]
- * @param rhs the right hand int[]
- * @return EqualsBuilder - used to chain calls.
- */
- public EqualsBuilder append(final int[] lhs, final int[] rhs) {
- if (isEquals == false) {
- return this;
- }
- if (lhs == rhs) {
- return this;
- }
- if (lhs == null || rhs == null) {
- this.setEquals(false);
- return this;
- }
- if (lhs.length != rhs.length) {
- this.setEquals(false);
- return this;
- }
- for (int i = 0; i < lhs.length && isEquals; ++i) {
- append(lhs[i], rhs[i]);
- }
- return this;
- }
+ /**
+ * int. Length and all
+ * values are compared.int[]
+ * @param rhs the right hand int[]
+ * @return EqualsBuilder - used to chain calls.
+ */
+ public EqualsBuilder append(final int[] lhs, final int[] rhs) {
+ if (isEquals == false) {
+ return this;
+ }
+ if (lhs == rhs) {
+ return this;
+ }
+ if (lhs == null || rhs == null) {
+ this.setEquals(false);
+ return this;
+ }
+ if (lhs.length != rhs.length) {
+ this.setEquals(false);
+ return this;
+ }
+ for (int i = 0; i < lhs.length && isEquals; ++i) {
+ append(lhs[i], rhs[i]);
+ }
+ return this;
+ }
- /**
- * short. Length and all
- * values are compared.short[]
- * @param rhs the right hand short[]
- * @return EqualsBuilder - used to chain calls.
- */
- public EqualsBuilder append(final short[] lhs, final short[] rhs) {
- if (isEquals == false) {
- return this;
- }
- if (lhs == rhs) {
- return this;
- }
- if (lhs == null || rhs == null) {
- this.setEquals(false);
- return this;
- }
- if (lhs.length != rhs.length) {
- this.setEquals(false);
- return this;
- }
- for (int i = 0; i < lhs.length && isEquals; ++i) {
- append(lhs[i], rhs[i]);
- }
- return this;
- }
+ /**
+ * short. Length and all
+ * values are compared.short[]
+ * @param rhs the right hand short[]
+ * @return EqualsBuilder - used to chain calls.
+ */
+ public EqualsBuilder append(final short[] lhs, final short[] rhs) {
+ if (isEquals == false) {
+ return this;
+ }
+ if (lhs == rhs) {
+ return this;
+ }
+ if (lhs == null || rhs == null) {
+ this.setEquals(false);
+ return this;
+ }
+ if (lhs.length != rhs.length) {
+ this.setEquals(false);
+ return this;
+ }
+ for (int i = 0; i < lhs.length && isEquals; ++i) {
+ append(lhs[i], rhs[i]);
+ }
+ return this;
+ }
- /**
- * char. Length and all
- * values are compared.char[]
- * @param rhs the right hand char[]
- * @return EqualsBuilder - used to chain calls.
- */
- public EqualsBuilder append(final char[] lhs, final char[] rhs) {
- if (isEquals == false) {
- return this;
- }
- if (lhs == rhs) {
- return this;
- }
- if (lhs == null || rhs == null) {
- this.setEquals(false);
- return this;
- }
- if (lhs.length != rhs.length) {
- this.setEquals(false);
- return this;
- }
- for (int i = 0; i < lhs.length && isEquals; ++i) {
- append(lhs[i], rhs[i]);
- }
- return this;
- }
+ /**
+ * char. Length and all
+ * values are compared.char[]
+ * @param rhs the right hand char[]
+ * @return EqualsBuilder - used to chain calls.
+ */
+ public EqualsBuilder append(final char[] lhs, final char[] rhs) {
+ if (isEquals == false) {
+ return this;
+ }
+ if (lhs == rhs) {
+ return this;
+ }
+ if (lhs == null || rhs == null) {
+ this.setEquals(false);
+ return this;
+ }
+ if (lhs.length != rhs.length) {
+ this.setEquals(false);
+ return this;
+ }
+ for (int i = 0; i < lhs.length && isEquals; ++i) {
+ append(lhs[i], rhs[i]);
+ }
+ return this;
+ }
- /**
- * byte. Length and all
- * values are compared.byte[]
- * @param rhs the right hand byte[]
- * @return EqualsBuilder - used to chain calls.
- */
- public EqualsBuilder append(final byte[] lhs, final byte[] rhs) {
- if (isEquals == false) {
- return this;
- }
- if (lhs == rhs) {
- return this;
- }
- if (lhs == null || rhs == null) {
- this.setEquals(false);
- return this;
- }
- if (lhs.length != rhs.length) {
- this.setEquals(false);
- return this;
- }
- for (int i = 0; i < lhs.length && isEquals; ++i) {
- append(lhs[i], rhs[i]);
- }
- return this;
- }
+ /**
+ * byte. Length and all
+ * values are compared.byte[]
+ * @param rhs the right hand byte[]
+ * @return EqualsBuilder - used to chain calls.
+ */
+ public EqualsBuilder append(final byte[] lhs, final byte[] rhs) {
+ if (isEquals == false) {
+ return this;
+ }
+ if (lhs == rhs) {
+ return this;
+ }
+ if (lhs == null || rhs == null) {
+ this.setEquals(false);
+ return this;
+ }
+ if (lhs.length != rhs.length) {
+ this.setEquals(false);
+ return this;
+ }
+ for (int i = 0; i < lhs.length && isEquals; ++i) {
+ append(lhs[i], rhs[i]);
+ }
+ return this;
+ }
- /**
- * double. Length and all
- * values are compared.double[]
- * @param rhs the right hand double[]
- * @return EqualsBuilder - used to chain calls.
- */
- public EqualsBuilder append(final double[] lhs, final double[] rhs) {
- if (isEquals == false) {
- return this;
- }
- if (lhs == rhs) {
- return this;
- }
- if (lhs == null || rhs == null) {
- this.setEquals(false);
- return this;
- }
- if (lhs.length != rhs.length) {
- this.setEquals(false);
- return this;
- }
- for (int i = 0; i < lhs.length && isEquals; ++i) {
- append(lhs[i], rhs[i]);
- }
- return this;
- }
+ /**
+ * double. Length and all
+ * values are compared.double[]
+ * @param rhs the right hand double[]
+ * @return EqualsBuilder - used to chain calls.
+ */
+ public EqualsBuilder append(final double[] lhs, final double[] rhs) {
+ if (isEquals == false) {
+ return this;
+ }
+ if (lhs == rhs) {
+ return this;
+ }
+ if (lhs == null || rhs == null) {
+ this.setEquals(false);
+ return this;
+ }
+ if (lhs.length != rhs.length) {
+ this.setEquals(false);
+ return this;
+ }
+ for (int i = 0; i < lhs.length && isEquals; ++i) {
+ append(lhs[i], rhs[i]);
+ }
+ return this;
+ }
- /**
- * float. Length and all
- * values are compared.float[]
- * @param rhs the right hand float[]
- * @return EqualsBuilder - used to chain calls.
- */
- public EqualsBuilder append(final float[] lhs, final float[] rhs) {
- if (isEquals == false) {
- return this;
- }
- if (lhs == rhs) {
- return this;
- }
- if (lhs == null || rhs == null) {
- this.setEquals(false);
- return this;
- }
- if (lhs.length != rhs.length) {
- this.setEquals(false);
- return this;
- }
- for (int i = 0; i < lhs.length && isEquals; ++i) {
- append(lhs[i], rhs[i]);
- }
- return this;
- }
+ /**
+ * float. Length and all
+ * values are compared.float[]
+ * @param rhs the right hand float[]
+ * @return EqualsBuilder - used to chain calls.
+ */
+ public EqualsBuilder append(final float[] lhs, final float[] rhs) {
+ if (isEquals == false) {
+ return this;
+ }
+ if (lhs == rhs) {
+ return this;
+ }
+ if (lhs == null || rhs == null) {
+ this.setEquals(false);
+ return this;
+ }
+ if (lhs.length != rhs.length) {
+ this.setEquals(false);
+ return this;
+ }
+ for (int i = 0; i < lhs.length && isEquals; ++i) {
+ append(lhs[i], rhs[i]);
+ }
+ return this;
+ }
- /**
- * boolean. Length and all
- * values are compared.boolean[]
- * @param rhs the right hand boolean[]
- * @return EqualsBuilder - used to chain calls.
- */
- public EqualsBuilder append(final boolean[] lhs, final boolean[] rhs) {
- if (isEquals == false) {
- return this;
- }
- if (lhs == rhs) {
- return this;
- }
- if (lhs == null || rhs == null) {
- this.setEquals(false);
- return this;
- }
- if (lhs.length != rhs.length) {
- this.setEquals(false);
- return this;
- }
- for (int i = 0; i < lhs.length && isEquals; ++i) {
- append(lhs[i], rhs[i]);
- }
- return this;
- }
+ /**
+ * boolean. Length and all
+ * values are compared.boolean[]
+ * @param rhs the right hand boolean[]
+ * @return EqualsBuilder - used to chain calls.
+ */
+ public EqualsBuilder append(final boolean[] lhs, final boolean[] rhs) {
+ if (isEquals == false) {
+ return this;
+ }
+ if (lhs == rhs) {
+ return this;
+ }
+ if (lhs == null || rhs == null) {
+ this.setEquals(false);
+ return this;
+ }
+ if (lhs.length != rhs.length) {
+ this.setEquals(false);
+ return this;
+ }
+ for (int i = 0; i < lhs.length && isEquals; ++i) {
+ append(lhs[i], rhs[i]);
+ }
+ return this;
+ }
- /**
- * true if the fields that have been checked
- * are all equal.true if the fields that have been checked
+ * are all equal.true if the fields that have been checked
- * are all equal.true if all of the fields that have been checked
- * are equal, false otherwise.
- *
- * @since 3.0
- */
- @Override
- public Boolean build() {
- return Boolean.valueOf(isEquals());
- }
+ /**
+ * true if the fields that have been checked
+ * are all equal.true if all of the fields that have been checked
+ * are equal, false otherwise.
+ * @since 3.0
+ */
+ @Override
+ public Boolean build() {
+ return isEquals();
+ }
- /**
- * Sets the isEquals value.
- *
- * @param isEquals The value to set.
- * @since 2.1
- */
- protected void setEquals(final boolean isEquals) {
- this.isEquals = isEquals;
- }
+ /**
+ * Sets the isEquals value.
+ *
+ * @param isEquals The value to set.
+ * @since 2.1
+ */
+ protected void setEquals(boolean isEquals) {
+ this.isEquals = isEquals;
+ }
- /**
- * Reset the EqualsBuilder so you can use the same object again
- * @since 2.5
- */
- public void reset() {
- this.isEquals = true;
- }
+ /**
+ * Reset the EqualsBuilder so you can use the same object again
+ *
+ * @since 2.5
+ */
+ public void reset() {
+ this.isEquals = true;
+ }
}
diff --git a/hutool-core/src/main/java/cn/hutool/core/codec/Base64.java b/hutool-core/src/main/java/cn/hutool/core/codec/Base64.java
index d796f882b..979b568c8 100644
--- a/hutool-core/src/main/java/cn/hutool/core/codec/Base64.java
+++ b/hutool-core/src/main/java/cn/hutool/core/codec/Base64.java
@@ -1,14 +1,14 @@
package cn.hutool.core.codec;
+import cn.hutool.core.io.FileUtil;
+import cn.hutool.core.io.IoUtil;
+import cn.hutool.core.util.CharsetUtil;
+
import java.io.File;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.charset.Charset;
-import cn.hutool.core.io.FileUtil;
-import cn.hutool.core.io.IoUtil;
-import cn.hutool.core.util.CharsetUtil;
-
/**
* Base64工具类，提供Base64的编码和解码方案
* base64编码是用64（2的6次方）个ASCII字符来表示256（2的8次方）个ASCII字符，
@@ -72,7 +72,7 @@ public class Base64 {
* @return 被加密后的字符串
*/
public static String encode(CharSequence source, String charset) {
- return Base64Encoder.encode(source, CharsetUtil.charset(charset));
+ return encode(source, CharsetUtil.charset(charset));
}
/**
@@ -84,7 +84,7 @@ public class Base64 {
* @since 3.0.6
*/
public static String encodeUrlSafe(CharSequence source, String charset) {
- return Base64Encoder.encodeUrlSafe(source, CharsetUtil.charset(charset));
+ return encodeUrlSafe(source, CharsetUtil.charset(charset));
}
/**
@@ -272,7 +272,7 @@ public class Base64 {
* @return 被加密后的字符串
*/
public static String decodeStr(CharSequence source, String charset) {
- return Base64Decoder.decodeStr(source, CharsetUtil.charset(charset));
+ return decodeStr(source, CharsetUtil.charset(charset));
}
/**
diff --git a/hutool-core/src/main/java/cn/hutool/core/collection/BoundedPriorityQueue.java b/hutool-core/src/main/java/cn/hutool/core/collection/BoundedPriorityQueue.java
index c62c93709..d83d1135c 100644
--- a/hutool-core/src/main/java/cn/hutool/core/collection/BoundedPriorityQueue.java
+++ b/hutool-core/src/main/java/cn/hutool/core/collection/BoundedPriorityQueue.java
@@ -2,7 +2,6 @@ package cn.hutool.core.collection;
import java.util.ArrayList;
import java.util.Arrays;
-import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.PriorityQueue;
@@ -80,7 +79,7 @@ public class BoundedPriorityQueue
+ * 针对一个集合中存在多个相同元素的情况，只保留一个
+ * 例如：集合1：[a, b, c, c, c]，集合2：[a, b, c, c]
+ * 结果：[a, b, c]，此结果中只保留了一个c
+ *
+ * @param
+ * 针对一个集合中存在多个相同元素的情况，保留全部元素
+ * 例如：集合1：[a, b, c, c, c]，集合2：[a, b, c, c]
+ * 结果：[a, b, c, c, c, a, b, c, c]
+ *
+ * @param
* 针对一个集合中存在多个相同元素的情况，计算两个集合中此元素的个数，保留最少的个数
@@ -222,7 +293,7 @@ public class CollUtil {
return coll1;
}
- final ArrayList
+ * subtractToList([1,2,3,4],[2,3,4,5]) -》 [1]
+ *
+ *
+ * @param coll1 集合1
+ * @param coll2 集合2
+ * @param
* 提供的参数为null时返回空{@link ArrayList}
*
- * @param
* 提供的参数为null时返回空{@link ArrayList}
*
- * @param
* 提供的参数为null时返回空{@link ArrayList}
*
- * @param
- * 传入抽象Map{@link AbstractMap}和{@link Map}类将默认创建{@link HashMap}
+ * 传入AbstractMap和{@link Map}类将默认创建{@link HashMap}
*
* @param