Java常用工具类---数字工具类

拼搏现实的明天。 2022-01-29 14:49 377阅读 0赞

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;
    	}
    }