Java基础-----Math类相关的API（一）

请添加图片描述

文章目录

1. Math类
- 1.1 简介
- 1.2 常用方法
- 1.3 小练身手
2.Random类
- 2.1 简介
- 2.2 构造方法
- 2.3 常用方法
3. BigInteger和BigDecimal
- 3.1 简介
- 3.2 创建方式
- 3.3 方法
- 3.4 RoundingModel处理方式(8种)
- - 3.4.1 **UP**
  - 3.4.2 **DOWN**
  - 3.4.3 **CEILING**
  - 3.4.4 **FLOOR**
  - 3.4.5 **HALF_UP**
  - 3.4.6 **HALF_DOWN**
  - 3.4.7 **HALF_EVEN**
  - 3.4.8 **UNNECESSARY**

1. Math类

1.1 简介

Math类中提供了大量用于数学运算的相关方法
Math类是使用final修饰的终结类，不能产生子类
Math类中的方法都是static修饰的静态方法，可以通过类名.方法名直接调用

        double v = Math.PI * 10;
        System.out.println("v = " + v);

1.2 常用方法

abs(int):求绝对值（int,long,float,double作为参数）
ceil(double):求大于等于给定值的最小整数值，以double类型返回
floor(double):求小于等于给定值的最大整数值，以double类型返回
max(int,int):求两个数字中最大的值（int long float double作为参数）
min(int,int):求两个数字中最小的值（int long float double作为参数）
random():获取一个0-1之间的随机小数
round(float|double):返回int或long，采用四舍五入法，获取最接近的整数值（传float型参数就返回int型，传double型参数就返回long型）
sqrt(double):获取平方根，如果传值为负数，返回NaN（Not a Number）
pow(double,double):求一个数的N次方
sin(double)/cos(double)/tan(double):获取给定弧度值的三角函数值

//abs():求绝对值
        int abs = Math.abs(-5);
        System.out.println(abs);//5

//ceil(double):返回>=参数的最小（最接近负无穷大） double值，并等于数学整数
        double ceil = Math.ceil(3.5);
        System.out.println("ceil = " + ceil);//4.0

 //floor(double):返回<=参数的最大（最接近正无穷大） double值，等于数学整数
        double floor = Math.floor(3.5);
        System.out.println("floor = " + floor);//3.0

//round():四舍五入     float->int   double->long
        long round = Math.round(3.1415);
        System.out.println("round = " + round);//3
        long round1 = Math.round(3.5426);
        System.out.println("round1 = " + round1);//4

//sqrt():开平方
        double sqrt = Math.sqrt(2);
        System.out.println("sqrt = " + sqrt);//1.4142135623730951
        double sqrt1 = Math.sqrt(-2);
        System.out.println("sqrt1 = " + sqrt1);//NaN

//pow():求几次方
        double pow = Math.pow(5, 3);
        System.out.println("pow = " + pow);//125.0

//sin(double)/cos(double)/tan(double)
        double sin = Math.sin(30);
        System.out.println("sin = " + sin);

1.3 小练身手

有一根棍，将其随机取两点，折成三段，有可能组成三角形，也有可能不会组成三角形。(任意两边之和大于第三边)。现有20000根棍，每根棍都按照上述方法操作，能够组成三角形的概率是多少？

思路：
- 假设棍子的长度为1，利用random()生成随机数，即随机截取的两个点
- 两个截取点p1和p2，一个在左边，一个在右边，位置不固定
- 因此左边的点 d1=min(p1,p2) 右边的点 d2=max(p1,p2)
- 第一段的长度为d1,第二段的距离为d2-d1,第三段的长度为1-d2
- 然后再判断是否满足组成三角形的条件

public class CountTri {
    public static void main(String[] args) {
        int count=0;
        for (int i = 0; i < 20000; i++) {
            double p1 = Math.random();
            double p2 = Math.random();
            double d1 = Math.min(p1, p2);//左边的点
            double d2 = Math.max(p1, p2);//右边的点
            double l1=d1;//截取的第一段
            double l2=d2-d1;//截取的第二段
            double l3=1-d2;//截取的第三段

           // System.out.println(l1+"\t"+l2+"\t"+l3);
            if(l1+l2>l3 && l1+l3>l2  && l2+l3>l1 ){
               // System.out.println("可以组成三角形");
                count++;
            }else {
                //System.out.println("不可以组成三角形");
            }

        }
        //组成三角形的概率
        System.out.println(count);
        System.out.println(count/20000D);
        System.out.println((count/20000D)*100+"%");
        System.out.println(Math.round(count/20000D*100)+"%");

    }
}

2.Random类

2.1 简介

