工具类，各种保留小数点位数及特殊需求

最新推荐文章于 2021-01-14 05:39:46 发布
最新推荐文章于 2021-01-14 05:39:46 发布
阅读量1k 收藏
点赞数 1
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/xiangyihu/article/details/77712156
版权 
/**
 * Copyright (C) 2015 北京学信科技有限公司
 *
 * @className com.xuexin.management.util.NumberUtils
 * @version v1.0.0 
 * @author hyx
 * 
 * Modification History:
 * Date         Author      Version     Description
 * -----------------------------------------------------------------
 * 2015年10月16日       hyx            v1.0.0      create
 *
 */
package com.xuexin.evaluation.util;

import java.math.BigDecimal;
import java.util.regex.Pattern;

import org.apache.commons.lang.StringUtils;

/** 
 * 类描述
 *
 * @author 徐高波
 * @date 2015年10月16日 上午11:25:28 
 */
public class NumberUtils {

    /** 
     * 判断当前值是否为整数 
     *  
     * @param value 
     * @return 
     */
    public static boolean isInteger(Object value) {
        if (StringUtils.isEmpty(String.valueOf(value))) {
            return false;
        }
        String mstr = String.valueOf(value);
        Pattern pattern = Pattern.compile("^-?\\d+{1}");
        return pattern.matcher(mstr).matches();
    }

    /** 
     * 判断当前值是否为数字(包括小数) 
     *  
     * @param value 
     * @return 
     */
    public static boolean isDigit(Object value) {
        if (StringUtils.isEmpty(String.valueOf(value))) {
            return false;
        }
        String mstr = String.valueOf(value);
        Pattern pattern = Pattern.compile("^-?[0-9]*.?[0-9]*{1}");
        return pattern.matcher(mstr).matches();
    }

    /** 
     * 将数字格式化输出 
     *  
     * @param value 
     *            需要格式化的值 
     * @param precision 
     *            精度(小数点后的位数) 
     * @return 
     */
    public static String format(Object value, Integer precision) {
        Double number = 0.0;
        if (NumberUtils.isDigit(value)) {
            number = new Double(value.toString());
        }
        precision = (precision == null || precision < 0) ? 2 : precision;
        BigDecimal bigDecimal = new BigDecimal(number);
        return bigDecimal.setScale(precision, BigDecimal.ROUND_HALF_UP)
                .toString();
    }

    /** 
     * 将数字格式化输出 
     *  
     * @param value 
     *            需要格式化的值 
     * @param precision 
     *            精度(小数点后的位数) 
     * @return 
     */
    public static Double formatDouble(Object value, Integer precision) {
        Double number = 0.0;
        if (NumberUtils.isDigit(value)) {
            number = new Double(value.toString());
        }
        precision = (precision == null || precision < 0) ? 2 : precision;
        BigDecimal bigDecimal = new BigDecimal(number);
        return bigDecimal.setScale(precision, BigDecimal.ROUND_HALF_UP)
                .doubleValue();
    }

    /**
     * 
     * 去除多余的小数点，直接舍弃
     *
     * @param value
     * @param precision
     * @return
     * @version v1.0
     * @author 徐高波
     * @date 2016年9月19日 下午1:07:37
     */
    public static Double formatDoubleDown(Object value, Integer precision) {
        Double number = 0.0;
        if (NumberUtils.isDigit(value)) {
            number = new Double(value.toString());
        }
        precision = (precision == null || precision < 0) ? 2 : precision;
        BigDecimal bigDecimal = new BigDecimal(number);
        return bigDecimal.setScale(precision, BigDecimal.ROUND_DOWN)
                .doubleValue();
    }

    /** 
     * 将数字格式化输出 
     *  
     * @param value 
     * @return 
     */
    public static String format(Object value) {
        return NumberUtils.format(value, 2);
    }

    /** 
     * 将值转成Integer型，如果不是整数，则返回0 
     *  
     * @param value 
     * @param replace 
     *            如果为0或者null，替换值 
     * @return 
     */
    public static Integer parseInteger(Object value, Integer replace) {
        if (value == null)
            return replace;
        if (!NumberUtils.isInteger(value)) {
            return replace;
        }
        return new Integer(value.toString());
    }

