我的数字工具类DigitalUtil

package cn.jingdianbao.popbao;

import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.text.ParseException;
import java.util.Locale;
import java.util.Objects;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 类名: DigitalUtil
 * 描述:
 * 日期: 2021/7/13-16:02
 *
 * @author 
 */
public class DigitalUtil {
    public static void main(String[] args) {

      /*  for (float i = 0.001f; i < 1; i += 0.001) {
            System.out.format("%s---------%s%n", i, getNumber(i, 2, false));
        }*/
        System.out.println(getNumberFormat(1.567,false));
        System.out.println(getNumber(1.5555, 2, true));
        //如果参数是null 则打印nul
        //   System.out.format("%4.3f---------%n", 0.67896);

        double pi=3.1415926535;//圆周率
        //取整数部分，可以将0替换成#
        System.out.println(new DecimalFormat("0").format(pi));//3
        System.out.println(new DecimalFormat("#").format(pi));//3
        //取整数部分和两位小数(默认RoundingMode.HALF_EVEN)
        System.out.println(new DecimalFormat("0.00").format(pi));//3.14
        //取整数部分和三位小数(默认RoundingMode.HALF_EVEN)，整数不足部分以0填补。
        System.out.println(new DecimalFormat("00.000").format(pi));//03.142
        //以百分比方式计数，并取两位小数
        System.out.println(new DecimalFormat("#.##%").format(pi));//314.16%
        long c=299792458;//光速
        //显示为科学计数法，并取五位小数
        System.out.println(new DecimalFormat("#.#####E0").format(c));//2.99792E8
        //显示为两位整数的科学计数法，并取四位小数
        System.out.println(new DecimalFormat("00.####E0").format(c));//29.9792E7
        //每三位以逗号进行分隔。
        System.out.println(new DecimalFormat(",###").format(c));//299,792,458
        //将格式嵌入文本
        System.out.println(new DecimalFormat("光速大小为每秒,###米").format(c)); //光速大小为每秒299,792,458米

    }

    /**
     * DecimalFormat默认情况下，它使用 RoundingMode.HALF_EVEN
     * #与0的区别：
     *      #：整数和小数部分少了:不作处理
     *      0：整数和小数部分少了:补0
     * @param number
     * @return
     */
    public static String getNumberFormat(Number number) {
       return getNumberFormat(number, true);
    }

    /**
     * DecimalFormat默认情况下，它使用 RoundingMode.HALF_EVEN
     * #与0的区别：
     *      #：整数和小数部分少了:不作处理
     *      0：整数和小数部分少了:补0
     * @param number
     * @return
     */
    public static String getNumberFormat(Number number,boolean isHalfUp) {
        DecimalFormat dFormat = new DecimalFormat("0.00");
        dFormat.setRoundingMode(isHalfUp?RoundingMode.HALF_UP:RoundingMode.DOWN);
        return dFormat.format(number);
    }

    public static void getCountryFormat() {
        Locale[] locales = NumberFormat.getAvailableLocales();
        double myNumber = -1234.56;
        NumberFormat form;
        //四种实例模式
        for (int j = 0; j < 4; ++j) {
            System.out.println("=====================================FORMAT=============================");
            for (int i = 0; i < locales.length; ++i) {
                if (locales[i].getCountry().length() == 0) {
                    continue; // Skip language-only locales
                }
                String countryName = locales[i].getDisplayName();
                if (countryName.contains("中文")) {
                    System.err.print(countryName);
                } else {
                    continue;
                    // System.out.print(countryName);
                }
                switch (j) {
                    case 0:
                        form = NumberFormat.getInstance(locales[i]);
                        break;
                    case 1:
                        form = NumberFormat.getIntegerInstance(locales[i]);
                        break;
                    case 2:
                        form = NumberFormat.getCurrencyInstance(locales[i]);
                        break;
                    default:
                        form = NumberFormat.getPercentInstance(locales[i]);
                        break;
                }
                if (form instanceof DecimalFormat) {
                    System.out.print(": " + ((DecimalFormat) form).toPattern());
                }
                System.out.print(" -> " + form.format(myNumber));
                try {
                    System.out.println(" -> " + form.parse(form.format(myNumber)));
                } catch (ParseException e) {
                }
            }
        }
    }