java.util下有一个Random类，根据随机算法的起源数字（种子）进行一些迭代变化，来产生随机数。
虽然Random类产生的数字是随机的，但在相同种子数下的相同次数产生的随机数是相同的（伪随机）。

2.2 构造方法

Random():以系统自身的时间为种子类来构造Random对象
Random(long):可以自己选定具体的种子来构造Random对象

public class Test {
    public static void main(String[] args) {
        /*Random random=new Random();
        int i=random.nextInt();
        System.out.println(i);//1936132354  1046228992*/
        
        /*Random()在相同种子数下的相同次数产生的额随机数是相同的（伪随机）*/
        Random random=new Random(100);
        Random random1=new Random(100);
        int num=random.nextInt();
        int num1=random1.nextInt();
        System.out.println(num);//-1193959466
        System.out.println(num1);//-1193959466
    }
}

2.3 常用方法

nextInt():获取int类型的随机数
nextInt(int):获取0（包含）到给定值（不包含）之间的随机数
nextlong():获取long类型的随机数
nextfloat():获取一个随机单精度浮点数0-1之间
nextDouble():获取一个随机双精度浮点数0-1之间
nextBoolean():返回一个随机boolean类型的值，true或false，概率相同

Random random=new Random();
//nextInt(int):获取0（包含）到给定值（不包含）之间的随机数
int i=random.nextInt(50);
System.out.println(i);

long l = random.nextLong();
System.out.println(l);

boolean b = random.nextBoolean();
System.out.println(b);

3. BigInteger和BigDecimal

3.1 简介

BigInteger可以支持任意长度的整数
BieDecimal可以支持任意精度的浮点数
BigInteger和BigDecimal是用来做精确计算的

3.2 创建方式

new BigInteger();
new BigInteger(参数1,进制)：可以将不同进制转成10进制显示
new BigDecimal();
BigInteger.valueOf();
BigDecimal.valueOf();
Scanner对象的nextBigInteger() nextBigDecimal();

Scanner scanner=new Scanner(System.in);
BigDecimal d=scanner.nextBigDecimal();
BigInteger b=scanner.nextBigInteger();

//BigInteger可以支持任意长度的整数
BigInteger b=new BigInteger("123456789123456789123456789");
System.out.println(b);//123456789123456789123456789
BigInteger b1=BigInteger.valueOf(12345678912L);
System.out.println(b1);//12345678912

BigDecimal d=new BigDecimal("3.1415");
BigDecimal x=new BigDecimal(10);
BigDecimal z=d.multiply(x);
System.out.println("z = " + z);//31.4150

BigDecimal d1=new BigDecimal(3.1415);
BigDecimal x1=new BigDecimal(10);
BigDecimal z1=d1.multiply(x1);
System.out.println("z1 = " + z1);//

上面这段代码的运行结果：
在这里插入图片描述
出现上面的原因是：
一个是字符串类型一个是double，部分浮点数不能被精准的表达就会出现这个问题所以用这个类的时候要用字符串传参（特别注意double 类型）

更具体的原因是：十进制的 double 类型的数据在进行计算的时候,计算机会先将其转换为二进制数据,然后再进行相关的运算。然而在十进制转二进制的过程中,有些十进制数是无法使用一个有限的二进制数来表达的,换言之就是转换的时候出现了精度的丢失问题,所以导致最后在运算的过程中,自然就出现了我们看到的一幕。

我们来对比一下double和BigDecimal的精度：

 double d=3.1415;
 double x=10;
 double z=d*x;
 System.out.println(z);//31.415000000000003

 BigDecimal d=new BigDecimal("3.1415");
 BigDecimal x=new BigDecimal(10);
 BigDecimal z=d.multiply(x);
 System.out.println("z = " + z);//31.4150

3.3 方法

add():加法
intValue():将BigInteger转成int类型值
doubleValue():将BigDecimal转成double类型值
substract():减法
multiply():乘法
divide():除法 BigInteger只保留整数。BigDecimal用法和BigInteger完全不同
remainder():求余数
divideAndRemainder():求除法商和余数，返回的是BigInteger数组
max():求最大值
min():求最小值

//add():加法
BigInteger b=new BigInteger("123");
BigInteger b1=new BigInteger("2");
BigInteger r=b.add(b1);
System.out.println(r);//125
int i = r.intValue();
System.out.println(i);//125

BigInteger b=new BigInteger("1231213123123");
BigInteger b1=new BigInteger("2");
BigInteger r=b.add(b1);
System.out.println(r);
int i = r.intValue();
System.out.println(i);

此段代码运行结果：
在这里插入图片描述
出现上面结果的原因是：超出int的范围

