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

fix comment

Browse Source
This commit is contained in:
Looly 2022-04-02 00:34:49 +08:00
parent 4d2e7bc755
commit 9a953b2a03
8 changed files with 46 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
hutool-core/src/main/java/cn/hutool/core/math/Calculator.java
View File

@ -9,7 +9,7 @@ import java.util.Stack;
/** /**
* 数学表达式计算工具类<br> * 数学表达式计算工具类<br>
* 见：https://github.com/looly/hutool/issues/1090#issuecomment-693750140 * 见：https://github.com/dromara/hutool/issues/1090#issuecomment-693750140
* *
* @author trainliang, looly * @author trainliang, looly
* @since 5.4.3 * @since 5.4.3

80
hutool-core/src/main/java/cn/hutool/core/math/Money.java
View File

@ -11,7 +11,7 @@ import java.util.Currency;
/** /**
* 单币种货币类，处理货币算术、币种和取整。 * 单币种货币类，处理货币算术、币种和取整。
* <p> * <p>
* 感谢提供此方法的用户：https://github.com/looly/hutool/issues/605 * 感谢提供此方法的用户：https://github.com/dromara/hutool/issues/605
* *
* <p> * <p>
* 货币类中封装了货币金额和币种。目前金额在内部是long类型表示， * 货币类中封装了货币金额和币种。目前金额在内部是long类型表示，
@ -95,7 +95,7 @@ public class Money implements Serializable, Comparable<Money> {
* 构造器。 * 构造器。
* *
* <p> * <p>
* 创建一个具有金额<code>yuan</code>元<code>cent</code>分和缺省币种的货币对象。 * 创建一个具有金额{@code yuan}元{@code cent}分和缺省币种的货币对象。
* *
* @param yuan 金额元数，0的情况下表示元的部分从分中截取 * @param yuan 金额元数，0的情况下表示元的部分从分中截取
* @param cent 金额分数。 * @param cent 金额分数。
@ -108,7 +108,7 @@ public class Money implements Serializable, Comparable<Money> {
* 构造器。 * 构造器。
* *
* <p> * <p>
* 创建一个具有金额<code>yuan</code>元<code>cent</code>分和指定币种的货币对象。 * 创建一个具有金额{@code yuan}元{@code cent}分和指定币种的货币对象。
* *
* @param yuan 金额元数，0的情况下表示元的部分从分中截取 * @param yuan 金额元数，0的情况下表示元的部分从分中截取
* @param cent 金额分数。 * @param cent 金额分数。
@ -128,7 +128,7 @@ public class Money implements Serializable, Comparable<Money> {
* 构造器。 * 构造器。
* *
* <p> * <p>
* 创建一个具有金额<code>amount</code>元和缺省币种的货币对象。 * 创建一个具有金额{@code amount}元和缺省币种的货币对象。
* *
* @param amount 金额，以元为单位。 * @param amount 金额，以元为单位。
*/ */
@ -140,7 +140,7 @@ public class Money implements Serializable, Comparable<Money> {
* 构造器。 * 构造器。
* *
* <p> * <p>
* 创建一个具有金额<code>amount</code>元和指定币种<code>currency</code>的货币对象。 * 创建一个具有金额{@code amount}元和指定币种{@code currency}的货币对象。
* *
* @param amount 金额，以元为单位。 * @param amount 金额，以元为单位。
* @param currency 币种。 * @param currency 币种。
@ -153,8 +153,8 @@ public class Money implements Serializable, Comparable<Money> {
* 构造器。 * 构造器。
* *
* <p> * <p>
* 创建一个具有金额<code>amount</code>元和指定币种<code>currency</code>的货币对象。 * 创建一个具有金额{@code amount}元和指定币种{@code currency}的货币对象。
* 如果金额不能转换为整数分，则使用指定的取整模式<code>roundingMode</code>取整。 * 如果金额不能转换为整数分，则使用指定的取整模式{@code roundingMode}取整。
* *
* @param amount 金额，以元为单位。 * @param amount 金额，以元为单位。
* @param currency 币种。 * @param currency 币种。
@ -168,21 +168,21 @@ public class Money implements Serializable, Comparable<Money> {
* 构造器。 * 构造器。
* *
* <p> * <p>
* 创建一个具有参数<code>amount</code>指定金额和缺省币种的货币对象。 * 创建一个具有参数{@code amount}指定金额和缺省币种的货币对象。
* 如果金额不能转换为整数分，则使用四舍五入方式取整。 * 如果金额不能转换为整数分，则使用四舍五入方式取整。
* *
* <p> * <p>
* 注意：由于double类型运算中存在误差，使用四舍五入方式取整的 * 注意：由于double类型运算中存在误差，使用四舍五入方式取整的
* 结果并不确定，因此，应尽量避免使用double类型创建货币类型。 * 结果并不确定，因此，应尽量避免使用double类型创建货币类型。
* 例： * 例：
* <code> * {@code
* assertEquals(999, Math.round(9.995 * 100)); * assertEquals(999, Math.round(9.995 * 100));
* assertEquals(1000, Math.round(999.5)); * assertEquals(1000, Math.round(999.5));
* money = new Money((9.995)); * money = new Money((9.995));
* assertEquals(999, money.getCent()); * assertEquals(999, money.getCent());
* money = new Money(10.005); * money = new Money(10.005);
* assertEquals(1001, money.getCent()); * assertEquals(1001, money.getCent());
* </code> * }
* *
* @param amount 金额，以元为单位。 * @param amount 金额，以元为单位。
*/ */
@ -194,21 +194,21 @@ public class Money implements Serializable, Comparable<Money> {
* 构造器。 * 构造器。
* *
* <p> * <p>
* 创建一个具有金额<code>amount</code>和指定币种的货币对象。 * 创建一个具有金额{@code amount}和指定币种的货币对象。
* 如果金额不能转换为整数分，则使用四舍五入方式取整。 * 如果金额不能转换为整数分，则使用四舍五入方式取整。
* *
* <p> * <p>
* 注意：由于double类型运算中存在误差，使用四舍五入方式取整的 * 注意：由于double类型运算中存在误差，使用四舍五入方式取整的
* 结果并不确定，因此，应尽量避免使用double类型创建货币类型。 * 结果并不确定，因此，应尽量避免使用double类型创建货币类型。
* 例： * 例：
* <code> * {@code
* assertEquals(999, Math.round(9.995 * 100)); * assertEquals(999, Math.round(9.995 * 100));
* assertEquals(1000, Math.round(999.5)); * assertEquals(1000, Math.round(999.5));
* money = new Money((9.995)); * money = new Money((9.995));
* assertEquals(999, money.getCent()); * assertEquals(999, money.getCent());
* money = new Money(10.005); * money = new Money(10.005);
* assertEquals(1001, money.getCent()); * assertEquals(1001, money.getCent());
* </code> * }
* *
* @param amount 金额，以元为单位。 * @param amount 金额，以元为单位。
* @param currency 币种。 * @param currency 币种。
@ -222,8 +222,8 @@ public class Money implements Serializable, Comparable<Money> {
* 构造器。 * 构造器。
* *
* <p> * <p>
* 创建一个具有金额<code>amount</code>和缺省币种的货币对象。 * 创建一个具有金额{@code amount}和缺省币种的货币对象。
* 如果金额不能转换为整数分，则使用缺省取整模式<code>DEFAULT_ROUNDING_MODE</code>取整。 * 如果金额不能转换为整数分，则使用缺省取整模式{@code DEFAULT_ROUNDING_MODE}取整。
* *
* @param amount 金额，以元为单位。 * @param amount 金额，以元为单位。
*/ */
@ -235,8 +235,8 @@ public class Money implements Serializable, Comparable<Money> {
* 构造器。 * 构造器。
* *
* <p> * <p>
* 创建一个具有参数<code>amount</code>指定金额和缺省币种的货币对象。 * 创建一个具有参数{@code amount}指定金额和缺省币种的货币对象。
* 如果金额不能转换为整数分，则使用指定的取整模式<code>roundingMode</code>取整。 * 如果金额不能转换为整数分，则使用指定的取整模式{@code roundingMode}取整。
* *
* @param amount 金额，以元为单位。 * @param amount 金额，以元为单位。
* @param roundingMode 取整模式 * @param roundingMode 取整模式
@ -249,8 +249,8 @@ public class Money implements Serializable, Comparable<Money> {
* 构造器。 * 构造器。
* *
* <p> * <p>
* 创建一个具有金额<code>amount</code>和指定币种的货币对象。 * 创建一个具有金额{@code amount}和指定币种的货币对象。
* 如果金额不能转换为整数分，则使用缺省的取整模式<code>DEFAULT_ROUNDING_MODE</code>进行取整。 * 如果金额不能转换为整数分，则使用缺省的取整模式{@code DEFAULT_ROUNDING_MODE}进行取整。
* *
* @param amount 金额，以元为单位。 * @param amount 金额，以元为单位。
* @param currency 币种 * @param currency 币种
@ -263,8 +263,8 @@ public class Money implements Serializable, Comparable<Money> {
* 构造器。 * 构造器。
* *
* <p> * <p>
* 创建一个具有金额<code>amount</code>和指定币种的货币对象。 * 创建一个具有金额{@code amount}和指定币种的货币对象。
* 如果金额不能转换为整数分，则使用指定的取整模式<code>roundingMode</code>取整。 * 如果金额不能转换为整数分，则使用指定的取整模式{@code roundingMode}取整。
* *
* @param amount 金额，以元为单位。 * @param amount 金额，以元为单位。
* @param currency 币种。 * @param currency 币种。
@ -338,8 +338,7 @@ public class Money implements Serializable, Comparable<Money> {
* </ul> * </ul>
* *
* @param other 待比较的另一对象。 * @param other 待比较的另一对象。
* @return <code>true</code>表示相等，<code>false</code>表示不相等。 * @return {@code true}表示相等，{@code false}表示不相等。
* @see java.lang.Object#equals(java.lang.Object)
*/ */
@Override @Override
public boolean equals(Object other) { public boolean equals(Object other) {
@ -356,7 +355,7 @@ public class Money implements Serializable, Comparable<Money> {
* </ul> * </ul>
* *
* @param other 待比较的另一货币对象。 * @param other 待比较的另一货币对象。
* @return <code>true</code>表示相等，<code>false</code>表示不相等。 * @return {@code true}表示相等，{@code false}表示不相等。
*/ */
public boolean equals(Money other) { public boolean equals(Money other) {
return currency.equals(other.currency) && (cent == other.cent); return currency.equals(other.currency) && (cent == other.cent);
@ -366,7 +365,6 @@ public class Money implements Serializable, Comparable<Money> {
* 计算本货币对象的杂凑值。 * 计算本货币对象的杂凑值。
* *
* @return 本货币对象的杂凑值。 * @return 本货币对象的杂凑值。
* @see Object#hashCode()
*/ */
@Override @Override
public int hashCode() { public int hashCode() {
@ -378,7 +376,7 @@ public class Money implements Serializable, Comparable<Money> {
* *
* <p> * <p>
* 比较本货币对象与另一货币对象的大小。 * 比较本货币对象与另一货币对象的大小。
* 如果待比较的两个货币对象的币种不同，则抛出<code>java.lang.IllegalArgumentException</code>。 * 如果待比较的两个货币对象的币种不同，则抛出{@code java.lang.IllegalArgumentException}。
* 如果本货币对象的金额少于待比较货币对象，则返回-1。 * 如果本货币对象的金额少于待比较货币对象，则返回-1。
* 如果本货币对象的金额等于待比较货币对象，则返回0。 * 如果本货币对象的金额等于待比较货币对象，则返回0。
* 如果本货币对象的金额大于待比较货币对象，则返回1。 * 如果本货币对象的金额大于待比较货币对象，则返回1。
@ -398,7 +396,7 @@ public class Money implements Serializable, Comparable<Money> {
* *
* <p> * <p>
* 判断本货币对象是否大于另一货币对象。 * 判断本货币对象是否大于另一货币对象。
* 如果待比较的两个货币对象的币种不同，则抛出<code>java.lang.IllegalArgumentException</code>。 * 如果待比较的两个货币对象的币种不同，则抛出{@code java.lang.IllegalArgumentException}。
* 如果本货币对象的金额大于待比较货币对象，则返回true，否则返回false。 * 如果本货币对象的金额大于待比较货币对象，则返回true，否则返回false。
* *
* @param other 另一对象。 * @param other 另一对象。
@ -417,7 +415,7 @@ public class Money implements Serializable, Comparable<Money> {
* <p> * <p>
* 如果两货币币种相同，则返回一个新的相同币种的货币对象，其金额为 * 如果两货币币种相同，则返回一个新的相同币种的货币对象，其金额为
* 两货币对象金额之和，本货币对象的值不变。 * 两货币对象金额之和，本货币对象的值不变。
* 如果两货币对象币种不同，抛出<code>java.lang.IllegalArgumentException</code>。 * 如果两货币对象币种不同，抛出{@code java.lang.IllegalArgumentException}。
* *
* @param other 作为加数的货币对象。 * @param other 作为加数的货币对象。
* @return 相加后的结果。 * @return 相加后的结果。
@ -434,7 +432,7 @@ public class Money implements Serializable, Comparable<Money> {
* *
* <p> * <p>
* 如果两货币币种相同，则本货币对象的金额等于两货币对象金额之和，并返回本货币对象的引用。 * 如果两货币币种相同，则本货币对象的金额等于两货币对象金额之和，并返回本货币对象的引用。
* 如果两货币对象币种不同，抛出<code>java.lang.IllegalArgumentException</code>。 * 如果两货币对象币种不同，抛出{@code java.lang.IllegalArgumentException}。
* *
* @param other 作为加数的货币对象。 * @param other 作为加数的货币对象。
* @return 累加后的本货币对象。 * @return 累加后的本货币对象。
@ -454,7 +452,7 @@ public class Money implements Serializable, Comparable<Money> {
* <p> * <p>
* 如果两货币币种相同，则返回一个新的相同币种的货币对象，其金额为 * 如果两货币币种相同，则返回一个新的相同币种的货币对象，其金额为
* 本货币对象的金额减去参数货币对象的金额。本货币对象的值不变。 * 本货币对象的金额减去参数货币对象的金额。本货币对象的值不变。
* 如果两货币币种不同，抛出<code>java.lang.IllegalArgumentException</code>。 * 如果两货币币种不同，抛出{@code java.lang.IllegalArgumentException}。
* *
* @param other 作为减数的货币对象。 * @param other 作为减数的货币对象。
* @return 相减后的结果。 * @return 相减后的结果。
@ -471,7 +469,7 @@ public class Money implements Serializable, Comparable<Money> {
* *
* <p> * <p>
* 如果两货币币种相同，则本货币对象的金额等于两货币对象金额之差，并返回本货币对象的引用。 * 如果两货币币种相同，则本货币对象的金额等于两货币对象金额之差，并返回本货币对象的引用。
* 如果两货币币种不同，抛出<code>java.lang.IllegalArgumentException</code>。 * 如果两货币币种不同，抛出{@code java.lang.IllegalArgumentException}。
* *
* @param other 作为减数的货币对象。 * @param other 作为减数的货币对象。
* @return 累减后的本货币对象。 * @return 累减后的本货币对象。
@ -550,7 +548,7 @@ public class Money implements Serializable, Comparable<Money> {
* <p> * <p>
* 返回一个新的货币对象，币种与本货币对象相同，金额为本货币对象的金额乘以乘数。 * 返回一个新的货币对象，币种与本货币对象相同，金额为本货币对象的金额乘以乘数。
* 本货币对象的值不变。如果相乘后的金额不能转换为整数分，使用缺省的取整模式 * 本货币对象的值不变。如果相乘后的金额不能转换为整数分，使用缺省的取整模式
* <code>DEFUALT_ROUNDING_MODE</code>进行取整。 * {@code DEFUALT_ROUNDING_MODE}进行取整。
* *
* @param val 乘数 * @param val 乘数
* @return 相乘后的结果。 * @return 相乘后的结果。
@ -565,7 +563,7 @@ public class Money implements Serializable, Comparable<Money> {
* <p> * <p>
* 本货币对象金额乘以乘数，并返回本货币对象。 * 本货币对象金额乘以乘数，并返回本货币对象。
* 如果相乘后的金额不能转换为整数分，使用缺省的取整方式 * 如果相乘后的金额不能转换为整数分，使用缺省的取整方式
* <code>DEFUALT_ROUNDING_MODE</code>进行取整。 * {@code DEFUALT_ROUNDING_MODE}进行取整。
* *
* @param val 乘数 * @param val 乘数
* @return 累乘后的结果。 * @return 累乘后的结果。
@ -580,7 +578,7 @@ public class Money implements Serializable, Comparable<Money> {
* <p> * <p>
* 返回一个新的货币对象，币种与本货币对象相同，金额为本货币对象的金额乘以乘数。 * 返回一个新的货币对象，币种与本货币对象相同，金额为本货币对象的金额乘以乘数。
* 本货币对象的值不变。如果相乘后的金额不能转换为整数分，使用指定的取整方式 * 本货币对象的值不变。如果相乘后的金额不能转换为整数分，使用指定的取整方式
* <code>roundingMode</code>进行取整。 * {@code roundingMode}进行取整。
* *
* @param val 乘数 * @param val 乘数
* @param roundingMode 取整方式 * @param roundingMode 取整方式
@ -598,7 +596,7 @@ public class Money implements Serializable, Comparable<Money> {
* <p> * <p>
* 本货币对象金额乘以乘数，并返回本货币对象。 * 本货币对象金额乘以乘数，并返回本货币对象。
* 如果相乘后的金额不能转换为整数分，使用指定的取整方式 * 如果相乘后的金额不能转换为整数分，使用指定的取整方式
* <code>roundingMode</code>进行取整。 * {@code roundingMode}进行取整。
* *
* @param val 乘数 * @param val 乘数
* @param roundingMode 取整方式 * @param roundingMode 取整方式
@ -648,7 +646,7 @@ public class Money implements Serializable, Comparable<Money> {
* <p> * <p>
* 返回一个新的货币对象，币种与本货币对象相同，金额为本货币对象的金额除以除数。 * 返回一个新的货币对象，币种与本货币对象相同，金额为本货币对象的金额除以除数。
* 本货币对象的值不变。如果相除后的金额不能转换为整数分，使用缺省的取整模式 * 本货币对象的值不变。如果相除后的金额不能转换为整数分，使用缺省的取整模式
* <code>DEFAULT_ROUNDING_MODE</code>进行取整。 * {@code DEFAULT_ROUNDING_MODE}进行取整。
* *
* @param val 除数 * @param val 除数
* @return 相除后的结果。 * @return 相除后的结果。
@ -663,7 +661,7 @@ public class Money implements Serializable, Comparable<Money> {
* <p> * <p>
* 返回一个新的货币对象，币种与本货币对象相同，金额为本货币对象的金额除以除数。 * 返回一个新的货币对象，币种与本货币对象相同，金额为本货币对象的金额除以除数。
* 本货币对象的值不变。如果相除后的金额不能转换为整数分，使用指定的取整模式 * 本货币对象的值不变。如果相除后的金额不能转换为整数分，使用指定的取整模式
* <code>roundingMode</code>进行取整。 * {@code roundingMode}进行取整。
* *
* @param val 除数 * @param val 除数
* @param roundingMode 取整 * @param roundingMode 取整
@ -681,7 +679,7 @@ public class Money implements Serializable, Comparable<Money> {
* <p> * <p>
* 本货币对象金额除以除数，并返回本货币对象。 * 本货币对象金额除以除数，并返回本货币对象。
* 如果相除后的金额不能转换为整数分，使用缺省的取整模式 * 如果相除后的金额不能转换为整数分，使用缺省的取整模式
* <code>DEFAULT_ROUNDING_MODE</code>进行取整。 * {@code DEFAULT_ROUNDING_MODE}进行取整。
* *
* @param val 除数 * @param val 除数
* @return 累除后的结果。 * @return 累除后的结果。
@ -696,7 +694,7 @@ public class Money implements Serializable, Comparable<Money> {
* <p> * <p>
* 本货币对象金额除以除数，并返回本货币对象。 * 本货币对象金额除以除数，并返回本货币对象。
* 如果相除后的金额不能转换为整数分，使用指定的取整模式 * 如果相除后的金额不能转换为整数分，使用指定的取整模式
* <code>roundingMode</code>进行取整。 * {@code roundingMode}进行取整。
* *
* @param val 除数 * @param val 除数
* @param roundingMode 保留小数方式 * @param roundingMode 保留小数方式
@ -714,7 +712,7 @@ public class Money implements Serializable, Comparable<Money> {
* 货币分配。 * 货币分配。
* *
* <p> * <p>
* 将本货币对象尽可能平均分配成<code>targets</code>份。 * 将本货币对象尽可能平均分配成{@code targets}份。
* 如果不能平均分配尽，则将零头放到开始的若干份中。分配 * 如果不能平均分配尽，则将零头放到开始的若干份中。分配
* 运算能够确保不会丢失金额零头。 * 运算能够确保不会丢失金额零头。
* *
@ -792,7 +790,7 @@ public class Money implements Serializable, Comparable<Money> {
* *
* <p> * <p>
* 如果本货币对象与另一货币对象具有相同的币种，则方法返回。 * 如果本货币对象与另一货币对象具有相同的币种，则方法返回。
* 否则抛出运行时异常<code>java.lang.IllegalArgumentException</code>。 * 否则抛出运行时异常{@code java.lang.IllegalArgumentException}。
* *
* @param other 另一货币对象 * @param other 另一货币对象
* @throws IllegalArgumentException 如果本货币对象与另一货币对象币种不同。 * @throws IllegalArgumentException 如果本货币对象与另一货币对象币种不同。

2
hutool-core/src/main/java/cn/hutool/core/net/NetUtil.java
View File

@ -484,7 +484,7 @@ public class NetUtil {
* <p> * <p>
* 此方法不会抛出异常，获取失败将返回{@code null}<br> * 此方法不会抛出异常，获取失败将返回{@code null}<br>
* <p> * <p>
* 见：https://github.com/looly/hutool/issues/428 * 见：https://github.com/dromara/hutool/issues/428
* *
* @return 本机网卡IP地址，获取失败返回{@code null} * @return 本机网卡IP地址，获取失败返回{@code null}
* @since 3.0.1 * @since 3.0.1

2
hutool-core/src/test/java/cn/hutool/core/bean/BeanUtilTest.java
View File

@ -492,7 +492,7 @@ public class BeanUtilTest {
} }
/** /**
* <a href="https://github.com/looly/hutool/issues/1173">#1173</a> * <a href="https://github.com/dromara/hutool/issues/1173">#1173</a>
*/ */
@Test @Test
public void beanToBeanOverlayFieldTest() { public void beanToBeanOverlayFieldTest() {

2
hutool-core/src/test/java/cn/hutool/core/date/DateUtilTest.java
View File

@ -955,7 +955,7 @@ public class DateUtilTest {
@Test(expected = DateException.class) @Test(expected = DateException.class)
public void parseNotFitTest() { public void parseNotFitTest() {
//https://github.com/looly/hutool/issues/1332 //https://github.com/dromara/hutool/issues/1332
// 在日期格式不匹配的时候，测试是否正常报错 // 在日期格式不匹配的时候，测试是否正常报错
DateUtil.parse("2020-12-23", DatePattern.PURE_DATE_PATTERN); DateUtil.parse("2020-12-23", DatePattern.PURE_DATE_PATTERN);
} }

2
hutool-core/src/test/java/cn/hutool/core/util/ZipUtilTest.java
View File

@ -150,7 +150,7 @@ public class ZipUtilTest {
@Test @Test
@Ignore @Ignore
public void zipStreamTest(){ public void zipStreamTest(){
//https://github.com/looly/hutool/issues/944 //https://github.com/dromara/hutool/issues/944
String dir = "d:/test"; String dir = "d:/test";
String zip = "d:/test.zip"; String zip = "d:/test.zip";
try (OutputStream out = new FileOutputStream(zip)){ try (OutputStream out = new FileOutputStream(zip)){

2
hutool-http/src/test/java/cn/hutool/http/useragent/UserAgentUtilTest.java
View File

@ -204,7 +204,7 @@ public class UserAgentUtilTest {
} }
/** /**
* https://github.com/looly/hutool/issues/1177 * https://github.com/dromara/hutool/issues/1177
*/ */
@Test @Test
public void parseMicroMessengerTest() { public void parseMicroMessengerTest() {

2
hutool-json/src/test/java/cn/hutool/json/JSONUtilTest.java
View File

@ -213,7 +213,7 @@ public class JSONUtilTest {
@Test @Test
public void sqlExceptionTest(){ public void sqlExceptionTest(){
//https://github.com/looly/hutool/issues/1399 //https://github.com/dromara/hutool/issues/1399
// SQLException实现了Iterable接口，默认是遍历之，会栈溢出，修正后只返回string // SQLException实现了Iterable接口，默认是遍历之，会栈溢出，修正后只返回string
final JSONObject set = JSONUtil.createObj().set("test", new SQLException("test")); final JSONObject set = JSONUtil.createObj().set("test", new SQLException("test"));
Assert.assertEquals("{\"test\":\"java.sql.SQLException: test\"}", set.toString()); Assert.assertEquals("{\"test\":\"java.sql.SQLException: test\"}", set.toString());