    //(?<=^(\d{3})+)\B

    /**
     * @param oldStr  要填充的字符串
     * @param length  填充后整个字符串的长度:如32位，不足填充0
     * @param fillStr 要使用填充的字符串
     * @param isRight 是否填充在右边
     * @return String
     */
    public static String fillStr(String oldStr, Integer length, String fillStr, boolean isRight) {
        Objects.requireNonNull(oldStr, "oldStr不能为空！");
        //构造 %指定数字s
        String format = String.format(isRight ? "%%-%ds" : "%%%ds", length);
        // %[argument_index$][flags][width][.precision][t]conversion
        // %(\d+\$)?([-#+ 0,(\<]*)?(\d+)?(\.\d+)?([tT])?([a-zA-Z%])
        //开始真正的填充,【默认不足位数，左填充空格】
        format = String.format(format, oldStr);
        // System.out.println(format);
        String newStr = format.replace(" ", fillStr);
        return newStr;
    }


    /**
     * 描述：保留小数点后n位
     * 使用正则
     *
     * @param number
     * @return
     * @author 
     * @date: 2021/8/6 15:09
     */
    public static String getNumber(Number number) {
        return getNumber(number, 2, true);
    }

    /**
     * 描述：保留小数点后保留n位
     * 使用正则
     *
     * @param number
     * @param scale    小数点后n位数
     * @param isHalfUp 是否四舍五入
     * @return
     * @author 
     * @date: 2021/8/6 15:09
     */
    public static String getNumber(Number number, int scale, boolean isHalfUp) {
        Objects.requireNonNull(number, "number 不能为空！");
        isHalfUp = String.valueOf(number.doubleValue()).length() <= 3 ? true : isHalfUp;
        if (isHalfUp) {
            //%%表示%   %.2f
            String format = String.format("%%.%sf", scale);
            //对第二个参数非常严格，一定是要浮点型类型
            return String.format(format, number.doubleValue());
        }
        String numberRegx = String.format("-?\\d+(\\.\\d{%s})?", scale);
        Matcher matcher = Pattern.compile(numberRegx).matcher(number.toString());
        if (matcher.find()) {
            String result = matcher.group();
            if (!result.contains(".")) {
                return String.format(String.format("%%.%sf", scale), Double.valueOf(result));
            }
            return result;
        }
        return "";
    }

    /**
     * 描述：二进制转十进制
     *
     * @param binaryStr 二进制进制字符串，如:"11111111"
     * @return
     * @author 
     * @date: 2021/7/13 16:08
     */
    public static Integer binary2Ten(String binaryStr) {
        Integer tenStr = Integer.parseInt(binaryStr, 2);
        System.out.println(tenStr);
        return tenStr;
    }

    /**
     * 十进制转二进制
     *
     * @param tenInt
     * @return
     */
    public static String ten2Two(Integer tenInt) {
        String binaryStr = Integer.toBinaryString(tenInt);
        System.out.println(binaryStr);
        return binaryStr;
    }

    /**
     * 描述：十六进制转二进制
     * 十六进制无法直接转成二进制，找十进制作为中间转换层
     * f->15->1111
     *
     * @param sixteenStr 十六进制字符串，去掉0x 如：0xff ->ff
     * @return
     * @author 
     * @date: 2021/7/13 16:08
     */
    public static String sixteen2Two(String sixteenStr) {
        //先将16进制数转为10进制，再将10进制转为2进制
        Integer num = Integer.parseInt(sixteenStr, 16);
        String binaryStr = Integer.toBinaryString(num);
        System.out.println(binaryStr);
        return binaryStr;
    }
}