java 数字工具类_java常用工具类 数字工具类

package com.jarvis.base.util;

import java.math.BigDecimal;

import java.text.DecimalFormat;

import java.text.NumberFormat;

import java.util.Random;

public class NumericHelper {

/**

* 描述：通过一个整数i获取你所要的哪几个(从0开始) i为 多个2的n次方之和，如i=7，那么根据原值是2的n次方之各，你的原值必定是1，2，4 。

*

* @param i

* 数值

* @return

*/

public static int[] getWhich(long i) {

int exp = Math.getExponent(i);

if (i == (1 << (exp + 1)) - 1) {

exp = exp + 1;

}

int[] num = new int[exp];

int x = exp - 1;

for (int n = 0; (1 << n) < i + 1; n++) {

if ((1 << (n + 1)) > i && (1 << n) < (i + 1)) {

num[x] = n;

i -= 1 << n;

n = 0;

x--;

}

}

return num;

}

/**

* 描述：非四舍五入取整处理

*

* @param v

* 需要四舍五入的数字

* @return

*/

public static int roundDown(double v) {

BigDecimal b = new BigDecimal(Double.toString(v));

BigDecimal one = new BigDecimal("1");

return b.divide(one, 0, BigDecimal.ROUND_DOWN).intValue();

}

/**

* 描述：四舍五入取整处理

*

* @param v

* 需要四舍五入的数字

* @return

*/

public static int roundUp(double v) {

BigDecimal b = new BigDecimal(Double.toString(v));

BigDecimal one = new BigDecimal("1");

return b.divide(one, 0, BigDecimal.ROUND_UP).intValue();

}

/**

* 描述：提供精确的小数位四舍五入处理。

*

* @param v

* 需要四舍五入的数字

* @param scale

* 小数点后保留几位

* @return 四舍五入后的结果

*/

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(Double.toString(v));

BigDecimal one = new BigDecimal("1");

return b.divide(one, scale, BigDecimal.ROUND_HALF_UP).doubleValue();

}

/**

* 描述：四舍五入保留两位小数

*

* @param num

* 数字

* @return 保留两位小数的数字字串

*/

public static String format(double num) {

return format(num, "0.00");

}

/**

* 描述：四舍五入数字保留小数位

*

* @param num

* 数字

* @param digits

* 小数位

* @return

*/

public static String format(double num, int digits) {

String pattern = "0";

if (digits > 0) {

pattern += "." + createStr("0", digits, "");

}

return format(num, pattern);

}

/**

* 描述：生成字符串

*

* @param arg0

* 字符串元素

* @param arg1

* 生成个数

* @param arg2

* 间隔符号

* @return

*/

private static String createStr(String arg0, int arg1, String arg2) {

if (arg0 == null) {

return "";

} else {

StringBuffer sb = new StringBuffer();

for (int i = 0; i < arg1; i++) {

if (arg2 == null)

arg2 = "";

sb.append(arg0).append(arg2);

}

if (sb.length() > 0) {

sb.delete(sb.lastIndexOf(arg2), sb.length());

}

return sb.toString();

}

}

/**

* 描述：数字格式化

*

* @param num

* 数字

* @param pattern

* 格式

* @return

*/

public static String format(double num, String pattern) {

NumberFormat fmt = null;

if (pattern != null && pattern.length() > 0) {

fmt = new DecimalFormat(pattern);

} else {

fmt = new DecimalFormat();

}

return fmt.format(num);

}

/**

* 求浮点数的权重

*

* @param number

* @return

*/

public static double weight(double number) {

if (number == 0) {

return 1;

}

double e = Math.log10(Math.abs(number));

int n = Double.valueOf(Math.floor(e)).intValue();

double weight = 1;

if (n > 0) {

for (int i = 0; i < n; i++) {

weight *= 10;

}

} else {

for (int i = 0; i > n; i--) {

weight /= 10;

}

}

return weight;

}

/**

* 获得权重的单位

*

* @param scale

* @return

*/

public static String unit(double scale) {

if (scale == 1 || scale == 0) {

return "";// 不设置单位倍率单位，使用基准单位

}

String[] units = new String[] { "十", "百", "千", "万", "十万", "百万", "千万", "亿", "十亿", "百亿", "千亿", "兆" };

String[] units2 = new String[] { "十分", "百分", "千分", "万分", "十万分", "百万分", "千万分" };

double e = Math.log10(scale);

int position = Double.valueOf(Math.ceil(e)).intValue();

if (position >= 1 && position <= units.length) {

return units[position - 1];

} else if (position <= -1 && -position <= units2.length) {

return units2[-position - 1];

} else {

return "无量";

}

}

/**

* 获得浮点数的缩放比例

*

* @param num

* @return

*/

public static double scale(double num) {

double absValue = Math.abs(num);

// 无需缩放

if (absValue < 10000 && absValue >= 1) {

return 1;

}

// 无需缩放

else if (absValue < 1 && absValue > 0.0001) {

return 1;

} else {

return weight(num) / 10;

}

}

/**

* 获得缩放后并且格式化的浮点数

*

* @param num

* @param scale

* @return

*/

public static double scaleNumber(double num, double scale) {

DecimalFormat df = null;

if (scale == 1) {

df = new DecimalFormat("#.0000");

} else {

df = new DecimalFormat("#.00");

}

double scaledNum = num / scale;

return Double.valueOf(df.format(scaledNum));

}

/**

* 产生n位随机数 TODO:性能不要，有待优化

*/

public static String ramdomNumber(int n) {

if (n <= 0) {

throw new IllegalArgumentException("n must be positive !");

}

Random random = new Random();

StringBuilder result = new StringBuilder();

for (int i = 0; i < n; i++) {

result.append(random.nextInt(10));

}

return result.toString();

}

/**

* 缩放1W倍

*/

public static double changeTo(double number) {

boolean flag = false;

if (number < 0) {

flag = true;

}

double value = Math.abs(number);

value = value / 10000.0;

if (flag) {

value = Double.parseDouble("-" + value);

}

return value;

}

/**

*

* 描述：缩放比例

*

* @param number

* @param scale

* @param points

* @return

*/

public static String scaleNumberToStr(double number, double scale, int points) {

boolean flag = (number < 0);

number = Math.abs(number);

String result = "";

DecimalFormat nbf3 = (DecimalFormat) NumberFormat.getInstance();// 默认格式

nbf3.setGroupingUsed(false);

nbf3.setMinimumFractionDigits(points);

nbf3.setMaximumFractionDigits(points);

double scaledNum = number / scale;

result = nbf3.format(scaledNum);

if (flag) {

result = "-" + result;

}

return result;

}

}