    /** 
     * 将值转成Integer型，如果不是整数，则返回0 
     *  
     * @param value 
     * @return 
     */
    public static Integer parseInteger(Object value) {
        return NumberUtils.parseInteger(value, 0);
    }

    /** 
     * 将值转成Long型 
     *  
     * @param value 
     * @param replace 
     *            如果为0或者null，替换值 
     * @return 
     */
    public static Long parseLong(Object value, Long replace) {
        if (!NumberUtils.isInteger(value)) {
            return replace;
        }
        return new Long(value.toString());
    }

    /** 
     * 将值转成Long型，如果不是整数，则返回0 
     *  
     * @param value 
     * @return 
     */
    public static Long parseLong(Object value) {
        return NumberUtils.parseLong(value, 0L);
    }

    /** 
     * 将值转成Double型 
     *  
     * @param value 
     * @param replace 
     *            replace 如果为0或者null，替换值 
     * @return 
     */
    public static Double parseDouble(Object value, Double replace) {
        if (!NumberUtils.isDigit(value)) {
            return replace;
        }
        return new Double(value.toString());
    }

    /** 
     * 将值转成Double型，如果不是整数，则返回0 
     *  
     * @param value 
     * @return 
     */
    public static Double parseDouble(Object value) {
        if (value == null)
            return 0.0;
        return NumberUtils.parseDouble(value, 0.0);
    }

    /** 
     * 将char型数据转成字节数组 
     *  
     * @param value 
     * @return 
     */
    public static byte[] toBytes(char value) {
        byte[] bt = new byte[2];
        for (int i = 0; i < bt.length; i++) {
            bt[i] = (byte) (value >>> (i * 8));
        }
        return bt;
    }

    /** 
     * 将short型数据转成字节数组 
     *  
     * @param value 
     * @return 
     */
    public static byte[] toBytes(short value) {
        byte[] bt = new byte[2];
        for (int i = 0; i < bt.length; i++) {
            bt[i] = (byte) (value >>> (i * 8));
        }
        return bt;
    }

    /** 
     * 将int型数据转成字节数组 
     *  
     * @param value 
     * @return 
     */
    public static byte[] toBytes(int value) {
        byte[] bt = new byte[4];
        for (int i = 0; i < bt.length; i++) {
            bt[i] = (byte) (value >>> (i * 8));
        }
        return bt;
    }

    /** 
     * 将long型数据转成字节数组 
     *  
     * @param value 
     * @return 
     */
    public static byte[] toBytes(long value) {
        byte[] bt = new byte[8];
        for (int i = 0; i < bt.length; i++) {
            bt[i] = (byte) (value >>> (i * 8));
        }
        return bt;
    }

    /** 
     * 将short型数据插入到指定索引的字节数组中 
     *  
     * @param index 
     *            索引 
     * @param values 
     *            字节数组 
     * @param value 
     *            需要插入的值 
     */
    public static void insert(int index, byte[] values, short value) {
        byte[] bt = NumberUtils.toBytes(value);
        System.arraycopy(bt, 0, values, index, 2);
    }

    /** 
     * 将int型数据插入到指定索引的字节数组中 
     *  
     * @param index 
     *            索引 
     * @param values 
     *            字节数组 
     * @param value 
     *            需要插入的值 
     */
    public static void insert(int index, byte[] values, int value) {
        byte[] bt = NumberUtils.toBytes(value);
        System.arraycopy(bt, 0, values, index, 4);
    }

    /** 
     * 将long型数据插入到指定索引的字节数组中 
     *  
     * @param index 
     *            索引 
     * @param values 
     *            字节数组 
     * @param value 
     *            需要插入的值 
     */
    public static void insert(int index, byte[] values, long value) {
        byte[] bt = NumberUtils.toBytes(value);
        System.arraycopy(bt, 0, values, index, 8);
    }

    /** 
     * 将字节转换成整型 
     *  
     * @param value 
     *            字节类型值 
     * @return 
     */
    public static int byteToInt(byte value) {
        if (value < 0) {
            return value + 256;
        }
        return value;
    }

