javaSE(从0开始)day13-优快云博客

BigInteger bg1=new BigInteger("10");

BigInteger bg2=new BigInteger("2");

//加

BigInteger add=bg1.add(bg2);

System.out.println(add);

//减

BigInteger subtract =bg1.subtract(bg2);

System.out.println(subtract);

//乘

BigInteger multiply=bg1.multiply(bg2);

System.out.println(multiply);

//除

BigInteger divide =bg1.divide(bg2);

System.out.println(divide);

2、 BigDecimal：`BigDecimal`和`BigInteger`类似，`BigDecimal`可以表示一个任意大小且精度完全准确的浮点数。

（1）BigDecimal一个精确的浮点数，注意构造方法一定用字符串。（传入字符串精确，浮点数以不精确的浮点数传入不精确）

BigDecimal bd1=new BigDecimal("0.1");

BigDecimal bd2=new BigDecimal("0.2");

System.out.println(bd1.add(bd2)); //0.3

（2）BigDecimal常用方法：

（2.1）scale（）获取小数点后面有几位

（2.2）stripTrailingZeros() 去除末尾的0 注意整形去除后面的0返回为负数表示为整数有几个0，对整形去0 会出现负值（表示为整数有几个0）

（2.3）setScale(1,RoundingMode.HALF_UP);设置小数位数，并设置进位规则四舍五入

（2.4）setScale(1, RoundingMode.DOWN);直接截取

（2.5）加减乘除：加法：add() 减法：subtract() 乘法：multiply() 除法：divide()

（2.6）BigDecimal使用divide进行除法运算，可能存在10进制无法准确表达的小数,出异常 system.out.println("除:"+bd1.divide(bd2)):不推荐推荐使用多参，设置小数位数和截取方式System.out.println("除：" + bd1.divide(bd2, 2, RoundingMode.DOWN));

（2.7）对BigDecimal 做除法的同时求余数

BigDecimal bd1 = new BigDecimal("10.0");

BigDecimal bd2 = new BigDecimal("3.0");

BigDecimal[] bds = bd1.divideAndRemainder(bd2);

System.out.println(Arrays.toString(bds));

        BigDecimal bd1=new BigDecimal("123.45");
        BigDecimal bd2=new BigDecimal("123.45000");
        BigDecimal bd3=new BigDecimal("12345000");

        //scale 获取小数点后面有几位
        System.out.println(bd1.scale());
        System.out.println(bd2.scale());
        System.out.println(bd3.scale());

        //stripTrailingZeros() 去除末尾的0 注意整形去除后面的0返回为负数 表示为整数有几个0
        System.out.println(bd1.stripTrailingZeros());
        System.out.println(bd2.stripTrailingZeros());
        //对整形去0  负值
        System.out.println(bd3.stripTrailingZeros());

        //设置小数位数，并设置进位规则 四舍五入
        BigDecimal upBd=bd2.setScale(1,RoundingMode.HALF_UP);
        System.out.println(upBd);
        //直接截取
        BigDecimal subBd=bd2.setScale(1, RoundingMode.DOWN);
        System.out.println(subBd);

（3）大小内容比较：

BigDecimal bd1 = new BigDecimal("10.0");

BigDecimal bd2 = new BigDecimal("10");

System.out.println("地址相等："+(bd1==bd2)); //false

System.out.println("内容相等："+(bd1.equals(bd2))); //false

System.out.println("大小相等："+(bd1.compareTo(bd2)==0)); //true

二、常用工具类：

1、Math类：

(1)求绝对值:Math.abs();

(2)取最大或最小值：Math.max(100, 99); // 100 Math.min(1.2, 2.3); // 1.2

(3)计算x的y次方:Math.pow(2, 10); // 2的10次方=1024

(4)计算x的开平方:Math.sqrt(2); // 1.414...

(5)计算e的x次方：Math.exp(2); // 7.389...

(6)计算以10为底的对数：Math.log10(100); // 2

(7)三角函数：Math.sin(3.14); // 0.00159...
Math.cos(3.14); // -0.9999...
Math.tan(3.14); // -0.0015...
Math.asin(1.0); // 1.57079...
Math.acos(1.0); // 0.0

(8)Math还提供了几个数学常量：Math.PI; Math.E; // 2.7182818...Math.sin(Math.PI / 6); // sin(π/6) = 0.5

(9)随机数函数:Math.random(); // 0.53907 每次都不一样，生成一个随机数x，x的范围是0 <= x < 1;

2、Random类（伪随机数）： `Random`用来创建伪随机数。所谓伪随机数，是指只要给定一个初始的种子，产生的随机数序列是完全一样的。要生成一个随机数，可以使用`nextInt()` `nextLong()`、`nextFloat()`、`nextDouble()`：

（1）获取随机数对byte[]数组填充：

byte[] bytes=new byte[10];

r1.nextBytes(bytes);// 获取一些随机数对byte数组进行填充 System.out.println(Arrays.toString(bytes));

（2）种子相同，随机数类相同伪随机：

package com.yuan.randomClass;

import java.util.Random;

public class Demo02 {
    public static void main(String[] args) {
        //种子相同，随机数类相同伪随机
        Random r1=new Random(123534654);
        for (int i = 0; i <20 ; i++) {
            System.out.print(r1.nextInt(10)+" ");
        }
        System.out.println("===============");
        Random r2=new Random(123534654);
        for (int i = 0; i <20 ; i++) {
            System.out.print(r1.nextInt(10)+" ");
        }
    }
}

3、SecureRandom类：有伪随机数，就有真随机数。实际上真正的真随机数只能通过量子力学原理来获取，而我们想要的是一个不可预测的安全的随机数，`SecureRandom`就是用来创建安全的随机数的：

