重走Java路-基本数据类型包装类

最新推荐文章于 2024-04-30 12:12:17 发布
最新推荐文章于 2024-04-30 12:12:17 发布
阅读量168 收藏
点赞数 1
分类专栏： 重走Java路 文章标签： java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/crazyjavawu/article/details/105827906
版权

 

        承接昨天的“重走Java路-基本数据类型”，在讲到浮点数为什么不精确的时候提到了，要进行精确计算需要使用BigDecimal类。因为在工作中也确实没怎么使用该类，昨天写完博客之后发现自己视乎不太了解该类。于是今天就和大家一起学习一下BigDecimal类的使用，以及浮点数进行运行的时候如何进行四舍五入保留n位小数。

        BigDecimal类

        BigDecimal类位于java.math包中，用于对小数的精确计算，至于为什么进行精确计算是需要使用BigDecimal类，前面以及说过了并不是所有的十进制小数都可用二进制小数来表示。

        BigDecimal类中的常用构造方法

  1. BigDecimal(int)

    创建一个整数值的对象

  2. BigDecimal(BigInteger)

         创建一个大数值的对象

  1. BigDecimal(double)

    创建一个双精度浮点的对象

  2. BigDecimal(long)

    创建一个长整数值的对象

  3. BigDecimal(String)

    创建一个字符串数值的对象

        这些构造函数中建议使用BigDecimal(String)，因为BigDecimal(String)构造的BigDecimal对象是精确的，如果你使用BigDecimal(double)构造函数即使通过BigDecimal对象进行运算也没法保证计算结果的精确性。

        BigDecimal类中的常用方法

  1. add(BigDecimal)

    BigDecimal对象中的值相加，返回BigDecimal对象

  2. subtract(BigDecimal)

    BigDecimal对象中的值相减，返回BigDecimal对象

  3. multiply(BigDecimal)

    BigDecimal对象中的值相乘，返回BigDecimal对象

  4. divide(BigDecimal)

    BigDecimal对象中的值相除，返回BigDecimal对象

  5. toString()

    将BigDecimal对象中的值转换成字符串

  6. doubleValue()

    将BigDecimal对象中的值转换成双精度数

  7. floatValue()

    将BigDecimal对象中的值转换成单精度数

  8. longValue()

    将BigDecimal对象中的值转换成长整数

  9. intValue()

    将BigDecimal对象中的值转换成整数

        BigDecimal对象的大小比较

//使用compareTo进行BigDecimal对象的大小比较
BigDecimal bigDecimal1 = new BigDecimal("1.1");
BigDecimal bigDecimal2 = new BigDecimal("1.2");
//bigDecimal1 < bigDecimal2 返回 -1
System.out.println(bigDecimal1.compareTo(bigDecimal2));
//bigDecimal2 > bigDecimal1 返回 1
System.out.println(bigDecimal2.compareTo(bigDecimal1));
//bigDecimal1 = bigDecimal1 返回 -1
System.out.println(bigDecimal1.compareTo(bigDecimal1));

        输出

-1
1
0

        BigDecimal对象保留n位小数

//保留有限位数
BigDecimal bigDecimal3 = new BigDecimal("1.234567");
//进一法
System.out.println(bigDecimal3.setScale(2, BigDecimal.ROUND_UP));
System.out.println(bigDecimal3.setScale(2, BigDecimal.ROUND_CEILING));
//去尾法
System.out.println(bigDecimal3.setScale(2, BigDecimal.ROUND_DOWN));
System.out.println(bigDecimal3.setScale(2, BigDecimal.ROUND_FLOOR));
//四舍五入法
System.out.println(bigDecimal3.setScale(2, BigDecimal.ROUND_HALF_UP));
System.out.println(bigDecimal3.setScale(3, BigDecimal.ROUND_HALF_UP));
System.out.println(bigDecimal3.setScale(2, BigDecimal.ROUND_HALF_DOWN));
System.out.println(bigDecimal3.setScale(3, BigDecimal.ROUND_HALF_DOWN));
System.out.println(bigDecimal3.setScale(2, BigDecimal.ROUND_HALF_EVEN));
System.out.println(bigDecimal3.setScale(3, BigDecimal.ROUND_HALF_EVEN));

        输出

1.24
1.24
1.23
1.23
1.23
1.235
1.23
1.235
1.23
1.235

      BigDecimal格式化

NumberFormat currency = NumberFormat.getCurrencyInstance(); //建立货币格式化引用 
NumberFormat percent = NumberFormat.getPercentInstance();  //建立百分比格式化引用 percent.setMaximumFractionDigits(3); //百分比小数点最多3位 
	    