    /**
     * 
     * 除法，返回2位精度的百分比数字  80.23
     *
     * @param num
     * @param div
     * @return
     * @date 2015年10月17日 上午8:12:30
     */
    public static double divideRate(Object num, Object div) {
        double a = NumberUtils.parseDouble(num);
        double b = NumberUtils.parseDouble(div);
        if (b != 0) {
            return Double.parseDouble(NumberUtils.format(a * 100 / b, 2));//精确到小数点2位
        } else {
            return 0.00;
        }

    }

    /**
     * 
     * 除法，返回2位精度的百分比数字  80.23
     *
     * @param num
     * @param div
     * @return
     * @date 2015年10月17日 上午8:12:30
     */
    public static String divideRateStr(Object num, Object div) {
        double a = NumberUtils.parseDouble(num);
        double b = NumberUtils.parseDouble(div);
        if (b != 0) {
            return NumberUtils.format(a * 100 / b, 2);//精确到小数点2位
        } else {
            return "0.00";
        }

    }

    /**
     * 
     * 除法，返回2位精度的数字  0.23
     *
     * @param num
     * @param div
     * @return
     * @version v1.0
     * @author 徐高波
     * @date 2015年12月1日 下午1:00:26
     */
    public static double divide(Object num, Object div) {
        double a = NumberUtils.parseDouble(num);
        double b = NumberUtils.parseDouble(div);
        if (b != 0) {
            return Double.parseDouble(NumberUtils.format(a / b, 2));//精确到小数点2位
        } else {
            return 0.00;
        }

    }

    /**
     * 
     * 除法
     *
     * @param num
     * @param div
     * @return
     * @version v1.0
     * @author 徐高波
     * @date 2015年12月1日 下午1:00:26
     */
    public static double divideA(Object num, Object div) {
        double a = NumberUtils.parseDouble(num);
        double b = NumberUtils.parseDouble(div);
        if (b != 0) {
            return a / b;
        } else {
            return 0.0;
        }

    }

    /**
     * 
     * 获取String类型数字
     *
     * @param obj
     * @return
     * @version v1.0
     * @author 徐高波
     * @date 2015年12月4日 上午11:00:14
     */
    public static String formatInteger(Integer obj) {
        if (obj == null) {
            return "0";
        } else {
            return obj.toString();
        }

    }

    /** 
     * 使用java正则表达式去掉多余的.与0 
     * 主要是处理“1.0”显示在为“1”
     * 
     * @param f 
     * @return  
     */
    public static String FormatFloat(Float f) {
        if (f == null) {
            return "0";
        }
        String s = f.toString();
        if (s.indexOf(".") > 0) {
            s = s.replaceAll("0+?$", "");//去掉多余的0  
            s = s.replaceAll("[.]$", "");//如最后一位是.则去掉  
        }
        return s;
    }

    /** 
     * 使用java正则表达式去掉多余的.与0 
     * 主要是处理“1.0”显示在为“1”
     * 
     * @param f 
     * @return  
     */
    public static String formatStr(String s) {
        if (s == null) {
            return "0";
        }
        if (s.indexOf(".") > 0) {
            s = s.replaceAll("0+?$", "");//去掉多余的0  
            s = s.replaceAll("[.]$", "");//如最后一位是.则去掉  
        }
        return s;
    }

    /** 
     * 使用java正则表达式去掉多余的.与0 
     * 主要是处理“1.0”显示在为“1”
     * 
     * @param f 
     * @return  
     */
    public static Double formatDouble(String s) {
        if (s == null) {
            return Double.valueOf("0");
        }
        if (s.indexOf(".") > 0) {
            s = s.replaceAll("0+?$", "");//去掉多余的0  
            s = s.replaceAll("[.]$", "");//如最后一位是.则去掉  
        }

        return Double.valueOf(s);
    }