------------------------------------------------------------------------------------------------------------------------------------------------我们继续ღღღღღღღღ--------------------------------------------------------------------------------------

BigInteger b=new BigInteger("123");
BigInteger b1=new BigInteger("2");
//加法
BigInteger r=b.add(b1);
System.out.println("r = " + r);//125
int i = r.intValue();
System.out.println(i);//125
//减法
BigInteger subtract = b.subtract(b1);
System.out.println("subtract = " + subtract);//121
//乘法
BigInteger multiply = b.multiply(b1);//246
System.out.println("multiply = " + multiply);
//除法   BigInteger只保留整数   BigDecimal会有小数
BigInteger divide = b.divide(b1);
System.out.println("divide = " + divide);//61
BigDecimal d=new BigDecimal("10");
BigDecimal d1=new BigDecimal("4");
BigDecimal divide1 = d.divide(d1);
System.out.println("divide1 = " + divide1);//2.5

--------------------------------------------------------------------------------------------------------------------------------------------------我们继续ღღღღღღღღ----------------------------------------------------------------------------

BigDecimal d=new BigDecimal("10");
BigDecimal d1=new BigDecimal("3");
BigDecimal divide1 = d.divide(d1);
System.out.println("divide1 = " + divide1);//报错

在这里插入图片描述

解决办法一：使用RoundingMode.UP

BigDecimal divide1 = d.divide(d1,2, RoundingMode.UP);//保留两位小数
System.out.println("divide1 = " + divide1);//3.34

解决方法二：使用reminder 求余数

BigInteger b=new BigInteger("123");
BigInteger b1=new BigInteger("2");
BigInteger remainder = b.remainder(b1);
System.out.println("remainder = " + remainder);//1

解决方法三：使用divideAndRemainder，求商和余数返回的是BigInteger数组

BigInteger b=new BigInteger("123");
BigInteger b1=new BigInteger("2");
BigInteger[] bigIntegers = b.divideAndRemainder(b1);
System.out.println(bigIntegers[0]);//61
System.out.println(bigIntegers[1]);//1

-------------------------------------------------------------------------------------------------------------------------------------------我们继续ღღღღღღღღ----------------------------------------------------------------------------------------------

//doubleValue():将BigDecimal转成double类型值
BigDecimal d=new BigDecimal("10");
double v = d.doubleValue();
System.out.println("v = " + v);//10.0

//new BigInteger(参数1,进制)：可以将不同进制转成10进制显示
BigInteger b=new BigInteger("A",16);
BigInteger b1=new BigInteger("7",8);
System.out.println("b = " + b);//10
System.out.println("b1 = " + b1);//7

3.4 RoundingModel处理方式(8种)

UP
DOWN
CEILING
FLOOR
HALF_UP
HALF_DOWN
HALF_EVEN
UNNECESSARY

3.4.1 UP

远离零方向舍入模式，始终对非零舍弃部分前面的数字+1
在这里插入图片描述

//UP:远离零方向舍入模式，始终对非零舍弃部分前面的数字+1
BigDecimal d=new BigDecimal("11");
BigDecimal d1=new BigDecimal("2");
BigDecimal divide_UP = d.divide(d1, RoundingMode.UP);
System.out.println("divide_UP = " + divide_UP);//6

BigDecimal d=new BigDecimal("-11");
BigDecimal d1=new BigDecimal("2");
BigDecimal divide_UP = d.divide(d1, RoundingMode.UP);
System.out.println("divide_UP = " + divide_UP);//-6

3.4.2 DOWN

向零方向舍入的舍入模式，从不对舍弃部分后面的数字+1（截尾处理）

在这里插入图片描述

//DOWN:向零方向舍入的舍入模式，从不对舍弃部分后面的数字+1（截尾处理）
BigDecimal d=new BigDecimal("11");
BigDecimal d1=new BigDecimal("2");
BigDecimal divide_DOWN = d.divide(d1, RoundingMode.DOWN);
System.out.println("divide_DOWN = " + divide_DOWN);//5

BigDecimal d=new BigDecimal("-11");
BigDecimal d1=new BigDecimal("2");
BigDecimal divide_DOWN = d.divide(d1, RoundingMode.DOWN);
System.out.println("divide_DOWN = " + divide_DOWN);//-5

3.4.3 CEILING

向正无限大方向舍入的舍入模式，如果为正数，则类似于UP；如果为负数，则类似于DOWN

在这里插入图片描述

BigDecimal d=new BigDecimal("11");
BigDecimal d1=new BigDecimal("2");
BigDecimal divide = d.divide(d1, RoundingMode.CEILING);
System.out.println(divide);//6

