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

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