安全原因：SecureRandom无法指定种子，它使用RNG（random number generator）算法。JDK的SecureRandom实际上有多种不同的底层实现，有的使用安全随机种子加上伪随机数算法来产生安全的随机数，有的使用真正的随机数生成器。实际使用的时候，可以优先获取高强度的安全随机数生成器，如果没有提供，再使用普通等级的安全随机数生成器：

package com.yuan.randomClass;

import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Arrays;

public class Demo03 {
    public static void main(String[] args) {
        //真随机数  安全 种子有多种随机算法实现 不可破解
        SecureRandom sr;
        try {
            //安全等级更高的随机数获取
            sr=SecureRandom.getInstanceStrong();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
            sr =new SecureRandom();
        }
        System.out.println("随机的整数："+sr.nextInt()); //整形范围内
        System.out.println("随机的整数："+sr.nextInt(10)); //0-指定范围内
        System.out.println("随机的Boolean："+sr.nextBoolean());
        System.out.println("随机小数"+sr.nextDouble());
        byte[] bytes=new byte[10];
        sr.nextBytes(bytes);// 获取一些随机数对byte数组进行填充
        System.out.println(Arrays.toString(bytes));
    }
}

三、枚举：为了让编译器能自动检查某个值在枚举的集合内，并且，不同用途的枚举需要不同的类型来标记，不能混用，我们可以使用`enum`来定义枚举类：

1、枚举的好处：`enum`常量本身带有类型信息，即`Weekday.SUN`类型是`Weekday`，编译器会自动检查出类型错误。其次，不可能引用到非枚举的值，因为无法通过编译。最后，不同类型的枚举不能互相比较或者赋值，因为类型不符。

2、枚举的定义：使用enum修饰类，使用public staticfinal修饰（可省略不写）常量

public class Weekday {
    public static final int SUN = 0;
    public static final int MON = 1;
    public static final int TUE = 2;
    public static final int WED = 3;
    public static final int THU = 4;
    public static final int FRI = 5;
    public static final int SAT = 6;
}

3、枚举的比较：

if (day == Weekday.FRI) { // ok!
}

if (day.equals(Weekday.SUN)) { // ok, but more code!
}

4、枚举的类型：

通过enum定义的枚举类，和其他的class有什么区别？答案是没有任何区别。enum定义的类型就是class，只不过它有以下几个特点：

定义的enum类型总是继承自java.lang.Enum，且无法被子类继承；
只能定义出enum的实例，而无法通过new操作符创建enum的实例；
定义的每个实例都是引用类型的唯一实例；
可以将enum类型用于switch语句。

例如，我们定义的Color枚举类：

public enum Color {
RED, GREEN, BLUE;
}

5、enum枚举的方法：

（1）`name()`方法：作用：返回常量名，

作用：返回常量名，

（2） `ordinal()`方法：作用：返回定义的常量的顺序，从0开始计数，

int n = Weekday.MON.ordinal(); // 1

（3）定义`private`的构造方法：如果不小心修改了枚举的顺序，编译器是无法检查出这种逻辑错误的。要编写健壮的代码，就不要依靠`ordinal()`的返回值。因为`enum`本身是`class`，所以我们可以定义`private`的构造方法，并且，给每个枚举常量添加字段，这样就无需担心顺序的变化，新增枚举常量时，也需要指定一个`int`值。

public class Main {
    public static void main(String[] args) {
        Weekday day = Weekday.SUN;
        if (day.dayValue == 6 || day.dayValue == 0) {
            System.out.println("Work at home!");
        } else {
            System.out.println("Work at office!");
        }
    }
}

enum Weekday {
    MON(1), TUE(2), WED(3), THU(4), FRI(5), SAT(6), SUN(0);

    public final int dayValue;

    private Weekday(int dayValue) {
        this.dayValue = dayValue;
    }
}

（4）`toString()`方法：作用：默认情况下，对枚举常量调用`toString()`会返回和`name()`一样的字符串。但是，`toString()`可以被覆写，而`name()`则不行。我们可以给`Weekday`添加`toString()`方法进行重写，目的是在输出时更有可读性。

public class Main {
    public static void main(String[] args) {
        Weekday day = Weekday.SUN;
        if (day.dayValue == 6 || day.dayValue == 0) {
            System.out.println("Today is " + day + ". Work at home!");
        } else {
            System.out.println("Today is " + day + ". Work at office!");
        }
    }
}

enum Weekday {
    MON(1, "星期一"), TUE(2, "星期二"), WED(3, "星期三"), THU(4, "星期四"), FRI(5, "星期五"), SAT(6, "星期六"), SUN(0, "星期日");

    public final int dayValue;
    private final String chinese;

    private Weekday(int dayValue, String chinese) {
        this.dayValue = dayValue;
        this.chinese = chinese;
    }

    @Override
    public String toString() {
        return this.chinese;
    }
}

javaSE(从0开始)day13

一、javaAPI常用类：

1、BigInteger：java.math.BigInteger就是用来表示任意大小的整数。BigInteger内部用一个int[]数组来模拟一个非常大的整数

（1）BigInteger的加法：add()

（2）BigInteger的减法：subtract()

（3）BigInteger的乘法：multiply()

（4）BigInteger的除法：divide()

2、 BigDecimal：BigDecimal和BigInteger类似，BigDecimal可以表示一个任意大小且精度完全准确的浮点数。

（1）BigDecimal一个精确的浮点数，注意构造方法一定用字符串。（传入字符串精确 ，浮点数以不精确的浮点数传入不精确）