    /** 
     * 使用java正则表达式去掉多余的.与0 
     * 主要是处理“1.0”显示在为“1”
     * 
     * @param f 
     * @return  
     */
    public static String FormatDoubleZero(Double f) {
        if (f == null) {
            return "0";
        }
        String s = f.toString();
        if (s.indexOf(".") > 0) {
            s = s.replaceAll("0+?$", "");//去掉多余的0  
            s = s.replaceAll("[.]$", "");//如最后一位是.则去掉  
        }
        return s;
    }

    /**
     * 转换Double数字成概率，例如0.25696,转换成25.7,页面展示时，需要自行拼接%
     * add by liuhj 20161215
     * @param value 原始值
     * @param precision 精度，小数点后多少位
     * @param  isIncludePostfix:是否包含%后缀
     * @return 格式化后的字符串
     */
    public static Object formatDoubleToRate(Double value, Integer precision,
            boolean isIncludePostfix) {
        Double first = NumberUtils.formatDouble(value * 100, precision + 1);
        Object end = NumberUtils.formatDouble(first, precision);
        return isIncludePostfix ? (end + "%") : end;
    }

    /**
     * 将数字转换成大写
     * @author kyq
     * @version
     * @date 2017/4/26 13:50
     * @param number 数字
     */
    public static String number2Chinese(String number){
        String[] s1 = { "零", "一", "二", "三", "四", "五", "六", "七", "八", "九" };
        String[] s2 = { "十", "百", "千", "万", "十万", "百万", "千万", "亿", "十亿", "百亿", "千亿" };
        String result = "";
        int n = number.length();
        for (int i = 0; i < n; i++) {
            int num = number.charAt(i) - '0';
            if (i != n - 1 && num != 0) {
                result += s1[num] + s2[n - 2 - i];
            } else {
                if(result=="" || !(("零".equals(result.substring(result.length() - 1))) && "零".equals(s1[num]))){
                    result += s1[num];
                }
            }
        }
        System.out.println("----------------");
        System.out.println(result);
        return result;
    }


