package kernel.util;
|
|
import java.io.ByteArrayInputStream;
|
import java.io.ByteArrayOutputStream;
|
import java.io.DataInputStream;
|
import java.io.DataOutputStream;
|
import java.math.BigDecimal;
|
import java.math.BigInteger;
|
import java.util.regex.Matcher;
|
import java.util.regex.Pattern;
|
|
import org.springframework.util.Assert;
|
|
/**
|
* 提供高精度的运算支持.
|
* 所以函数以double为参数类型，兼容int与float.
|
*
|
*/
|
public abstract class NumberUtils extends org.springframework.util.NumberUtils {
|
/**
|
* 精确的加法运算.
|
*/
|
public static double add(double v1, double v2) {
|
BigDecimal b1 = new BigDecimal(v1);
|
BigDecimal b2 = new BigDecimal(v2);
|
return b1.add(b2).doubleValue();
|
}
|
|
/**
|
*
|
* 精确的减法运算.
|
*
|
* @param v1 被减数
|
* @param v2 减数
|
*/
|
public static double subtract(double v1, double v2) {
|
BigDecimal b1 = new BigDecimal(Double.toString(v1));
|
BigDecimal b2 = new BigDecimal(Double.toString(v2));
|
return b1.subtract(b2).doubleValue();
|
}
|
|
/**
|
* 提供精确的乘法运算.
|
*/
|
public static double multiply(double v1, double v2) {
|
BigDecimal b1 = new BigDecimal(v1);
|
BigDecimal b2 = new BigDecimal(v2);
|
return b1.multiply(b2).doubleValue();
|
}
|
|
/**
|
* 提供精确的乘法运算，并对运算结果截位.
|
*
|
* @param scale 运算结果小数后精确的位数
|
*/
|
public static double multiply(double v1, double v2, int scale) {
|
if (scale < 0) {
|
throw new IllegalArgumentException("The scale must be a positive integer or zero");
|
}
|
BigDecimal b1 = new BigDecimal(v1);
|
BigDecimal b2 = new BigDecimal(v2);
|
return b1.multiply(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).doubleValue();
|
}
|
|
/**
|
* 提供（相对）精确的除法运算.
|
*
|
* @see #divide(double, double, int)
|
*/
|
public static double divide(double v1, double v2) {
|
BigDecimal b1 = new BigDecimal(v1);
|
BigDecimal b2 = new BigDecimal(v2);
|
return b1.divide(b2).doubleValue();
|
}
|
|
/**
|
* 提供（相对）精确的除法运算.
|
* 由scale参数指定精度，以后的数字四舍五入.
|
*
|
* @param v1 被除数
|
* @param v2 除数
|
* @param scale 表示表示需要精确到小数点以后几位
|
*/
|
public static double divide(double v1, double v2, int scale) {
|
if (scale < 0) {
|
throw new IllegalArgumentException("The scale must be a positive integer or zero");
|
}
|
|
BigDecimal b1 = new BigDecimal(v1);
|
BigDecimal b2 = new BigDecimal(v2);
|
return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
|
}
|
|
/**
|
* 提供精确的小数位四舍五入处理.
|
*
|
* @param v 需要四舍五入的数字
|
* @param scale 小数点后保留几位
|
*/
|
public static double round(double v, int scale) {
|
if (scale < 0) {
|
throw new IllegalArgumentException("The scale must be a positive integer or zero");
|
}
|
BigDecimal b = new BigDecimal(v);
|
return b.setScale(scale, BigDecimal.ROUND_HALF_UP).doubleValue();
|
}
|
|
public static int compare(Number left, Number right) throws IllegalArgumentException {
|
Assert.notNull(left, "left number must not be null");
|
Assert.notNull(right, "right number must not be null");
|
|
if (left.getClass().equals(Byte.class)) {
|
return ((Byte) left).compareTo((Byte) right);
|
}
|
else if (left.getClass().equals(Short.class)) {
|
return ((Short) left).compareTo((Short) right);
|
}
|
else if (left.getClass().equals(Integer.class)) {
|
return ((Integer) left).compareTo((Integer) right);
|
}
|
else if (left.getClass().equals(Long.class)) {
|
return ((Long) left).compareTo((Long) right);
|
}
|
else if (left.getClass().equals(BigInteger.class)) {
|
return ((BigInteger) left).compareTo((BigInteger) right);
|
}
|
else if (left.getClass().equals(Float.class)) {
|
return ((Float) left).compareTo((Float) right);
|
}
|
else if (left.getClass().equals(Double.class)) {
|
return ((Double) left).compareTo((Double) right);
|
}
|
else if (left.getClass().equals(BigDecimal.class)) {
|
return ((BigDecimal) left).compareTo((BigDecimal) right);
|
}
|
else {
|
throw new IllegalArgumentException("Could not compare left number [" + left + "] of type ["
|
+ left.getClass().getName() + "] to right number [" + right + "] of type ["
|
+ right.getClass().getName() + "]");
|
}
|
}
|
|
public static int safeLongToInt(long l) {
|
if (l < Integer.MIN_VALUE || l > Integer.MAX_VALUE) {
|
throw new IllegalArgumentException(l + " cannot be cast to int without changing its value.");
|
}
|
return (int) l;
|
}
|
|
/**
|
* �����ָ�ʽ��Ϊ��Ǯ��ʽ
|
*
|
* @param number
|
* ���ʽ����BigDecimal
|
* @return С����2λ��ʽ���ַ�
|
*/
|
public static String formatNumericFee(BigDecimal number) {
|
return number.setScale(2, BigDecimal.ROUND_HALF_UP).toString();
|
}
|
|
/**
|
* �����ָ�ʽ��Ϊ����ʽ
|
*
|
* @param number
|
* ���ʽ����BigDecimal
|
* @return С����6λ��ʽ���ַ�
|
*/
|
public static String formatNumericTraffic(BigDecimal number) {
|
return number.setScale(6, BigDecimal.ROUND_HALF_UP).toString();
|
}
|
|
// ���һ��ת����������bigdecimalת��ΪTB��GB��MB����ʽ
|
public static String mbToTGM(BigDecimal mb) {
|
StringBuffer sb = new StringBuffer(200);
|
int g = 0;
|
int t = 0;
|
BigDecimal m = new BigDecimal(0);
|
|
t = new Float(mb.divide(new BigDecimal(1024 * 1024), BigDecimal.ROUND_DOWN).floatValue()).intValue();
|
mb = mb.subtract((new BigDecimal(t).multiply(new BigDecimal(1024 * 1024))));
|
g = new Float(mb.divide(new BigDecimal(1024), BigDecimal.ROUND_DOWN).floatValue()).intValue();
|
mb = mb.subtract((new BigDecimal(g).multiply(new BigDecimal(1024))));
|
m = mb.setScale(2, BigDecimal.ROUND_HALF_UP);
|
|
sb.append(new Integer(t).toString()).append(" TB ");
|
|
sb.append(new Integer(g).toString()).append(" GB ");
|
|
sb.append(m.toString()).append(" MB ");
|
|
return sb.toString();
|
}
|
|
// ��value��ǰ4���ֽڶs����һ�������
|
public static Integer readInt(byte[] value) {
|
if (value == null || value.length < 4) {
|
return null;
|
}
|
try {
|
ByteArrayInputStream bais = new ByteArrayInputStream(value);
|
DataInputStream dis = new DataInputStream(bais);
|
Integer retval = dis.readInt();
|
bais.close();
|
dis.close();
|
return retval;
|
} catch (Exception e) {
|
return null;
|
}
|
}
|
|
// ��value��ǰ}���ֽڶs����һ�������
|
public static Short readShort(byte[] value) {
|
if (value == null || value.length < 2) {
|
return null;
|
}
|
try {
|
ByteArrayInputStream bais = new ByteArrayInputStream(value);
|
DataInputStream dis = new DataInputStream(bais);
|
Short retval = dis.readShort();
|
bais.close();
|
dis.close();
|
return retval;
|
} catch (Exception e) {
|
return null;
|
}
|
}
|
|
public static byte[] intToByteArray(Integer value) {
|
if (value == null) {
|
return null;
|
}
|
|
try {
|
byte[] data = null;
|
ByteArrayOutputStream bais = new ByteArrayOutputStream(4);
|
DataOutputStream dos = new DataOutputStream(bais);
|
dos.writeInt(value);
|
data = bais.toByteArray();
|
bais.close();
|
dos.close();
|
return data;
|
} catch (Exception e) {
|
return null;
|
}
|
}
|
|
public static byte[] longToByteArray(long value) {
|
try {
|
byte[] data = null;
|
ByteArrayOutputStream bais = new ByteArrayOutputStream(8);
|
DataOutputStream dos = new DataOutputStream(bais);
|
dos.writeLong(value);
|
data = bais.toByteArray();
|
bais.close();
|
dos.close();
|
return data;
|
} catch (Exception e) {
|
return null;
|
}
|
}
|
|
public static Long readUnsingedInt(byte[] data, int offset) {
|
try {
|
DataInputStream dis = new DataInputStream(new ByteArrayInputStream(data));
|
dis.skip(offset);
|
Long retval = null;
|
int tmp = dis.readInt();
|
if (tmp < 0) {
|
retval = tmp + 4294967296L;
|
}
|
else {
|
retval = Long.valueOf(tmp);
|
}
|
|
dis.close();
|
return retval;
|
} catch (Exception e) {
|
return null;
|
}
|
}
|
|
public static boolean isNumeric(String str) {
|
Pattern pattern = Pattern.compile("[0-9]*");
|
Matcher isNum = pattern.matcher(str);
|
if (!isNum.matches()) {
|
return false;
|
}
|
return true;
|
}
|
}
|
