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

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。