    public static void main(String[] args) {
        System.out.println(isDigit("66"));
    }
}
【Java-DecimalFormat】Java-DecimalFormat工具类在进行运算时如何保留小数点后几位
weixin_53543905的博客
07-07 1126
【Java-DecimalFormat】Java-DecimalFormat工具类在进行运算时如何保留小数点后几位、2、得出的结果小数点后并没有数，是什么原因导致的？那么小数点后两位即使是0也会保留。那么小数点后两位如果是0则会省略。
Java中处理double、float、Double、Float、BigDecimal、String类型对象的小数工具类，保留小数位或取整，是否四舍五入
番茄Salad
06-20 463
由于每次都要处理小数，很麻烦，所以封装一个工具类来去处理，这个工具类专门用来处理小数位的，就比如我是double、float、Double、Float、BigDecimal、String这些。工具类提供三个参数，一个是泛型的value用来传入任何类型的（double、float、Double、Float、BigDecimal、String）值，一个是保留多少位scale用来截取多少位，一个是是否需要四舍五入判断指标isHalf用来判断是否需要四舍五入，如我value是double类型1.336，scale是
NumberUtils用法
热门推荐
08-16 4万+
/*1. NumberUtils.isNumber() : 判断字符串是否是数字*/      NumberUtils.isNumber("5.96");//结果是true   NumberUtils.isNumber("s5");//结果是false   NumberUtils.isNumber("0000000000596");//结果是true      /*2. NumberU
MySql自定义函数-关于保留小数位的特殊需求
Howinfun的博客
09-21 668
利用MySql自定义函数完成保留小数位的特殊需求
NumberUtils
a1003434346的博客
08-27 541
/** * 保留小数点 * * @param number * * @param dot 保留位数,保留0位从角四舍五入,保留1位从分四舍五入,以此类推 * * @return * */ public static double formatDoubleDot(double number, int dot) ...
java中小数格式化函数
yangxn的专栏
09-09 1894
 一、NumberUtils 方法名 描述         format(double d, int length) 将小数四舍五入后返回字符型    On Entry: double d: 需要处理的小数 如：3.73394int length:要保留的位数    On Exit: return String返回处理后的字符小数。    format(String d, int length
型数据保留几位小数_Bytes型数据decode时是如何知道要把几位数据组合在一起的？...
weixin_36256361的博客
01-14 131
摄影：产品经理产品经理希望吃肉吃虾，我喜欢豌豆尖大家在开发 Python 的过程中，经常会进行字符串encode为 Bytes型数据，或者把 Bytes 型数据 decode为字符串的操作。例如：我们知道，在 Unicode 编码中，中文占3个字节，所以一个中文字符编码为 Bytes 型数据以后，会占用3个 Bytes 字符，例如：>>> a = '青'>>...
Java指定保留小数位数的方法
08-31
Java指定保留小数位数的方法 Java语言中经常需要保留小数位数，例如在金融、科研等领域，保留小数位数是非常重要的。这篇文章将详细介绍Java指定保留小数位数的方法，包括使用String.format方法、DecimalFormat类和...
arcgis小数点位数调整
最新发布
12-31
### 设置或修改数值字段的小数点...针对某些特殊需求场景下可能要求严格控制坐标的精确程度，如保留六个有效小数位。此时可通过自定义脚本或者模型构建器里的逻辑流程来进行补充填充零的操作，从而达到预期效果[^3]。
java常用工具类 数字工具类
08-25
对于处理数字，Java提供了多种工具类，其中数字工具类提供了丰富的静态方法，用于执行各种数字操作。本文将详细介绍Java中的数字工具类，并深入探讨其提供的关键方法，以便开发者能够更加熟练地使用这些工具类来提高...
Java 数字相关操作通用类 NumberUtils.java
Admans的专栏
01-29 1241
package com.*.*.*.utils; import java.math.BigDecimal; import java.math.BigInteger; import java.math.RoundingMode; import java.text.DecimalFormat; import java.util.regex.Matcher; import java.util.reg...
（六）Java工具类NumberUtils详解
OceanSky的专栏
01-22 1万+
int数据类型和long数据类型 int占32位，long占64位，long表示的数据更大； public static int toInt(String str) NumberUtils.toInt(null) = 0 NumberUtils.toInt("") = 0 NumberUtils.toInt("1") = 1 说明：将一个字符串转换成int类
NumberUtils的使用及数字处理需要注意的东西
shirley_zx的专栏
08-24 5640
1.org.apache.commons.lang3.math.NumberUtils的使用 public static void main(String[] args) { //isNumber System.out.println(NumberUtils.isNumber("2.34f"));//true System.out.println(
java工具类之NumberUtils
落叶无声的专栏
08-21 2514
保留两位小数DemicalFormat0：代表1位占位符，数字位数不足则填充0 # : 尽可能代表多位数字占位符，数字位数不足则不填充，显示空DecimalFormat format = new DecimalFormat("#0.00"); System.out.println(format.format(958412.2415));//958412.24，保留两位小数format =
apache工具类系列
qq_37891961的博客
06-19 729
在网上找了一段时间的数组求平均值得工具类,几乎所有的都是自己编写的工具类,最后还是自己找到了就在这里贴一下 所用的工具类 import org.apache.commons.math.stat.StatUtils; Apache下的工具类实在是强大; public static void main(String[] args) { double[] i = new double[]
apache--common 常用组件实例（二）
有 prepare , No out
12-30 2659
1 package com.special; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.lang.reflect.Array; import java.lang.reflect.Method; import java.math.BigDecimal; import java.ni
java保留指定小数位数的工具类
我就是我不一样的美男子！
01-26 5631
package com.viathink; import java.math.BigDecimal; /** * 数字格式化工具类 * @author LiuJunGuang * @date 2013-1-26上午10:44:08 */ public class NumberUtils { /** * 格式化为指定位小数的数字,返回未使用科学计数法表示的具有指定位数的字符串。
Java 常用工具类(29) : 保留小数
Lxinccode的博客
01-02 774
import com.aliyun.et.industry.pangang.common.consts.Constants; import org.apache.commons.lang3.StringUtils; import java.math.BigDecimal; /** * @Auther: liyue * @Date: 2019/8/23 17:01 * @Descript...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值