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 code

Browse Source
This commit is contained in:
Looly 2019-11-20 00:15:52 +08:00
parent eec404f875
commit 106ea5a759
12 changed files with 399 additions and 378 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
CHANGELOG.md
View File

@ -6,8 +6,11 @@
## 5.0.7 ## 5.0.7
### 新特性 ### 新特性
* 【core 】 解决NumberUtil导致的ambiguous问题（issue#630@Github）
* 【core 】 BeanUtil.isEmpty()忽略字段支持，增加isNotEmpty（issue#629@Github）
### Bug修复 ### Bug修复
* 【extra】 修复SFTP.upload上传失败的问题
------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------

30
hutool-core/src/main/java/cn/hutool/core/bean/BeanUtil.java
View File

@ -292,7 +292,7 @@ public class BeanUtil {
/** /**
* 解析Bean中的属性值 * 解析Bean中的属性值
* *
* @param <T> 属性值类型 * @param <T> 属性值类型
* @param bean Bean对象，支持Map、List、Collection、Array * @param bean Bean对象，支持Map、List、Collection、Array
* @param expression 表达式，例如：person.friend[5].name * @param expression 表达式，例如：person.friend[5].name
* @return Bean属性值 * @return Bean属性值
@ -676,17 +676,31 @@ public class BeanUtil {
return bean; return bean;
} }
/**
* 判断Bean是否为非空对象，非空对象表示本身不为<code>null</code>或者含有非<code>null</code>属性的对象
*
* @param bean Bean对象
* @param ignoreFiledNames 忽略检查的字段名
* @return 是否为空，<code>true</code> - 空 / <code>false</code> - 非空
* @since 5.0.7
*/
public static boolean isNotEmpty(Object bean, String... ignoreFiledNames) {
return false == isEmpty(bean, ignoreFiledNames);
}
/** /**
* 判断Bean是否为空对象，空对象表示本身为<code>null</code>或者所有属性都为<code>null</code> * 判断Bean是否为空对象，空对象表示本身为<code>null</code>或者所有属性都为<code>null</code>
* *
* @param bean Bean对象 * @param bean Bean对象
* @param ignoreFiledNames 忽略检查的字段名
* @return 是否为空，<code>true</code> - 空 / <code>false</code> - 非空 * @return 是否为空，<code>true</code> - 空 / <code>false</code> - 非空
* @since 4.1.10 * @since 4.1.10
*/ */
public static boolean isEmpty(Object bean) { public static boolean isEmpty(Object bean, String... ignoreFiledNames) {
if (null != bean) { if (null != bean) {
for (Field field : ReflectUtil.getFields(bean.getClass())) { for (Field field : ReflectUtil.getFields(bean.getClass())) {
if (null != ReflectUtil.getFieldValue(bean, field)) { if ((false == ArrayUtil.contains(ignoreFiledNames, field.getName()))
&& null != ReflectUtil.getFieldValue(bean, field)) {
return false; return false;
} }
} }
@ -698,16 +712,18 @@ public class BeanUtil {
* 判断Bean是否包含值为<code>null</code>的属性<br> * 判断Bean是否包含值为<code>null</code>的属性<br>
* 对象本身为<code>null</code>也返回true * 对象本身为<code>null</code>也返回true
* *
* @param bean Bean对象 * @param bean Bean对象
* @param ignoreFiledNames 忽略检查的字段名
* @return 是否包含值为<code>null</code>的属性，<code>true</code> - 包含 / <code>false</code> - 不包含 * @return 是否包含值为<code>null</code>的属性，<code>true</code> - 包含 / <code>false</code> - 不包含
* @since 4.1.10 * @since 4.1.10
*/ */
public static boolean hasNullField(Object bean) { public static boolean hasNullField(Object bean, String... ignoreFiledNames) {
if (null == bean) { if (null == bean) {
return true; return true;
} }
for (Field field : ReflectUtil.getFields(bean.getClass())) { for (Field field : ReflectUtil.getFields(bean.getClass())) {
if (null == ReflectUtil.getFieldValue(bean, field)) { if ((false == ArrayUtil.contains(ignoreFiledNames, field.getName()))//
&& null == ReflectUtil.getFieldValue(bean, field)) {
return true; return true;
} }
} }

74
hutool-core/src/main/java/cn/hutool/core/util/ArrayUtil.java
View File

@ -477,7 +477,7 @@ public class ArrayUtil {
* @return 新数组 * @return 新数组
* @since 4.0.8 * @since 4.0.8
*/ */
@SuppressWarnings("unchecked") @SuppressWarnings({"unchecked", "SuspiciousSystemArraycopy"})
public static <T> Object insert(Object array, int index, T... newElements) { public static <T> Object insert(Object array, int index, T... newElements) {
if (isEmpty(newElements)) { if (isEmpty(newElements)) {
return array; return array;
@ -541,6 +541,7 @@ public class ArrayUtil {
final int length = length(array); final int length = length(array);
final Object newArray = Array.newInstance(array.getClass().getComponentType(), newSize); final Object newArray = Array.newInstance(array.getClass().getComponentType(), newSize);
if (newSize > 0 && isNotEmpty(array)) { if (newSize > 0 && isNotEmpty(array)) {
//noinspection SuspiciousSystemArraycopy
System.arraycopy(array, 0, newArray, 0, Math.min(length, newSize)); System.arraycopy(array, 0, newArray, 0, Math.min(length, newSize));
} }
return newArray; return newArray;
@ -656,6 +657,7 @@ public class ArrayUtil {
* @since 3.0.6 * @since 3.0.6
*/ */
public static Object copy(Object src, int srcPos, Object dest, int destPos, int length) { public static Object copy(Object src, int srcPos, Object dest, int destPos, int length) {
//noinspection SuspiciousSystemArraycopy
System.arraycopy(src, srcPos, dest, destPos, length); System.arraycopy(src, srcPos, dest, destPos, length);
return dest; return dest;
} }
@ -671,6 +673,7 @@ public class ArrayUtil {
* @since 3.0.6 * @since 3.0.6
*/ */
public static Object copy(Object src, Object dest, int length) { public static Object copy(Object src, Object dest, int length) {
//noinspection SuspiciousSystemArraycopy
System.arraycopy(src, 0, dest, 0, length); System.arraycopy(src, 0, dest, 0, length);
return dest; return dest;
} }
@ -1477,7 +1480,7 @@ public class ArrayUtil {
final Integer[] array = new Integer[length]; final Integer[] array = new Integer[length];
for (int i = 0; i < length; i++) { for (int i = 0; i < length; i++) {
array[i] = Integer.valueOf(values[i]); array[i] = values[i];
} }
return array; return array;
} }
@ -1499,7 +1502,7 @@ public class ArrayUtil {
final int[] array = new int[length]; final int[] array = new int[length];
for (int i = 0; i < length; i++) { for (int i = 0; i < length; i++) {
array[i] = values[i].intValue(); array[i] = values[i];
} }
return array; return array;
} }
@ -1521,7 +1524,7 @@ public class ArrayUtil {
final Long[] array = new Long[length]; final Long[] array = new Long[length];
for (int i = 0; i < length; i++) { for (int i = 0; i < length; i++) {
array[i] = Long.valueOf(values[i]); array[i] = values[i];
} }
return array; return array;
} }
@ -1543,7 +1546,7 @@ public class ArrayUtil {
final long[] array = new long[length]; final long[] array = new long[length];
for (int i = 0; i < length; i++) { for (int i = 0; i < length; i++) {
array[i] = values[i].longValue(); array[i] = values[i];
} }
return array; return array;
} }
@ -1565,7 +1568,7 @@ public class ArrayUtil {
final Character[] array = new Character[length]; final Character[] array = new Character[length];
for (int i = 0; i < length; i++) { for (int i = 0; i < length; i++) {
array[i] = Character.valueOf(values[i]); array[i] = values[i];
} }
return array; return array;
} }
@ -1587,7 +1590,7 @@ public class ArrayUtil {
char[] array = new char[length]; char[] array = new char[length];
for (int i = 0; i < length; i++) { for (int i = 0; i < length; i++) {
array[i] = values[i].charValue(); array[i] = values[i];
} }
return array; return array;
} }
@ -1609,7 +1612,7 @@ public class ArrayUtil {
final Byte[] array = new Byte[length]; final Byte[] array = new Byte[length];
for (int i = 0; i < length; i++) { for (int i = 0; i < length; i++) {
array[i] = Byte.valueOf(values[i]); array[i] = values[i];
} }
return array; return array;
} }
@ -1631,7 +1634,7 @@ public class ArrayUtil {
final byte[] array = new byte[length]; final byte[] array = new byte[length];
for (int i = 0; i < length; i++) { for (int i = 0; i < length; i++) {
array[i] = values[i].byteValue(); array[i] = ObjectUtil.defaultIfNull(values[i], (byte)0);
} }
return array; return array;
} }
@ -1653,7 +1656,7 @@ public class ArrayUtil {
final Short[] array = new Short[length]; final Short[] array = new Short[length];
for (int i = 0; i < length; i++) { for (int i = 0; i < length; i++) {
array[i] = Short.valueOf(values[i]); array[i] = values[i];
} }
return array; return array;
} }
@ -1675,7 +1678,7 @@ public class ArrayUtil {
final short[] array = new short[length]; final short[] array = new short[length];
for (int i = 0; i < length; i++) { for (int i = 0; i < length; i++) {
array[i] = values[i].shortValue(); array[i] = ObjectUtil.defaultIfNull(values[i], (short)0);
} }
return array; return array;
} }
@ -1697,7 +1700,7 @@ public class ArrayUtil {
final Float[] array = new Float[length]; final Float[] array = new Float[length];
for (int i = 0; i < length; i++) { for (int i = 0; i < length; i++) {
array[i] = Float.valueOf(values[i]); array[i] = values[i];
} }
return array; return array;
} }
@ -1719,7 +1722,7 @@ public class ArrayUtil {
final float[] array = new float[length]; final float[] array = new float[length];
for (int i = 0; i < length; i++) { for (int i = 0; i < length; i++) {
array[i] = values[i].floatValue(); array[i] = ObjectUtil.defaultIfNull(values[i], 0F);
} }
return array; return array;
} }
@ -1741,7 +1744,7 @@ public class ArrayUtil {
final Double[] array = new Double[length]; final Double[] array = new Double[length];
for (int i = 0; i < length; i++) { for (int i = 0; i < length; i++) {
array[i] = Double.valueOf(values[i]); array[i] = values[i];
} }
return array; return array;
} }
@ -1763,7 +1766,7 @@ public class ArrayUtil {
final double[] array = new double[length]; final double[] array = new double[length];
for (int i = 0; i < length; i++) { for (int i = 0; i < length; i++) {
array[i] = values[i].doubleValue(); array[i] = ObjectUtil.defaultIfNull(values[i], 0D);
} }
return array; return array;
} }
@ -1785,7 +1788,7 @@ public class ArrayUtil {
final Boolean[] array = new Boolean[length]; final Boolean[] array = new Boolean[length];
for (int i = 0; i < length; i++) { for (int i = 0; i < length; i++) {
array[i] = Boolean.valueOf(values[i]); array[i] = values[i];
} }
return array; return array;
} }
@ -1807,7 +1810,7 @@ public class ArrayUtil {
final boolean[] array = new boolean[length]; final boolean[] array = new boolean[length];
for (int i = 0; i < length; i++) { for (int i = 0; i < length; i++) {
array[i] = values[i].booleanValue(); array[i] = ObjectUtil.defaultIfNull(values[i], false);
} }
return array; return array;
} }
@ -2841,6 +2844,7 @@ public class ArrayUtil {
* @throws IllegalArgumentException 参数对象不为数组对象 * @throws IllegalArgumentException 参数对象不为数组对象
* @since 3.0.8 * @since 3.0.8
*/ */
@SuppressWarnings("SuspiciousSystemArraycopy")
public static Object remove(Object array, int index) throws IllegalArgumentException { public static Object remove(Object array, int index) throws IllegalArgumentException {
if (null == array) { if (null == array) {
return null; return null;
@ -3339,9 +3343,9 @@ public class ArrayUtil {
throw new IllegalArgumentException("Number array must not empty !"); throw new IllegalArgumentException("Number array must not empty !");
} }
T min = numberArray[0]; T min = numberArray[0];
for (int i = 0; i < numberArray.length; i++) { for (T t : numberArray) {
if (ObjectUtil.compare(min, numberArray[i]) > 0) { if (ObjectUtil.compare(min, t) > 0) {
min = numberArray[i]; min = t;
} }
} }
return min; return min;
@ -3359,7 +3363,7 @@ public class ArrayUtil {
throw new IllegalArgumentException("Number array must not empty !"); throw new IllegalArgumentException("Number array must not empty !");
} }
long min = numberArray[0]; long min = numberArray[0];
for (int i = 0; i < numberArray.length; i++) { for (int i = 1; i < numberArray.length; i++) {
if (min > numberArray[i]) { if (min > numberArray[i]) {
min = numberArray[i]; min = numberArray[i];
} }
@ -3379,7 +3383,7 @@ public class ArrayUtil {
throw new IllegalArgumentException("Number array must not empty !"); throw new IllegalArgumentException("Number array must not empty !");
} }
int min = numberArray[0]; int min = numberArray[0];
for (int i = 0; i < numberArray.length; i++) { for (int i = 1; i < numberArray.length; i++) {
if (min > numberArray[i]) { if (min > numberArray[i]) {
min = numberArray[i]; min = numberArray[i];
} }
@ -3399,7 +3403,7 @@ public class ArrayUtil {
throw new IllegalArgumentException("Number array must not empty !"); throw new IllegalArgumentException("Number array must not empty !");
} }
short min = numberArray[0]; short min = numberArray[0];
for (int i = 0; i < numberArray.length; i++) { for (int i = 1; i < numberArray.length; i++) {
if (min > numberArray[i]) { if (min > numberArray[i]) {
min = numberArray[i]; min = numberArray[i];
} }
@ -3419,7 +3423,7 @@ public class ArrayUtil {
throw new IllegalArgumentException("Number array must not empty !"); throw new IllegalArgumentException("Number array must not empty !");
} }
char min = numberArray[0]; char min = numberArray[0];
for (int i = 0; i < numberArray.length; i++) { for (int i = 1; i < numberArray.length; i++) {
if (min > numberArray[i]) { if (min > numberArray[i]) {
min = numberArray[i]; min = numberArray[i];
} }
@ -3439,7 +3443,7 @@ public class ArrayUtil {
throw new IllegalArgumentException("Number array must not empty !"); throw new IllegalArgumentException("Number array must not empty !");
} }
byte min = numberArray[0]; byte min = numberArray[0];
for (int i = 0; i < numberArray.length; i++) { for (int i = 1; i < numberArray.length; i++) {
if (min > numberArray[i]) { if (min > numberArray[i]) {
min = numberArray[i]; min = numberArray[i];
} }
@ -3459,7 +3463,7 @@ public class ArrayUtil {
throw new IllegalArgumentException("Number array must not empty !"); throw new IllegalArgumentException("Number array must not empty !");
} }
double min = numberArray[0]; double min = numberArray[0];
for (int i = 0; i < numberArray.length; i++) { for (int i = 1; i < numberArray.length; i++) {
if (min > numberArray[i]) { if (min > numberArray[i]) {
min = numberArray[i]; min = numberArray[i];
} }
@ -3479,7 +3483,7 @@ public class ArrayUtil {
throw new IllegalArgumentException("Number array must not empty !"); throw new IllegalArgumentException("Number array must not empty !");
} }
float min = numberArray[0]; float min = numberArray[0];
for (int i = 0; i < numberArray.length; i++) { for (int i = 1; i < numberArray.length; i++) {
if (min > numberArray[i]) { if (min > numberArray[i]) {
min = numberArray[i]; min = numberArray[i];
} }
@ -3500,7 +3504,7 @@ public class ArrayUtil {
throw new IllegalArgumentException("Number array must not empty !"); throw new IllegalArgumentException("Number array must not empty !");
} }
T max = numberArray[0]; T max = numberArray[0];
for (int i = 0; i < numberArray.length; i++) { for (int i = 1; i < numberArray.length; i++) {
if (ObjectUtil.compare(max, numberArray[i]) < 0) { if (ObjectUtil.compare(max, numberArray[i]) < 0) {
max = numberArray[i]; max = numberArray[i];
} }
@ -3520,7 +3524,7 @@ public class ArrayUtil {
throw new IllegalArgumentException("Number array must not empty !"); throw new IllegalArgumentException("Number array must not empty !");
} }
long max = numberArray[0]; long max = numberArray[0];
for (int i = 0; i < numberArray.length; i++) { for (int i = 1; i < numberArray.length; i++) {
if (max < numberArray[i]) { if (max < numberArray[i]) {
max = numberArray[i]; max = numberArray[i];
} }
@ -3540,7 +3544,7 @@ public class ArrayUtil {
throw new IllegalArgumentException("Number array must not empty !"); throw new IllegalArgumentException("Number array must not empty !");
} }
int max = numberArray[0]; int max = numberArray[0];
for (int i = 0; i < numberArray.length; i++) { for (int i = 1; i < numberArray.length; i++) {
if (max < numberArray[i]) { if (max < numberArray[i]) {
max = numberArray[i]; max = numberArray[i];
} }
@ -3560,7 +3564,7 @@ public class ArrayUtil {
throw new IllegalArgumentException("Number array must not empty !"); throw new IllegalArgumentException("Number array must not empty !");
} }
short max = numberArray[0]; short max = numberArray[0];
for (int i = 0; i < numberArray.length; i++) { for (int i = 1; i < numberArray.length; i++) {
if (max < numberArray[i]) { if (max < numberArray[i]) {
max = numberArray[i]; max = numberArray[i];
} }
@ -3580,7 +3584,7 @@ public class ArrayUtil {
throw new IllegalArgumentException("Number array must not empty !"); throw new IllegalArgumentException("Number array must not empty !");
} }
char max = numberArray[0]; char max = numberArray[0];
for (int i = 0; i < numberArray.length; i++) { for (int i = 1; i < numberArray.length; i++) {
if (max < numberArray[i]) { if (max < numberArray[i]) {
max = numberArray[i]; max = numberArray[i];
} }
@ -3600,7 +3604,7 @@ public class ArrayUtil {
throw new IllegalArgumentException("Number array must not empty !"); throw new IllegalArgumentException("Number array must not empty !");
} }
byte max = numberArray[0]; byte max = numberArray[0];
for (int i = 0; i < numberArray.length; i++) { for (int i = 1; i < numberArray.length; i++) {
if (max < numberArray[i]) { if (max < numberArray[i]) {
max = numberArray[i]; max = numberArray[i];
} }
@ -3620,7 +3624,7 @@ public class ArrayUtil {
throw new IllegalArgumentException("Number array must not empty !"); throw new IllegalArgumentException("Number array must not empty !");
} }
double max = numberArray[0]; double max = numberArray[0];
for (int i = 0; i < numberArray.length; i++) { for (int i = 1; i < numberArray.length; i++) {
if (max < numberArray[i]) { if (max < numberArray[i]) {
max = numberArray[i]; max = numberArray[i];
} }
@ -3640,7 +3644,7 @@ public class ArrayUtil {
throw new IllegalArgumentException("Number array must not empty !"); throw new IllegalArgumentException("Number array must not empty !");
} }
float max = numberArray[0]; float max = numberArray[0];
for (int i = 0; i < numberArray.length; i++) { for (int i = 1; i < numberArray.length; i++) {
if (max < numberArray[i]) { if (max < numberArray[i]) {
max = numberArray[i]; max = numberArray[i];
} }

21
hutool-core/src/main/java/cn/hutool/core/util/IdcardUtil.java
View File

@ -10,6 +10,7 @@ import cn.hutool.core.lang.Validator;
import java.util.Date; import java.util.Date;
import java.util.HashMap; import java.util.HashMap;
import java.util.Map; import java.util.Map;
import java.util.Objects;
/** /**
* 身份证相关工具类<br> * 身份证相关工具类<br>
@ -323,10 +324,10 @@ public class IdcardUtil {
final char[] chars = mid.toCharArray(); final char[] chars = mid.toCharArray();
int iflag = 8; int iflag = 8;
for (char c : chars) { for (char c : chars) {
sum += Integer.valueOf(String.valueOf(c)) * iflag; sum += Integer.parseInt(String.valueOf(c)) * iflag;
iflag--; iflag--;
} }
return (sum % 10 == 0 ? 0 : (10 - sum % 10)) == Integer.valueOf(end); return (sum % 10 == 0 ? 0 : (10 - sum % 10)) == Integer.parseInt(end);
} }
/** /**
@ -360,7 +361,7 @@ public class IdcardUtil {
char[] chars = mid.toCharArray(); char[] chars = mid.toCharArray();
int iflag = 7; int iflag = 7;
for (char c : chars) { for (char c : chars) {
sum = sum + Integer.valueOf(String.valueOf(c)) * iflag; sum = sum + Integer.parseInt(String.valueOf(c)) * iflag;
iflag--; iflag--;
} }
if ("A".equals(end.toUpperCase())) { if ("A".equals(end.toUpperCase())) {
@ -389,13 +390,15 @@ public class IdcardUtil {
* @return 生日(yyyyMMdd) * @return 生日(yyyyMMdd)
*/ */
public static String getBirth(String idCard) { public static String getBirth(String idCard) {
Assert.notBlank(idCard, "id card must be not blank!");
final int len = idCard.length(); final int len = idCard.length();
if (len < CHINA_ID_MIN_LENGTH) { if (len < CHINA_ID_MIN_LENGTH) {
return null; return null;
} else if (len == CHINA_ID_MIN_LENGTH) { } else if (len == CHINA_ID_MIN_LENGTH) {
idCard = convert15To18(idCard); idCard = convert15To18(idCard);
} }
return idCard.substring(6, 14);
return Objects.requireNonNull(idCard).substring(6, 14);
} }
/** /**
@ -444,7 +447,7 @@ public class IdcardUtil {
} else if (len == CHINA_ID_MIN_LENGTH) { } else if (len == CHINA_ID_MIN_LENGTH) {
idCard = convert15To18(idCard); idCard = convert15To18(idCard);
} }
return Short.valueOf(idCard.substring(6, 10)); return Short.valueOf(Objects.requireNonNull(idCard).substring(6, 10));
} }
/** /**
@ -460,7 +463,7 @@ public class IdcardUtil {
} else if (len == CHINA_ID_MIN_LENGTH) { } else if (len == CHINA_ID_MIN_LENGTH) {
idCard = convert15To18(idCard); idCard = convert15To18(idCard);
} }
return Short.valueOf(idCard.substring(10, 12)); return Short.valueOf(Objects.requireNonNull(idCard).substring(10, 12));
} }
/** /**
@ -476,7 +479,7 @@ public class IdcardUtil {
} else if (len == CHINA_ID_MIN_LENGTH) { } else if (len == CHINA_ID_MIN_LENGTH) {
idCard = convert15To18(idCard); idCard = convert15To18(idCard);
} }
return Short.valueOf(idCard.substring(12, 14)); return Short.valueOf(Objects.requireNonNull(idCard).substring(12, 14));
} }
/** /**
@ -495,7 +498,7 @@ public class IdcardUtil {
if (len == CHINA_ID_MIN_LENGTH) { if (len == CHINA_ID_MIN_LENGTH) {
idCard = convert15To18(idCard); idCard = convert15To18(idCard);
} }
char sCardChar = idCard.charAt(16); char sCardChar = Objects.requireNonNull(idCard).charAt(16);
return (sCardChar % 2 != 0) ? 1 : 0; return (sCardChar % 2 != 0) ? 1 : 0;
} }
@ -586,7 +589,7 @@ public class IdcardUtil {
int iSum = 0; int iSum = 0;
if (power.length == iArr.length) { if (power.length == iArr.length) {
for (int i = 0; i < iArr.length; i++) { for (int i = 0; i < iArr.length; i++) {
iSum += Integer.valueOf(String.valueOf(iArr[i])) * power[i]; iSum += Integer.parseInt(String.valueOf(iArr[i])) * power[i];
} }
} }
return iSum; return iSum;

311
hutool-core/src/main/java/cn/hutool/core/util/NumberUtil.java
View File

@ -22,7 +22,7 @@ import java.util.Set;
* <pre> * <pre>
* new BigDecimal(0.1) * new BigDecimal(0.1)
* </pre> * </pre>
* * <p>
* 表示的不是<strong>0.1</strong>而是<strong>0.1000000000000000055511151231257827021181583404541015625</strong> * 表示的不是<strong>0.1</strong>而是<strong>0.1000000000000000055511151231257827021181583404541015625</strong>
* *
* <p> * <p>
@ -35,11 +35,12 @@ import java.util.Set;
* </ul> * </ul>
* *
* @author Looly * @author Looly
*
*/ */
public class NumberUtil { public class NumberUtil {
/** 默认除法运算精度 */ /**
* 默认除法运算精度
*/
private static final int DEFAUT_DIV_SCALE = 10; private static final int DEFAUT_DIV_SCALE = 10;
/** /**
@ -95,6 +96,7 @@ public class NumberUtil {
* @since 3.1.1 * @since 3.1.1
*/ */
public static double add(Double v1, Double v2) { public static double add(Double v1, Double v2) {
//noinspection RedundantCast
return add((Number) v1, (Number) v2).doubleValue(); return add((Number) v1, (Number) v2).doubleValue();
} }
@ -107,7 +109,7 @@ public class NumberUtil {
* @return 和 * @return 和
*/ */
public static BigDecimal add(Number v1, Number v2) { public static BigDecimal add(Number v1, Number v2) {
return add(new Number[] { v1, v2 }); return add(new Number[]{v1, v2});
} }
/** /**
@ -234,6 +236,7 @@ public class NumberUtil {
* @return 差 * @return 差
*/ */
public static double sub(Double v1, Double v2) { public static double sub(Double v1, Double v2) {
//noinspection RedundantCast
return sub((Number) v1, (Number) v2).doubleValue(); return sub((Number) v1, (Number) v2).doubleValue();
} }
@ -246,7 +249,7 @@ public class NumberUtil {
* @return 差 * @return 差
*/ */
public static BigDecimal sub(Number v1, Number v2) { public static BigDecimal sub(Number v1, Number v2) {
return sub(new Number[] { v1, v2 }); return sub(new Number[]{v1, v2});
} }
/** /**
@ -374,6 +377,7 @@ public class NumberUtil {
* @return 积 * @return 积
*/ */
public static double mul(Double v1, Double v2) { public static double mul(Double v1, Double v2) {
//noinspection RedundantCast
return mul((Number) v1, (Number) v2).doubleValue(); return mul((Number) v1, (Number) v2).doubleValue();
} }
@ -386,7 +390,7 @@ public class NumberUtil {
* @return 积 * @return 积
*/ */
public static BigDecimal mul(Number v1, Number v2) { public static BigDecimal mul(Number v1, Number v2) {
return mul(new Number[] { v1, v2 }); return mul(new Number[]{v1, v2});
} }
/** /**
@ -554,8 +558,8 @@ public class NumberUtil {
/** /**
* 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度,后面的四舍五入 * 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度,后面的四舍五入
* *
* @param v1 被除数 * @param v1 被除数
* @param v2 除数 * @param v2 除数
* @param scale 精确度，如果为负值，取绝对值 * @param scale 精确度，如果为负值，取绝对值
* @return 两个参数的商 * @return 两个参数的商
*/ */
@ -566,8 +570,8 @@ public class NumberUtil {
/** /**
* 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度,后面的四舍五入 * 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度,后面的四舍五入
* *
* @param v1 被除数 * @param v1 被除数
* @param v2 除数 * @param v2 除数
* @param scale 精确度，如果为负值，取绝对值 * @param scale 精确度，如果为负值，取绝对值
* @return 两个参数的商 * @return 两个参数的商
*/ */
@ -578,8 +582,8 @@ public class NumberUtil {
/** /**
* 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度,后面的四舍五入 * 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度,后面的四舍五入
* *
* @param v1 被除数 * @param v1 被除数
* @param v2 除数 * @param v2 除数
* @param scale 精确度，如果为负值，取绝对值 * @param scale 精确度，如果为负值，取绝对值
* @return 两个参数的商 * @return 两个参数的商
*/ */
@ -590,8 +594,8 @@ public class NumberUtil {
/** /**
* 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度,后面的四舍五入 * 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度,后面的四舍五入
* *
* @param v1 被除数 * @param v1 被除数
* @param v2 除数 * @param v2 除数
* @param scale 精确度，如果为负值，取绝对值 * @param scale 精确度，如果为负值，取绝对值
* @return 两个参数的商 * @return 两个参数的商
*/ */
@ -602,8 +606,8 @@ public class NumberUtil {
/** /**
* 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度,后面的四舍五入 * 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度,后面的四舍五入
* *
* @param v1 被除数 * @param v1 被除数
* @param v2 除数 * @param v2 除数
* @param scale 精确度，如果为负值，取绝对值 * @param scale 精确度，如果为负值，取绝对值
* @return 两个参数的商 * @return 两个参数的商
*/ */
@ -614,8 +618,8 @@ public class NumberUtil {
/** /**
* 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度,后面的四舍五入 * 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度,后面的四舍五入
* *
* @param v1 被除数 * @param v1 被除数
* @param v2 除数 * @param v2 除数
* @param scale 精确度，如果为负值，取绝对值 * @param scale 精确度，如果为负值，取绝对值
* @return 两个参数的商 * @return 两个参数的商
* @since 3.1.0 * @since 3.1.0
@ -627,8 +631,8 @@ public class NumberUtil {
/** /**
* 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度,后面的四舍五入 * 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度,后面的四舍五入
* *
* @param v1 被除数 * @param v1 被除数
* @param v2 除数 * @param v2 除数
* @param scale 精确度，如果为负值，取绝对值 * @param scale 精确度，如果为负值，取绝对值
* @return 两个参数的商 * @return 两个参数的商
*/ */
@ -639,9 +643,9 @@ public class NumberUtil {
/** /**
* 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度 * 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度
* *
* @param v1 被除数 * @param v1 被除数
* @param v2 除数 * @param v2 除数
* @param scale 精确度，如果为负值，取绝对值 * @param scale 精确度，如果为负值，取绝对值
* @param roundingMode 保留小数的模式 {@link RoundingMode} * @param roundingMode 保留小数的模式 {@link RoundingMode}
* @return 两个参数的商 * @return 两个参数的商
*/ */
@ -652,9 +656,9 @@ public class NumberUtil {
/** /**
* 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度 * 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度
* *
* @param v1 被除数 * @param v1 被除数
* @param v2 除数 * @param v2 除数
* @param scale 精确度，如果为负值，取绝对值 * @param scale 精确度，如果为负值，取绝对值
* @param roundingMode 保留小数的模式 {@link RoundingMode} * @param roundingMode 保留小数的模式 {@link RoundingMode}
* @return 两个参数的商 * @return 两个参数的商
*/ */
@ -665,9 +669,9 @@ public class NumberUtil {
/** /**
* 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度 * 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度
* *
* @param v1 被除数 * @param v1 被除数
* @param v2 除数 * @param v2 除数
* @param scale 精确度，如果为负值，取绝对值 * @param scale 精确度，如果为负值，取绝对值
* @param roundingMode 保留小数的模式 {@link RoundingMode} * @param roundingMode 保留小数的模式 {@link RoundingMode}
* @return 两个参数的商 * @return 两个参数的商
*/ */
@ -678,9 +682,9 @@ public class NumberUtil {
/** /**
* 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度 * 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度
* *
* @param v1 被除数 * @param v1 被除数
* @param v2 除数 * @param v2 除数
* @param scale 精确度，如果为负值，取绝对值 * @param scale 精确度，如果为负值，取绝对值
* @param roundingMode 保留小数的模式 {@link RoundingMode} * @param roundingMode 保留小数的模式 {@link RoundingMode}
* @return 两个参数的商 * @return 两个参数的商
*/ */
@ -691,22 +695,23 @@ public class NumberUtil {
/** /**
* 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度 * 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度
* *
* @param v1 被除数 * @param v1 被除数
* @param v2 除数 * @param v2 除数
* @param scale 精确度，如果为负值，取绝对值 * @param scale 精确度，如果为负值，取绝对值
* @param roundingMode 保留小数的模式 {@link RoundingMode} * @param roundingMode 保留小数的模式 {@link RoundingMode}
* @return 两个参数的商 * @return 两个参数的商
*/ */
public static double div(Double v1, Double v2, int scale, RoundingMode roundingMode) { public static double div(Double v1, Double v2, int scale, RoundingMode roundingMode) {
//noinspection RedundantCast
return div((Number) v1, (Number) v2, scale, roundingMode).doubleValue(); return div((Number) v1, (Number) v2, scale, roundingMode).doubleValue();
} }
/** /**
* 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度 * 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度
* *
* @param v1 被除数 * @param v1 被除数
* @param v2 除数 * @param v2 除数
* @param scale 精确度，如果为负值，取绝对值 * @param scale 精确度，如果为负值，取绝对值
* @param roundingMode 保留小数的模式 {@link RoundingMode} * @param roundingMode 保留小数的模式 {@link RoundingMode}
* @return 两个参数的商 * @return 两个参数的商
* @since 3.1.0 * @since 3.1.0
@ -718,9 +723,9 @@ public class NumberUtil {
/** /**
* 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度 * 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度
* *
* @param v1 被除数 * @param v1 被除数
* @param v2 除数 * @param v2 除数
* @param scale 精确度，如果为负值，取绝对值 * @param scale 精确度，如果为负值，取绝对值
* @param roundingMode 保留小数的模式 {@link RoundingMode} * @param roundingMode 保留小数的模式 {@link RoundingMode}
* @return 两个参数的商 * @return 两个参数的商
*/ */
@ -731,9 +736,9 @@ public class NumberUtil {
/** /**
* 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度 * 提供(相对)精确的除法运算,当发生除不尽的情况时,由scale指定精确度
* *
* @param v1 被除数 * @param v1 被除数
* @param v2 除数 * @param v2 除数
* @param scale 精确度，如果为负值，取绝对值 * @param scale 精确度，如果为负值，取绝对值
* @param roundingMode 保留小数的模式 {@link RoundingMode} * @param roundingMode 保留小数的模式 {@link RoundingMode}
* @return 两个参数的商 * @return 两个参数的商
* @since 3.0.9 * @since 3.0.9
@ -750,12 +755,13 @@ public class NumberUtil {
} }
// ------------------------------------------------------------------------------------------- round // ------------------------------------------------------------------------------------------- round
/** /**
* 保留固定位数小数<br> * 保留固定位数小数<br>
* 采用四舍五入策略 {@link RoundingMode#HALF_UP}<br> * 采用四舍五入策略 {@link RoundingMode#HALF_UP}<br>
* 例如保留2位小数：123.456789 =》 123.46 * 例如保留2位小数：123.456789 =》 123.46
* *
* @param v 值 * @param v 值
* @param scale 保留小数位数 * @param scale 保留小数位数
* @return 新值 * @return 新值
*/ */
@ -768,7 +774,7 @@ public class NumberUtil {
* 采用四舍五入策略 {@link RoundingMode#HALF_UP}<br> * 采用四舍五入策略 {@link RoundingMode#HALF_UP}<br>
* 例如保留2位小数：123.456789 =》 123.46 * 例如保留2位小数：123.456789 =》 123.46
* *
* @param v 值 * @param v 值
* @param scale 保留小数位数 * @param scale 保留小数位数
* @return 新值 * @return 新值
*/ */
@ -782,7 +788,7 @@ public class NumberUtil {
* 例如保留2位小数：123.456789 =》 123.46 * 例如保留2位小数：123.456789 =》 123.46
* *
* @param numberStr 数字值的字符串表现形式 * @param numberStr 数字值的字符串表现形式
* @param scale 保留小数位数 * @param scale 保留小数位数
* @return 新值 * @return 新值
*/ */
public static BigDecimal round(String numberStr, int scale) { public static BigDecimal round(String numberStr, int scale) {
@ -795,7 +801,7 @@ public class NumberUtil {
* 例如保留2位小数：123.456789 =》 123.46 * 例如保留2位小数：123.456789 =》 123.46
* *
* @param number 数字值 * @param number 数字值
* @param scale 保留小数位数 * @param scale 保留小数位数
* @return 新值 * @return 新值
* @since 4.1.0 * @since 4.1.0
*/ */
@ -809,7 +815,7 @@ public class NumberUtil {
* 例如保留2位小数：123.456789 =》 123.46 * 例如保留2位小数：123.456789 =》 123.46
* *
* @param numberStr 数字值的字符串表现形式 * @param numberStr 数字值的字符串表现形式
* @param scale 保留小数位数 * @param scale 保留小数位数
* @return 新值 * @return 新值
* @since 3.2.2 * @since 3.2.2
*/ */
@ -821,8 +827,8 @@ public class NumberUtil {
* 保留固定位数小数<br> * 保留固定位数小数<br>
* 例如保留四位小数：123.456789 =》 123.4567 * 例如保留四位小数：123.456789 =》 123.4567
* *
* @param v 值 * @param v 值
* @param scale 保留小数位数 * @param scale 保留小数位数
* @param roundingMode 保留小数的模式 {@link RoundingMode} * @param roundingMode 保留小数的模式 {@link RoundingMode}
* @return 新值 * @return 新值
*/ */
@ -834,8 +840,8 @@ public class NumberUtil {
* 保留固定位数小数<br> * 保留固定位数小数<br>
* 例如保留四位小数：123.456789 =》 123.4567 * 例如保留四位小数：123.456789 =》 123.4567
* *
* @param v 值 * @param v 值
* @param scale 保留小数位数 * @param scale 保留小数位数
* @param roundingMode 保留小数的模式 {@link RoundingMode} * @param roundingMode 保留小数的模式 {@link RoundingMode}
* @return 新值 * @return 新值
* @since 3.2.2 * @since 3.2.2
@ -848,8 +854,8 @@ public class NumberUtil {
* 保留固定位数小数<br> * 保留固定位数小数<br>
* 例如保留四位小数：123.456789 =》 123.4567 * 例如保留四位小数：123.456789 =》 123.4567
* *
* @param numberStr 数字值的字符串表现形式 * @param numberStr 数字值的字符串表现形式
* @param scale 保留小数位数，如果传入小于0，则默认0 * @param scale 保留小数位数，如果传入小于0，则默认0
* @param roundingMode 保留小数的模式 {@link RoundingMode}，如果传入null则默认四舍五入 * @param roundingMode 保留小数的模式 {@link RoundingMode}，如果传入null则默认四舍五入
* @return 新值 * @return 新值
*/ */
@ -865,8 +871,8 @@ public class NumberUtil {
* 保留固定位数小数<br> * 保留固定位数小数<br>
* 例如保留四位小数：123.456789 =》 123.4567 * 例如保留四位小数：123.456789 =》 123.4567
* *
* @param number 数字值 * @param number 数字值
* @param scale 保留小数位数，如果传入小于0，则默认0 * @param scale 保留小数位数，如果传入小于0，则默认0
* @param roundingMode 保留小数的模式 {@link RoundingMode}，如果传入null则默认四舍五入 * @param roundingMode 保留小数的模式 {@link RoundingMode}，如果传入null则默认四舍五入
* @return 新值 * @return 新值
*/ */
@ -888,8 +894,8 @@ public class NumberUtil {
* 保留固定位数小数<br> * 保留固定位数小数<br>
* 例如保留四位小数：123.456789 =》 123.4567 * 例如保留四位小数：123.456789 =》 123.4567
* *
* @param numberStr 数字值的字符串表现形式 * @param numberStr 数字值的字符串表现形式
* @param scale 保留小数位数 * @param scale 保留小数位数
* @param roundingMode 保留小数的模式 {@link RoundingMode} * @param roundingMode 保留小数的模式 {@link RoundingMode}
* @return 新值 * @return 新值
* @since 3.2.2 * @since 3.2.2
@ -914,7 +920,7 @@ public class NumberUtil {
* </pre> * </pre>
* *
* @param number 需要科学计算的数据 * @param number 需要科学计算的数据
* @param scale 保留的小数位 * @param scale 保留的小数位
* @return 结果 * @return 结果
* @since 4.1.0 * @since 4.1.0
*/ */
@ -950,7 +956,7 @@ public class NumberUtil {
* 保留固定小数位数，舍去多余位数 * 保留固定小数位数，舍去多余位数
* *
* @param number 需要科学计算的数据 * @param number 需要科学计算的数据
* @param scale 保留的小数位 * @param scale 保留的小数位
* @return 结果 * @return 结果
* @since 4.1.0 * @since 4.1.0
*/ */
@ -971,22 +977,23 @@ public class NumberUtil {
} }
// ------------------------------------------------------------------------------------------- decimalFormat // ------------------------------------------------------------------------------------------- decimalFormat
/** /**
* 格式化double<br> * 格式化double<br>
* 对 {@link DecimalFormat} 做封装<br> * 对 {@link DecimalFormat} 做封装<br>
* *
* @param pattern 格式 格式中主要以 # 和 0 两种占位符号来指定数字长度。0 表示如果位数不足则以 0 填充，# 表示只要有可能就把数字拉上这个位置。<br> * @param pattern 格式 格式中主要以 # 和 0 两种占位符号来指定数字长度。0 表示如果位数不足则以 0 填充，# 表示只要有可能就把数字拉上这个位置。<br>
* <ul> * <ul>
* <li>0 =》 取一位整数</li> * <li>0 =》 取一位整数</li>
* <li>0.00 =》 取一位整数和两位小数</li> * <li>0.00 =》 取一位整数和两位小数</li>
* <li>00.000 =》 取两位整数和三位小数</li> * <li>00.000 =》 取两位整数和三位小数</li>
* <li># =》 取所有整数部分</li> * <li># =》 取所有整数部分</li>
* <li>#.##% =》 以百分比方式计数，并取两位小数</li> * <li>#.##% =》 以百分比方式计数，并取两位小数</li>
* <li>#.#####E0 =》 显示为科学计数法，并取五位小数</li> * <li>#.#####E0 =》 显示为科学计数法，并取五位小数</li>
* <li>,### =》 每三位以逗号进行分隔，例如：299,792,458</li> * <li>,### =》 每三位以逗号进行分隔，例如：299,792,458</li>
* <li>光速大小为每秒,###米 =》 将格式嵌入文本</li> * <li>光速大小为每秒,###米 =》 将格式嵌入文本</li>
* </ul> * </ul>
* @param value 值 * @param value 值
* @return 格式化后的值 * @return 格式化后的值
*/ */
public static String decimalFormat(String pattern, double value) { public static String decimalFormat(String pattern, double value) {
@ -998,17 +1005,17 @@ public class NumberUtil {
* 对 {@link DecimalFormat} 做封装<br> * 对 {@link DecimalFormat} 做封装<br>
* *
* @param pattern 格式 格式中主要以 # 和 0 两种占位符号来指定数字长度。0 表示如果位数不足则以 0 填充，# 表示只要有可能就把数字拉上这个位置。<br> * @param pattern 格式 格式中主要以 # 和 0 两种占位符号来指定数字长度。0 表示如果位数不足则以 0 填充，# 表示只要有可能就把数字拉上这个位置。<br>
* <ul> * <ul>
* <li>0 =》 取一位整数</li> * <li>0 =》 取一位整数</li>
* <li>0.00 =》 取一位整数和两位小数</li> * <li>0.00 =》 取一位整数和两位小数</li>
* <li>00.000 =》 取两位整数和三位小数</li> * <li>00.000 =》 取两位整数和三位小数</li>
* <li># =》 取所有整数部分</li> * <li># =》 取所有整数部分</li>
* <li>#.##% =》 以百分比方式计数，并取两位小数</li> * <li>#.##% =》 以百分比方式计数，并取两位小数</li>
* <li>#.#####E0 =》 显示为科学计数法，并取五位小数</li> * <li>#.#####E0 =》 显示为科学计数法，并取五位小数</li>
* <li>,### =》 每三位以逗号进行分隔，例如：299,792,458</li> * <li>,### =》 每三位以逗号进行分隔，例如：299,792,458</li>
* <li>光速大小为每秒,###米 =》 将格式嵌入文本</li> * <li>光速大小为每秒,###米 =》 将格式嵌入文本</li>
* </ul> * </ul>
* @param value 值 * @param value 值
* @return 格式化后的值 * @return 格式化后的值
* @since 3.0.5 * @since 3.0.5
*/ */
@ -1031,7 +1038,7 @@ public class NumberUtil {
* 格式化百分比，小数采用四舍五入方式 * 格式化百分比，小数采用四舍五入方式
* *
* @param number 值 * @param number 值
* @param scale 保留小数位数 * @param scale 保留小数位数
* @return 百分比 * @return 百分比
* @since 3.2.3 * @since 3.2.3
*/ */
@ -1042,6 +1049,7 @@ public class NumberUtil {
} }
// ------------------------------------------------------------------------------------------- isXXX // ------------------------------------------------------------------------------------------- isXXX
/** /**
* 是否为数字，支持包括： * 是否为数字，支持包括：
* *
@ -1084,7 +1092,7 @@ public class NumberUtil {
} }
} }
sz--; // don't want to loop to the last char, check it afterwords sz--; // don't want to loop to the last char, check it afterwords
// for type qualifiers // for type qualifiers
int i = start; int i = start;
// loop to the next to last char or to the last char if we need another digit to // loop to the next to last char or to the last char if we need another digit to
// make a valid number (e.g. chars[0..5] = "1234E") // make a valid number (e.g. chars[0..5] = "1234E")
@ -1225,8 +1233,8 @@ public class NumberUtil {
* 生成不重复随机数 根据给定的最小数字和最大数字，以及随机数的个数，产生指定的不重复的数组 * 生成不重复随机数 根据给定的最小数字和最大数字，以及随机数的个数，产生指定的不重复的数组
* *
* @param begin 最小数字（包含该数） * @param begin 最小数字（包含该数）
* @param end 最大数字（不包含该数） * @param end 最大数字（不包含该数）
* @param size 指定产生随机数的个数 * @param size 指定产生随机数的个数
* @return 随机int数组 * @return 随机int数组
*/ */
public static int[] generateRandomNumber(int begin, int end, int size) { public static int[] generateRandomNumber(int begin, int end, int size) {
@ -1263,8 +1271,8 @@ public class NumberUtil {
* 生成不重复随机数 根据给定的最小数字和最大数字，以及随机数的个数，产生指定的不重复的数组 * 生成不重复随机数 根据给定的最小数字和最大数字，以及随机数的个数，产生指定的不重复的数组
* *
* @param begin 最小数字（包含该数） * @param begin 最小数字（包含该数）
* @param end 最大数字（不包含该数） * @param end 最大数字（不包含该数）
* @param size 指定产生随机数的个数 * @param size 指定产生随机数的个数
* @return 随机int数组 * @return 随机int数组
*/ */
public static Integer[] generateBySet(int begin, int end, int size) { public static Integer[] generateBySet(int begin, int end, int size) {
@ -1288,6 +1296,7 @@ public class NumberUtil {
} }
// ------------------------------------------------------------------------------------------- range // ------------------------------------------------------------------------------------------- range
/** /**
* 从0开始给定范围内的整数列表，步进为1 * 从0开始给定范围内的整数列表，步进为1
* *
@ -1303,7 +1312,7 @@ public class NumberUtil {
* 给定范围内的整数列表，步进为1 * 给定范围内的整数列表，步进为1
* *
* @param start 开始（包含） * @param start 开始（包含）
* @param stop 结束（包含） * @param stop 结束（包含）
* @return 整数列表 * @return 整数列表
*/ */
public static int[] range(int start, int stop) { public static int[] range(int start, int stop) {
@ -1314,8 +1323,8 @@ public class NumberUtil {
* 给定范围内的整数列表 * 给定范围内的整数列表
* *
* @param start 开始（包含） * @param start 开始（包含）
* @param stop 结束（包含） * @param stop 结束（包含）
* @param step 步进 * @param step 步进
* @return 整数列表 * @return 整数列表
*/ */
public static int[] range(int start, int stop, int step) { public static int[] range(int start, int stop, int step) {
@ -1324,7 +1333,7 @@ public class NumberUtil {
} else if (start > stop) { } else if (start > stop) {
step = -Math.abs(step); step = -Math.abs(step);
} else {// start == end } else {// start == end
return new int[] { start }; return new int[]{start};
} }
int size = Math.abs((stop - start) / step) + 1; int size = Math.abs((stop - start) / step) + 1;
@ -1340,8 +1349,8 @@ public class NumberUtil {
/** /**
* 将给定范围内的整数添加到已有集合中，步进为1 * 将给定范围内的整数添加到已有集合中，步进为1
* *
* @param start 开始（包含） * @param start 开始（包含）
* @param stop 结束（包含） * @param stop 结束（包含）
* @param values 集合 * @param values 集合
* @return 集合 * @return 集合
*/ */
@ -1352,9 +1361,9 @@ public class NumberUtil {
/** /**
* 将给定范围内的整数添加到已有集合中 * 将给定范围内的整数添加到已有集合中
* *
* @param start 开始（包含） * @param start 开始（包含）
* @param stop 结束（包含） * @param stop 结束（包含）
* @param step 步进 * @param step 步进
* @param values 集合 * @param values 集合
* @return 集合 * @return 集合
*/ */
@ -1375,6 +1384,7 @@ public class NumberUtil {
} }
// ------------------------------------------------------------------------------------------- others // ------------------------------------------------------------------------------------------- others
/** /**
* 计算阶乘 * 计算阶乘
* <p> * <p>
@ -1382,7 +1392,7 @@ public class NumberUtil {
* </p> * </p>
* *
* @param start 阶乘起始 * @param start 阶乘起始
* @param end 阶乘结束，必须小于起始 * @param end 阶乘结束，必须小于起始
* @return 结果 * @return 结果
* @since 4.1.0 * @since 4.1.0
*/ */
@ -1437,7 +1447,7 @@ public class NumberUtil {
* 比如大乐透35选5可以这样调用processMultiple(7,5); 就是数学中的：C75=7*6/2*1 * 比如大乐透35选5可以这样调用processMultiple(7,5); 就是数学中的：C75=7*6/2*1
* *
* @param selectNum 选中小球个数 * @param selectNum 选中小球个数
* @param minNum 最少要选中多少个小球 * @param minNum 最少要选中多少个小球
* @return 注数 * @return 注数
*/ */
public static int processMultiple(int selectNum, int minNum) { public static int processMultiple(int selectNum, int minNum) {
@ -1514,11 +1524,10 @@ public class NumberUtil {
/** /**
* 比较两个值的大小 * 比较两个值的大小
* *
* @see Character#compare(char, char)
*
* @param x 第一个值 * @param x 第一个值
* @param y 第二个值 * @param y 第二个值
* @return x==y返回0，x&lt;y返回-1，x&gt;y返回1 * @return x==y返回0，x&lt;y返回-1，x&gt;y返回1
* @see Character#compare(char, char)
* @since 3.0.1 * @since 3.0.1
*/ */
public static int compare(char x, char y) { public static int compare(char x, char y) {
@ -1528,11 +1537,10 @@ public class NumberUtil {
/** /**
* 比较两个值的大小 * 比较两个值的大小
* *
* @see Double#compare(double, double)
*
* @param x 第一个值 * @param x 第一个值
* @param y 第二个值 * @param y 第二个值
* @return x==y返回0，x&lt;y返回-1，x&gt;y返回1 * @return x==y返回0，x&lt;y返回-1，x&gt;y返回1
* @see Double#compare(double, double)
* @since 3.0.1 * @since 3.0.1
*/ */
public static int compare(double x, double y) { public static int compare(double x, double y) {
@ -1542,11 +1550,10 @@ public class NumberUtil {
/** /**
* 比较两个值的大小 * 比较两个值的大小
* *
* @see Integer#compare(int, int)
*
* @param x 第一个值 * @param x 第一个值
* @param y 第二个值 * @param y 第二个值
* @return x==y返回0，x&lt;y返回-1，x&gt;y返回1 * @return x==y返回0，x&lt;y返回-1，x&gt;y返回1
* @see Integer#compare(int, int)
* @since 3.0.1 * @since 3.0.1
*/ */
public static int compare(int x, int y) { public static int compare(int x, int y) {
@ -1556,11 +1563,10 @@ public class NumberUtil {
/** /**
* 比较两个值的大小 * 比较两个值的大小
* *
* @see Long#compare(long, long)
*
* @param x 第一个值 * @param x 第一个值
* @param y 第二个值 * @param y 第二个值
* @return x==y返回0，x&lt;y返回-1，x&gt;y返回1 * @return x==y返回0，x&lt;y返回-1，x&gt;y返回1
* @see Long#compare(long, long)
* @since 3.0.1 * @since 3.0.1
*/ */
public static int compare(long x, long y) { public static int compare(long x, long y) {
@ -1570,11 +1576,10 @@ public class NumberUtil {
/** /**
* 比较两个值的大小 * 比较两个值的大小
* *
* @see Short#compare(short, short)
*
* @param x 第一个值 * @param x 第一个值
* @param y 第二个值 * @param y 第二个值
* @return x==y返回0，x&lt;y返回-1，x&gt;y返回1 * @return x==y返回0，x&lt;y返回-1，x&gt;y返回1
* @see Short#compare(short, short)
* @since 3.0.1 * @since 3.0.1
*/ */
public static int compare(short x, short y) { public static int compare(short x, short y) {
@ -1584,11 +1589,10 @@ public class NumberUtil {
/** /**
* 比较两个值的大小 * 比较两个值的大小
* *
* @see Byte#compare(byte, byte)
*
* @param x 第一个值 * @param x 第一个值
* @param y 第二个值 * @param y 第二个值
* @return x==y返回0，x&lt;y返回-1，x&gt;y返回1 * @return x==y返回0，x&lt;y返回-1，x&gt;y返回1
* @see Byte#compare(byte, byte)
* @since 3.0.1 * @since 3.0.1
*/ */
public static int compare(byte x, byte y) { public static int compare(byte x, byte y) {
@ -1601,7 +1605,7 @@ public class NumberUtil {
* @param bigNum1 数字1 * @param bigNum1 数字1
* @param bigNum2 数字2 * @param bigNum2 数字2
* @return 是否大于 * @return 是否大于
* @since 3,0.9 * @since 3, 0.9
*/ */
public static boolean isGreater(BigDecimal bigNum1, BigDecimal bigNum2) { public static boolean isGreater(BigDecimal bigNum1, BigDecimal bigNum2) {
Assert.notNull(bigNum1); Assert.notNull(bigNum1);
@ -1615,7 +1619,7 @@ public class NumberUtil {
* @param bigNum1 数字1 * @param bigNum1 数字1
* @param bigNum2 数字2 * @param bigNum2 数字2
* @return 是否大于等于 * @return 是否大于等于
* @since 3,0.9 * @since 3, 0.9
*/ */
public static boolean isGreaterOrEqual(BigDecimal bigNum1, BigDecimal bigNum2) { public static boolean isGreaterOrEqual(BigDecimal bigNum1, BigDecimal bigNum2) {
Assert.notNull(bigNum1); Assert.notNull(bigNum1);
@ -1629,7 +1633,7 @@ public class NumberUtil {
* @param bigNum1 数字1 * @param bigNum1 数字1
* @param bigNum2 数字2 * @param bigNum2 数字2
* @return 是否小于 * @return 是否小于
* @since 3,0.9 * @since 3, 0.9
*/ */
public static boolean isLess(BigDecimal bigNum1, BigDecimal bigNum2) { public static boolean isLess(BigDecimal bigNum1, BigDecimal bigNum2) {
Assert.notNull(bigNum1); Assert.notNull(bigNum1);
@ -1643,7 +1647,7 @@ public class NumberUtil {
* @param bigNum1 数字1 * @param bigNum1 数字1
* @param bigNum2 数字2 * @param bigNum2 数字2
* @return 是否小于等于 * @return 是否小于等于
* @since 3,0.9 * @since 3, 0.9
*/ */
public static boolean isLessOrEqual(BigDecimal bigNum1, BigDecimal bigNum2) { public static boolean isLessOrEqual(BigDecimal bigNum1, BigDecimal bigNum2) {
Assert.notNull(bigNum1); Assert.notNull(bigNum1);
@ -1669,12 +1673,12 @@ public class NumberUtil {
/** /**
* 比较两个字符是否相同 * 比较两个字符是否相同
* *
* @param c1 字符1 * @param c1 字符1
* @param c2 字符2 * @param c2 字符2
* @param ignoreCase 是否忽略大小写 * @param ignoreCase 是否忽略大小写
* @return 是否相同 * @return 是否相同
* @since 3.2.1
* @see CharUtil#equals(char, char, boolean) * @see CharUtil#equals(char, char, boolean)
* @since 3.2.1
*/ */
public static boolean equals(char c1, char c2, boolean ignoreCase) { public static boolean equals(char c1, char c2, boolean ignoreCase) {
return CharUtil.equals(c1, c2, ignoreCase); return CharUtil.equals(c1, c2, ignoreCase);
@ -1683,14 +1687,13 @@ public class NumberUtil {
/** /**
* 取最小值 * 取最小值
* *
* @param <T> 元素类型 * @param <T> 元素类型
* @param numberArray 数字数组 * @param numberArray 数字数组
* @return 最小值 * @return 最小值
* @since 4.0.7
* @see ArrayUtil#min(Comparable[]) * @see ArrayUtil#min(Comparable[])
* @since 4.0.7
*/ */
@SuppressWarnings("unchecked") public static <T extends Comparable<? super T>> T min(T[] numberArray) {
public static <T extends Comparable<? super T>> T min(T... numberArray) {
return ArrayUtil.min(numberArray); return ArrayUtil.min(numberArray);
} }
@ -1699,8 +1702,8 @@ public class NumberUtil {
* *
* @param numberArray 数字数组 * @param numberArray 数字数组
* @return 最小值 * @return 最小值
* @since 4.0.7
* @see ArrayUtil#min(long...) * @see ArrayUtil#min(long...)
* @since 4.0.7
*/ */
public static long min(long... numberArray) { public static long min(long... numberArray) {
return ArrayUtil.min(numberArray); return ArrayUtil.min(numberArray);
@ -1711,8 +1714,8 @@ public class NumberUtil {
* *
* @param numberArray 数字数组 * @param numberArray 数字数组
* @return 最小值 * @return 最小值
* @since 4.0.7
* @see ArrayUtil#min(int...) * @see ArrayUtil#min(int...)
* @since 4.0.7
*/ */
public static int min(int... numberArray) { public static int min(int... numberArray) {
return ArrayUtil.min(numberArray); return ArrayUtil.min(numberArray);
@ -1723,8 +1726,8 @@ public class NumberUtil {
* *
* @param numberArray 数字数组 * @param numberArray 数字数组
* @return 最小值 * @return 最小值
* @since 4.0.7
* @see ArrayUtil#min(short...) * @see ArrayUtil#min(short...)
* @since 4.0.7
*/ */
public static short min(short... numberArray) { public static short min(short... numberArray) {
return ArrayUtil.min(numberArray); return ArrayUtil.min(numberArray);
@ -1735,8 +1738,8 @@ public class NumberUtil {
* *
* @param numberArray 数字数组 * @param numberArray 数字数组
* @return 最小值 * @return 最小值
* @since 4.0.7
* @see ArrayUtil#min(double...) * @see ArrayUtil#min(double...)
* @since 4.0.7
*/ */
public static double min(double... numberArray) { public static double min(double... numberArray) {
return ArrayUtil.min(numberArray); return ArrayUtil.min(numberArray);
@ -1747,8 +1750,8 @@ public class NumberUtil {
* *
* @param numberArray 数字数组 * @param numberArray 数字数组
* @return 最小值 * @return 最小值
* @since 4.0.7
* @see ArrayUtil#min(float...) * @see ArrayUtil#min(float...)
* @since 4.0.7
*/ */
public static float min(float... numberArray) { public static float min(float... numberArray) {
return ArrayUtil.min(numberArray); return ArrayUtil.min(numberArray);
@ -1757,14 +1760,13 @@ public class NumberUtil {
/** /**
* 取最大值 * 取最大值
* *
* @param <T> 元素类型 * @param <T> 元素类型
* @param numberArray 数字数组 * @param numberArray 数字数组
* @return 最大值 * @return 最大值
* @since 4.0.7
* @see ArrayUtil#max(Comparable[]) * @see ArrayUtil#max(Comparable[])
* @since 4.0.7
*/ */
@SuppressWarnings("unchecked") public static <T extends Comparable<? super T>> T max(T[] numberArray) {
public static <T extends Comparable<? super T>> T max(T... numberArray) {
return ArrayUtil.max(numberArray); return ArrayUtil.max(numberArray);
} }
@ -1773,8 +1775,8 @@ public class NumberUtil {
* *
* @param numberArray 数字数组 * @param numberArray 数字数组
* @return 最大值 * @return 最大值
* @since 4.0.7
* @see ArrayUtil#max(long...) * @see ArrayUtil#max(long...)
* @since 4.0.7
*/ */
public static long max(long... numberArray) { public static long max(long... numberArray) {
return ArrayUtil.max(numberArray); return ArrayUtil.max(numberArray);
@ -1785,8 +1787,8 @@ public class NumberUtil {
* *
* @param numberArray 数字数组 * @param numberArray 数字数组
* @return 最大值 * @return 最大值
* @since 4.0.7
* @see ArrayUtil#max(int...) * @see ArrayUtil#max(int...)
* @since 4.0.7
*/ */
public static int max(int... numberArray) { public static int max(int... numberArray) {
return ArrayUtil.max(numberArray); return ArrayUtil.max(numberArray);
@ -1797,8 +1799,8 @@ public class NumberUtil {
* *
* @param numberArray 数字数组 * @param numberArray 数字数组
* @return 最大值 * @return 最大值
* @since 4.0.7
* @see ArrayUtil#max(short...) * @see ArrayUtil#max(short...)
* @since 4.0.7
*/ */
public static short max(short... numberArray) { public static short max(short... numberArray) {
return ArrayUtil.max(numberArray); return ArrayUtil.max(numberArray);
@ -1809,8 +1811,8 @@ public class NumberUtil {
* *
* @param numberArray 数字数组 * @param numberArray 数字数组
* @return 最大值 * @return 最大值
* @since 4.0.7
* @see ArrayUtil#max(double...) * @see ArrayUtil#max(double...)
* @since 4.0.7
*/ */
public static double max(double... numberArray) { public static double max(double... numberArray) {
return ArrayUtil.max(numberArray); return ArrayUtil.max(numberArray);
@ -1821,8 +1823,8 @@ public class NumberUtil {
* *
* @param numberArray 数字数组 * @param numberArray 数字数组
* @return 最大值 * @return 最大值
* @since 4.0.7
* @see ArrayUtil#max(float...) * @see ArrayUtil#max(float...)
* @since 4.0.7
*/ */
public static float max(float... numberArray) { public static float max(float... numberArray) {
return ArrayUtil.max(numberArray); return ArrayUtil.max(numberArray);
@ -1832,7 +1834,7 @@ public class NumberUtil {
* 数字转字符串<br> * 数字转字符串<br>
* 调用{@link Number#toString()}，并去除尾小数点儿后多余的0 * 调用{@link Number#toString()}，并去除尾小数点儿后多余的0
* *
* @param number A Number * @param number A Number
* @param defaultValue 如果number参数为{@code null}，返回此默认值 * @param defaultValue 如果number参数为{@code null}，返回此默认值
* @return A String. * @return A String.
* @since 3.0.9 * @since 3.0.9
@ -1915,10 +1917,10 @@ public class NumberUtil {
* 是否空白符<br> * 是否空白符<br>
* 空白符包括空格、制表符、全角空格和不间断空格<br> * 空白符包括空格、制表符、全角空格和不间断空格<br>
* *
* @see Character#isWhitespace(int)
* @see Character#isSpaceChar(int)
* @param c 字符 * @param c 字符
* @return 是否空白符 * @return 是否空白符
* @see Character#isWhitespace(int)
* @see Character#isSpaceChar(int)
* @since 3.0.6 * @since 3.0.6
* @deprecated 请使用{@link CharUtil#isBlankChar(int)} * @deprecated 请使用{@link CharUtil#isBlankChar(int)}
*/ */
@ -1931,7 +1933,7 @@ public class NumberUtil {
* 计算等份个数 * 计算等份个数
* *
* @param total 总数 * @param total 总数
* @param part 每份的个数 * @param part 每份的个数
* @return 分成了几份 * @return 分成了几份
* @since 3.0.6 * @since 3.0.6
*/ */
@ -2034,7 +2036,7 @@ public class NumberUtil {
* 把给定的总数平均分成N份，返回每份的个数<br> * 把给定的总数平均分成N份，返回每份的个数<br>
* 当除以分数有余数时每份+1 * 当除以分数有余数时每份+1
* *
* @param total 总数 * @param total 总数
* @param partCount 份数 * @param partCount 份数
* @return 每份的个数 * @return 每份的个数
* @since 4.0.7 * @since 4.0.7
@ -2047,21 +2049,16 @@ public class NumberUtil {
* 把给定的总数平均分成N份，返回每份的个数<br> * 把给定的总数平均分成N份，返回每份的个数<br>
* 如果isPlusOneWhenHasRem为true，则当除以分数有余数时每份+1，否则丢弃余数部分 * 如果isPlusOneWhenHasRem为true，则当除以分数有余数时每份+1，否则丢弃余数部分
* *
* @param total 总数 * @param total 总数
* @param partCount 份数 * @param partCount 份数
* @param isPlusOneWhenHasRem 在有余数时是否每份+1 * @param isPlusOneWhenHasRem 在有余数时是否每份+1
* @return 每份的个数 * @return 每份的个数
* @since 4.0.7 * @since 4.0.7
*/ */
public static int partValue(int total, int partCount, boolean isPlusOneWhenHasRem) { public static int partValue(int total, int partCount, boolean isPlusOneWhenHasRem) {
int partValue; int partValue = total / partCount;
if (total % partCount == 0) { if (isPlusOneWhenHasRem && total % partCount == 0) {
partValue = total / partCount; partValue++;
} else {
partValue = (int) Math.floor(total / partCount);
if (isPlusOneWhenHasRem) {
partValue += 1;
}
} }
return partValue; return partValue;
} }
@ -2070,7 +2067,7 @@ public class NumberUtil {
* 提供精确的幂运算 * 提供精确的幂运算
* *
* @param number 底数 * @param number 底数
* @param n 指数 * @param n 指数
* @return 幂的积 * @return 幂的积
* @since 4.1.0 * @since 4.1.0
*/ */
@ -2082,7 +2079,7 @@ public class NumberUtil {
* 提供精确的幂运算 * 提供精确的幂运算
* *
* @param number 底数 * @param number 底数
* @param n 指数 * @param n 指数
* @return 幂的积 * @return 幂的积
* @since 4.1.0 * @since 4.1.0
*/ */
@ -2233,7 +2230,7 @@ public class NumberUtil {
* 以无符号字节数组的形式返回传入值。 * 以无符号字节数组的形式返回传入值。
* *
* @param length bytes长度 * @param length bytes长度
* @param value 需要转换的值 * @param value 需要转换的值
* @return 无符号bytes * @return 无符号bytes
* @since 4.5.0 * @since 4.5.0
*/ */
@ -2269,8 +2266,8 @@ public class NumberUtil {
/** /**
* 无符号bytes转{@link BigInteger} * 无符号bytes转{@link BigInteger}
* *
* @param buf 无符号bytes * @param buf 无符号bytes
* @param off 起始位置 * @param off 起始位置
* @param length 长度 * @param length 长度
* @return {@link BigInteger} * @return {@link BigInteger}
*/ */

2
hutool-core/src/main/java/cn/hutool/core/util/ObjectUtil.java
View File

@ -184,6 +184,7 @@ public class ObjectUtil {
* @return 是否为null * @return 是否为null
*/ */
public static boolean isNull(Object obj) { public static boolean isNull(Object obj) {
//noinspection ConstantConditions
return null == obj || obj.equals(null); return null == obj || obj.equals(null);
} }
@ -194,6 +195,7 @@ public class ObjectUtil {
* @return 是否为null * @return 是否为null
*/ */
public static boolean isNotNull(Object obj) { public static boolean isNotNull(Object obj) {
//noinspection ConstantConditions
return null != obj && false == obj.equals(null); return null != obj && false == obj.equals(null);
} }

4
hutool-core/src/test/java/cn/hutool/core/util/NumberUtilTest.java
View File

@ -191,13 +191,13 @@ public class NumberUtilTest {
@Test @Test
public void maxTest() { public void maxTest() {
int max = NumberUtil.max(new int[]{5,4,3,6,1}); int max = NumberUtil.max(5,4,3,6,1);
Assert.assertEquals(6, max); Assert.assertEquals(6, max);
} }
@Test @Test
public void minTest() { public void minTest() {
int min = NumberUtil.min(new int[]{5,4,3,6,1}); int min = NumberUtil.min(5,4,3,6,1);
Assert.assertEquals(1, min); Assert.assertEquals(1, min);
} }

9
hutool-extra/src/main/java/cn/hutool/extra/ftp/AbstractFtp.java
View File

@ -133,13 +133,14 @@ public abstract class AbstractFtp implements Closeable {
} }
/** /**
* 将本地文件上传到目标服务器，目标文件名为destPath，若destPath为目录，则目标文件名将与srcFilePath文件名相同。覆盖模式 * 将本地文件上传到目标服务器，目标文件名为destPath，若destPath为目录，则目标文件名将与file文件名相同。
* 覆盖模式
* *
* @param srcFilePath 本地文件路径 * @param destPath 服务端路径，可以为{@code null} 或者相对路径或绝对路径
* @param destFile 目标文件 * @param file 需要上传的文件
* @return 是否成功 * @return 是否成功
*/ */
public abstract boolean upload(String srcFilePath, File destFile); public abstract boolean upload(String destPath, File file);
/** /**
* 下载文件 * 下载文件

6
hutool-extra/src/main/java/cn/hutool/extra/ftp/Ftp.java
View File

@ -364,14 +364,14 @@ public class Ftp extends AbstractFtp {
* 3. path为绝对路径则上传到此路径 * 3. path为绝对路径则上传到此路径
* </pre> * </pre>
* *
* @param path 服务端路径，可以为{@code null} 或者相对路径或绝对路径 * @param destPath 服务端路径，可以为{@code null} 或者相对路径或绝对路径
* @param file 文件 * @param file 文件
* @return 是否上传成功 * @return 是否上传成功
*/ */
@Override @Override
public boolean upload(String path, File file) { public boolean upload(String destPath, File file) {
Assert.notNull(file, "file to upload is null !"); Assert.notNull(file, "file to upload is null !");
return upload(path, file.getName(), file); return upload(destPath, file.getName(), file);
} }
/** /**

5
hutool-extra/src/main/java/cn/hutool/extra/ssh/JschUtil.java
View File

@ -238,9 +238,6 @@ public class JschUtil {
*/ */
public static int openAndBindPortToLocal(Connector sshConn, String remoteHost, int remotePort) throws JschRuntimeException { public static int openAndBindPortToLocal(Connector sshConn, String remoteHost, int remotePort) throws JschRuntimeException {
final Session session = openSession(sshConn.getHost(), sshConn.getPort(), sshConn.getUser(), sshConn.getPassword()); final Session session = openSession(sshConn.getHost(), sshConn.getPort(), sshConn.getUser(), sshConn.getPassword());
if (session == null) {
throw new JschRuntimeException("Error to create SSH Session！");
}
final int localPort = generateLocalPort(); final int localPort = generateLocalPort();
bindPort(session, remoteHost, remotePort, localPort); bindPort(session, remoteHost, remotePort, localPort);
return localPort; return localPort;
@ -359,7 +356,7 @@ public class JschUtil {
if (null == charset) { if (null == charset) {
charset = CharsetUtil.CHARSET_UTF_8; charset = CharsetUtil.CHARSET_UTF_8;
} }
ChannelExec channel = (ChannelExec) openChannel(session, ChannelType.EXEC); final ChannelExec channel = (ChannelExec) openChannel(session, ChannelType.EXEC);
channel.setCommand(StrUtil.bytes(cmd, charset)); channel.setCommand(StrUtil.bytes(cmd, charset));
channel.setInputStream(null); channel.setInputStream(null);
channel.setErrStream(errStream); channel.setErrStream(errStream);

24
hutool-extra/src/main/java/cn/hutool/extra/ssh/Sftp.java
View File

@ -1,12 +1,9 @@
package cn.hutool.extra.ssh; package cn.hutool.extra.ssh;
import java.io.File; import cn.hutool.core.io.FileUtil;
import java.io.IOException; import cn.hutool.core.lang.Filter;
import java.nio.charset.Charset; import cn.hutool.core.util.StrUtil;
import java.util.ArrayList; import cn.hutool.extra.ftp.AbstractFtp;
import java.util.List;
import java.util.Vector;
import com.jcraft.jsch.ChannelSftp; import com.jcraft.jsch.ChannelSftp;
import com.jcraft.jsch.ChannelSftp.LsEntry; import com.jcraft.jsch.ChannelSftp.LsEntry;
import com.jcraft.jsch.ChannelSftp.LsEntrySelector; import com.jcraft.jsch.ChannelSftp.LsEntrySelector;
@ -14,10 +11,11 @@ import com.jcraft.jsch.Session;
import com.jcraft.jsch.SftpException; import com.jcraft.jsch.SftpException;
import com.jcraft.jsch.SftpProgressMonitor; import com.jcraft.jsch.SftpProgressMonitor;
import cn.hutool.core.io.FileUtil; import java.io.File;
import cn.hutool.core.lang.Filter; import java.nio.charset.Charset;
import cn.hutool.core.util.StrUtil; import java.util.ArrayList;
import cn.hutool.extra.ftp.AbstractFtp; import java.util.List;
import java.util.Vector;
/** /**
* SFTP是Secure File Transfer Protocol的缩写，安全文件传送协议。可以为传输文件提供一种安全的加密方法。<br> * SFTP是Secure File Transfer Protocol的缩写，安全文件传送协议。可以为传输文件提供一种安全的加密方法。<br>
@ -336,8 +334,8 @@ public class Sftp extends AbstractFtp {
} }
@Override @Override
public boolean upload(String srcFilePath, File destFile) { public boolean upload(String destPath, File file) {
put(srcFilePath, FileUtil.getAbsolutePath(destFile)); put(FileUtil.getAbsolutePath(file), destPath);
return true; return true;
} }

4
hutool-system/src/main/java/cn/hutool/system/RuntimeInfo.java
View File

@ -23,8 +23,8 @@ public class RuntimeInfo implements Serializable{
} }
/** /**
* 获得JVM最大可用内存 * 获得JVM最大内存
* @return 最大可用内存 * @return 最大内存
*/ */
public final long getMaxMemory(){ public final long getMaxMemory(){
return currentRuntime.maxMemory(); return currentRuntime.maxMemory();