BigDecimal loanAmount = new BigDecimal("15000.48"); //贷款金额
BigDecimal interestRate = new BigDecimal("0.008"); //利率   
BigDecimal interest = loanAmount.multiply(interestRate); //相乘
	 
System.out.println("贷款金额:\t" + currency.format(loanAmount)); 
System.out.println("利率:\t" + percent.format(interestRate)); 
System.out.println("利息:\t" + currency.format(interest));

        输出：

贷款金额:	￥15,000.48
利率:	0.8%
利息:	￥120.00

        自定义工具

package com.founder.util;

import java.math.BigDecimal;

public class MyBigDecimalUtil {
	//默认除法运算精度
    private static final int DEF_DIV_SCALE = 10;

    /**
     * 提供精确的加法运算
     *
     * @param v1 被加数
     * @param v2 加数
     * @return 两个参数的和
     */

    public static double add(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.add(b2).doubleValue();
    }

    /**
     * 提供精确的加法运算
     *
     * @param v1 被加数
     * @param v2 加数
     * @return 两个参数的和
     */
    public static BigDecimal add(String v1, String v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.add(b2);
    }

    /**
     * 提供精确的加法运算
     *
     * @param v1    被加数
     * @param v2    加数
     * @param scale 保留scale 位小数
     * @return 两个参数的和
     */
    public static String add(String v1, String v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.add(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
    }

    /**
     * 提供精确的减法运算
     *
     * @param v1 被减数
     * @param v2 减数
     * @return 两个参数的差
     */
    public static double sub(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.subtract(b2).doubleValue();
    }

    /**
     * 提供精确的减法运算。
     *
     * @param v1 被减数
     * @param v2 减数
     * @return 两个参数的差
     */
    public static BigDecimal sub(String v1, String v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.subtract(b2);
    }

    /**
     * 提供精确的减法运算
     *
     * @param v1    被减数
     * @param v2    减数
     * @param scale 保留scale 位小数
     * @return 两个参数的差
     */
    public static String sub(String v1, String v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.subtract(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
    }

    /**
     * 提供精确的乘法运算
     *
     * @param v1 被乘数
     * @param v2 乘数
     * @return 两个参数的积
     */
    public static double mul(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.multiply(b2).doubleValue();
    }

    /**
     * 提供精确的乘法运算
     *
     * @param v1 被乘数
     * @param v2 乘数
     * @return 两个参数的积
     */
    public static BigDecimal mul(String v1, String v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.multiply(b2);
    }

    /**
     * 提供精确的乘法运算
     *
     * @param v1    被乘数
     * @param v2    乘数
     * @param scale 保留scale 位小数
     * @return 两个参数的积
     */
    public static double mul(double v1, double v2, int scale) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return round(b1.multiply(b2).doubleValue(), scale);
    }

    /**
     * 提供精确的乘法运算
     *
     * @param v1    被乘数
     * @param v2    乘数
     * @param scale 保留scale 位小数
     * @return 两个参数的积
     */
    public static String mul(String v1, String v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.multiply(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
    }

    /**
     * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到
     * 小数点以后10位，以后的数字四舍五入
     *
     * @param v1 被除数
     * @param v2 除数
     * @return 两个参数的商
     */

    public static double div(double v1, double v2) {
        return div(v1, v2, DEF_DIV_SCALE);
    }

    /**
     * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
     * 定精度，以后的数字四舍五入
     *
     * @param v1    被除数
     * @param v2    除数
     * @param scale 表示表示需要精确到小数点以后几位。
     * @return 两个参数的商
     */
    public static double div(double v1, double v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException("The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
    }

    /**
     * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
     * 定精度，以后的数字四舍五入
     *
     * @param v1    被除数
     * @param v2    除数
     * @param scale 表示需要精确到小数点以后几位
     * @return 两个参数的商
     */
    public static String div(String v1, String v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException("The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v1);
        return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).toString();
    }

    /**
     * 提供精确的小数位四舍五入处理
     *
     * @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));
        return b.setScale(scale, BigDecimal.ROUND_HALF_UP).doubleValue();
    }

    /**
     * 提供精确的小数位四舍五入处理
     *
     * @param v     需要四舍五入的数字
     * @param scale 小数点后保留几位
     * @return 四舍五入后的结果
     */
    public static String round(String v, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b = new BigDecimal(v);
        return b.setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
    }

    /**
     * 取余数
     *
     * @param v1    被除数
     * @param v2    除数
     * @param scale 小数点后保留几位
     * @return 余数
     */
    public static String remainder(String v1, String v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.remainder(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
    }

    /**
     * 取余数  BigDecimal
     *
     * @param v1    被除数
     * @param v2    除数
     * @param scale 小数点后保留几位
     * @return 余数
     */
    public static BigDecimal remainder(BigDecimal v1, BigDecimal v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        return v1.remainder(v2).setScale(scale, BigDecimal.ROUND_HALF_UP);
    }

    /**
     * 比较大小
     *
     * @param v1 被比较数
     * @param v2 比较数
     * @return 如果v1 大于v2 则 返回true 否则false
     */
    public static boolean compare(String v1, String v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        int bj = b1.compareTo(b2);
        boolean res;
        if (bj > 0)
            res = true;
        else
            res = false;
        return res;
    }
	
	
	
	

}

        Math类

        常用方法：

        1、    xxxValue()
        将 Number 对象转换为xxx数据类型的值并返回。
        2 、   compareTo()
        将number对象与参数比较。
        3 、   equals()
        判断number对象是否与参数相等。
        4 、   valueOf()
        返回一个 Number 对象指定的内置数据类型
        5、    toString()
        以字符串形式返回值。
        6、    parseInt()
        将字符串解析为int类型。
        7、    abs()
        返回参数的绝对值。
        8、    ceil()
        返回大于等于( >= )给定参数的的最小整数，类型为双精度浮点型。
        9、    floor()
        返回小于等于（<=）给定参数的最大整数 。
        10 、   rint()
        返回与参数最接近的整数。返回类型为double。
        11、    round()
        它表示四舍五入，算法为 Math.floor(x+0.5)，即将原来的数字加上 0.5 后再向下取整，所以，Math.round(11.5) 的结果为12，Math.round(-11.5) 的结果为-11。
        12、    min()
        返回两个参数中的最小值。
        13、    max()
        返回两个参数中的最大值。
        14、    exp()
        返回自然数底数e的参数次方。
        15、    log()
        返回参数的自然数底数的对数值。
        16 、   pow()
        返回第一个参数的第二个参数次方。
        17、    sqrt()
        求参数的算术平方根。
        18、    sin()
        求指定double类型参数的正弦值。
        19    cos()
        求指定double类型参数的余弦值。
        20、    tan()
        求指定double类型参数的正切值。
        21、    asin()
        求指定double类型参数的反正弦值。
        22、    acos()
        求指定double类型参数的反余弦值。
        23、    atan()
        求指定double类型参数的反正切值。
        24、    atan2()
        将笛卡尔坐标转换为极坐标，并返回极坐标的角度值。
        25、    toDegrees()
        将参数转化为角度。
        26、    toRadians()
        将角度转换为弧度。
        27、    random()
        返回一个随机数。

        总结：BigDecimal类用于进行浮点数的精确计算，其本质是一个引用数据类型对象(类)。我们在进行精确计算+、-、×、÷时不在调用常用的+、-、×、÷等数学运算符，而是调用对象的操作函数add()、subtract()、multiply()、divide()其本质也是Java面向对象的体现。我们将double、float浮点运算不精确的计算过程进行封装，转换成对象行为的调用（方法）而实现数据的精确计算。

        今天浮点运行的补充到此结束，欲知详情请听下回分解-“重走Java路-基本数据类型包装类”。

CrazyJavaWu
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 基本数据类型包装类
08-10
绍Java 基本数据类型包装类
Java修仙之路，十万字吐血整理全网最完整Java学习笔记（基础篇）
vincewm的博客
01-05 2604
从Java环境的搭建到实际代码的编写，从基本用法的讲解到底层原理的剖析，深度解析Java基础知识。本文是《Java学习路线》专栏的起始文章，旨在提供一套完整的Java学习路线，覆盖Java基础知识、数据库、SSM/SpringBoot等框架、Redis/MQ等中间件、设计模式、架构设计、性能调优、源码解读、核心面试题等全面的知识点，并在未来不断更新和完善，帮助Java从业者在更短的时间内成长为高级开发。
Java基础知识1----基本概念（1）
须臾徐的博客
04-18 2630
Java基础内容
Java中基本类型和封装类型数据与堆、栈的关系
shang的博客
07-20 4741
Java的堆是一个运行时数据区,类的(对象从中分配空间。这些对象通过new、newarray、anewarray和multianewarray等 指令建立，它们不需要程序代码来显式的释放。堆是由垃圾回收来负责的，堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时 动态分配内存的，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取
Java知识体系最强总结(2021版)
热门推荐
ThinkWon的博客
12-18 108万+
更新于2019-12-15 10:38:00 本人从事Java开发已多年，平时有记录问题解决方案和总结知识点的习惯，整理了一些有关Java的知识体系，这不是最终版，会不定期的更新。也算是记录自己在从事编程工作的成长足迹，通过博客可以促进博主与阅读者的共同进步，结交更多志同道合的朋友。特此分享给大家，本人见识有限，写的博客难免有错误或者疏忽的地方，还望各位大佬指点，在此表示感激不尽。 文章目录...
【Java基础】全网最详细 - 从入门到转行
東方幻想郷的博客
05-09 3513
Java是一种通用的、高级的、面向对象的编程语言，最初由Sun Microsystems（目前为Oracle公司）于1995年发布。它被设计成一种可以在各种不同的环境中运行的语言，不论是桌面应用程序、企业级应用程序、移动设备或集群服务器，都可以使用Java来开发。Java的特点包括：简单性：Java的语法相对于其他编程语言比较简单，易于学习和理解。面向对象：Java是一种完全的面向对象编程语言，支持类、继承、封装和多态等核心特性。平台无关性：Java编写的程序可以在不同的操作系统和硬件平台上运行。
Java基本数据类型包装类原理解析
08-19
主要介绍了Java基本数据类型包装类原理解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Java基本数据类型与对应的包装类(动力节点java学院整理)
08-30
Java是面向对象的编程语言，包装类的出现更好的体现这一思想，Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。 下面通过本文给大家详细介绍，感兴趣的朋友...
Java 基本数据类型与包装类之间的转换
05-19
Java 基本数据类型与包装类之间的转换的思维脑图
基本数据类型包装类.pdf
09-06
基本数据类型包装类.pdf
java方法重写（重点讲），方法重载
weixin_46281068的博客
04-27 948
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
Day25-Java基础之常用类1
m0_46053885的博客
04-27 888
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
Lambda表达式特点
weixin_57763462的博客
04-24 810
**API 设计**：Lambda 表达式鼓励使用函数式接口的设计模式，这改变了 Java 库的设计，例如 `java.util.function` 包下的一系列函数式接口。- **函数式编程**：Lambda 表达式引入了函数式编程的理念，使得 Java 更接近于函数式编程语言，如 Scala 和 Clojure。- **并发编程**：Lambda 表达式与 Java 8 新增的 Stream API 结合使用，可以简化并发编程，特别是与集合的操作相关。
Java解决最长公共前缀
无人罪的博客
04-28 229
编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串""。
MSE实现全链路灰度实践
云计算、数据库、大数据、深度学习、NLP、Python
04-24 434
待更新。
Java | 冒泡排序算法实现
yingzix688的博客
04-24 893
题目描述 编写一个Java程序，实现冒泡排序算法。程序需要能够接收一个整型数组作为输入，并输出排序后的数组。 冒泡排序是一种简单的排序算法，它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
公考学习平台|基于SprinBoot+vue的公考学习平台(源码+数据库+文档)
weixin_66413741的博客
04-30 724
本共享汽车管理系统有管理员和用户。管理员功能有个人中心，用户管理，投放地区管理，汽车信息管理，汽车投放管理，汽车入库管理，使用订单管理，汽车归还管理。用户可以在注册登录，可以对汽车进行使用产生订单，还可以归还。因而具有一定的实用性。本站是一个B/S模式系统，采用Spring Boot框架，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得共享汽车管理系统管理工作系统化、规范化。
【限流】基于springboot（拦截器） + redis（执行lua脚本）实现注解限流
最新发布
qq_43209531的博客
04-30 182
基于springboot（拦截器） + redis（执行lua脚本）实现注解限流
Java设计模式_概述（设计模式类型和基本原则）
weisian的博客
04-25 868
通过合成，可以将已有的类组合成新的类，达到复用的目的，同时保持类的简单和清晰。设计模式（Design pattern）代表了最佳的实践，是软件开发人员在软件开发过程中面临一般问题的解决方案，是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。但不推荐刚入门的开发者学习，哪怕把代码搞的一塌糊涂，也要先将功能完成，初学者，迈过坑是必然的，只有对自己编写的代码不满意，你才会体会到设计模式的重要性，也才能更加理解。也就是说，一个类应该尽量减少与其他类的耦合度，只与它直接相关的类进行交互。
java基本数据类型和包装类的区别
07-27
Java基本数据类型和包装类是Java中用来表示数据的两种不同方式。 1. 基本数据类型（Primitive Data Types）： - Java的基本数据类型有8种：byte、short、int、long、float、double、char和boolean。 - 这些基本...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值