BigDecimal d=new BigDecimal("-11");
BigDecimal d1=new BigDecimal("2");
BigDecimal divide = d.divide(d1, RoundingMode.CEILING);
System.out.println(divide);//-5

3.4.4 FLOOR

向负无限大方向舍入的舍入模式，如果为正数，则类似于DOWN；如果为负数，则类似于UP、

在这里插入图片描述

//FLOOR:向负无限大方向舍入的舍入模式
BigDecimal d=new BigDecimal("11");
BigDecimal d1=new BigDecimal("2");
BigDecimal divide_FLOOR = d.divide(d1, RoundingMode.FLOOR);
System.out.println(divide);//5

BigDecimal d=new BigDecimal("-11");
BigDecimal d1=new BigDecimal("2");
BigDecimal divide = d.divide(d1, RoundingMode.FLOOR);
System.out.println(divide);//-6

3.4.5 HALF_UP

向最接近数字方向舍入的舍入模式，如果与两个相邻数字的距离相等，则向上舍入，如果被舍弃部分>=0.5，则舍入行为同UP，否则和DOWN相同，就是通常使用的四舍五入

//HALF_UP:四舍五入
BigDecimal d=new BigDecimal("11");
//BigDecimal d=new BigDecimal("-11");
BigDecimal d1=new BigDecimal("2");
BigDecimal divide = d.divide(d1, RoundingMode.HALF_UP);
System.out.println(divide);//6

BigDecimal d=new BigDecimal("-11");
BigDecimal d1=new BigDecimal("2");
BigDecimal divide = d.divide(d1, RoundingMode.HALF_UP);
System.out.println(divide);//-6

3.4.6 HALF_DOWN

向最接近数字方向舍入的舍入模式，如果与两个相邻数字的距离相等，则向上舍入，如果被舍弃部分>0.5，则舍入行为同UP，否则和DOWN相同，五舍六入

BigDecimal d=new BigDecimal("11");
BigDecimal d1=new BigDecimal("2");
BigDecimal divide = d.divide(d1, RoundingMode.HALF_DOWN);
System.out.println(divide);//5

BigDecimal d=new BigDecimal("11.2");
BigDecimal d1=new BigDecimal("2");
BigDecimal divide = d.divide(d1, RoundingMode.HALF_DOWN);
System.out.println(divide);//5.6

BigDecimal d=new BigDecimal("-11");
BigDecimal d1=new BigDecimal("2");
BigDecimal divide= d.divide(d1, RoundingMode.HALF_DOWN);
System.out.println(divide);//-5

BigDecimal d=new BigDecimal("-11.2");
BigDecimal d1=new BigDecimal("2");
BigDecimal divide = d.divide(d1, RoundingMode.HALF_DOWN);
System.out.println(divide);//-5.6

3.4.7 HALF_EVEN

向最接近数字方向舍入的舍入模式，如果与两个相邻数字的距离相等，则向相邻的偶数舍入，如果舍弃部分左边的数字为奇数，则舍入行为同HALF_UP，如果为偶数，则舍入行为同HALF_DOWN，也称作“银行家舍入法”。

看舍弃部分左侧数据，奇数采用四舍五入，偶数采用五舍六入。

//HALF_EVEN:看舍弃部分左侧数据，奇数采用四舍五入，偶数采用五舍六入。
BigDecimal d=new BigDecimal("11");
BigDecimal d1=new BigDecimal("2");
BigDecimal divide = d.divide(d1, RoundingMode.HALF_EVEN);
System.out.println(divide);//6

BigDecimal d=new BigDecimal("9.8");
BigDecimal d1=new BigDecimal("2");
BigDecimal divide = d.divide(d1, RoundingMode.HALF_EVEN);
System.out.println(divide);//4.9

BigDecimal d=new BigDecimal("-11");
BigDecimal d1=new BigDecimal("2");
BigDecimal divide = d.divide(d1, RoundingMode.HALF_EVEN);
System.out.println(divide);//-6

3.4.8 UNNECESSARY

如果舍弃值为0，则正常处理，否则报ArithmeticException

//UNNECESSARY:如果舍弃值为0，则正常处理，否则报ArithmeticException
BigDecimal d=new BigDecimal("11");
BigDecimal d1=new BigDecimal("2");
BigDecimal divide = d.divide(d1,RoundingMode.UNNECESSARY);
System.out.println(divide);//报错

BigDecimal d=new BigDecimal("11");
BigDecimal d1=new BigDecimal("2");
BigDecimal divide = d.divide(d1, 1,RoundingMode.UNNECESSARY);
System.out.println(divide);//5.5