0056 Math、Arrays、System、BigInteger和BigDecimal类

 

 

 

 

 

/*
    Math类
    包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数

    常见方法（静态方法）
    abs             //绝对值
    pow             //求幂
    ceil            //向上取整
    floor           //向下取整
    round           //四舍五入
    sqrt            //求开方
    random          //求随机数  返回0-1之间的一个随机小数 [0,1)
    max             //求两个数最大值
    min             //求两个数最小值
 */
public class Math_ {
    public static void main(String[] args) {
        //1.abs 绝对值
        int abs = Math.abs(-9);
        System.out.println(abs);//9

        //2.pow 求幂
        double pow = Math.pow(2, 4);//2 的 4 次方
        System.out.println(pow);//16.0

        //3.ceil 向上取整,返回>=该参数的最小整数
        double ceil = Math.ceil(-3.6);
        System.out.println(ceil);//-3.0

        //4.floor 向下取整，返回<=该参数的最大整数
        double floor = Math.floor(4.001);
        System.out.println(floor);//4.0

        // 5.round 四舍五入
        long round = Math.round(5.51);
        System.out.println(round);//6

        // 6.sqrt 求开方
        double sqrt = Math.sqrt(9.0);
        System.out.println(sqrt);//3.0

        //7.random 求随机数
        System.out.println(Math.random());//[0,1)之间的小数
        //获取[a,b]之间的随机整数
        //(int)(Math.random() * (b-a)) 返回 [0,b-a)
        //(int)(Math.random() * (b-a+1)) 返回 [0,b-a]
        //(int)(a + Math.random() * (b-a+1)) 返回 [a,a+b-a]即[a,b]

        //如a=2,b=7
        //2 + Math.random()*6 返回[2,8)的小数
        //(int)2 + Math.random()*6 返回 [2,7]
        System.out.println((int)2 + Math.random()*6);

        //max , min 返回最大值和最小值
        int min = Math.min(1, 9);
        int max = Math.max(45, 99);
        System.out.println("min=" + min);//1
        System.out.println("max=" + max);//99

    }
}

/*
    Arrays类
    Arrays包含了一系列静态方法，用于管理或操作数组（如排序和搜索）

    1.toString               //返回数组的字符串形式
    2.sort                   //排序
    3.binarySearch           //通过二分法搜索进行查找，要求必须排好序
    4.copyOf                 //数组元素的复制
    5.fill                   //数组元素的填充
    6.equals                 //比较两个数组元素内容是否一致
    7.asList                 //将一组的值，转换成list
 */
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
public class Arrays_ {
    public static void main(String[] args) {
        Integer[] integers = {11,22,33,44};
        //toString 显示数组
        System.out.println(Arrays.toString(integers));
        //sort
        Integer[] arr = {1,-1,3,5,6,-3,7};
        Arrays.sort(arr);//因为数组是引用类型，所以排序后会直接影响到实参arr
        System.out.println(Arrays.toString(arr));//[-3, -1, 1, 3, 5, 6, 7]
        //sort也可通过传入一个接口Comparator实现定制排序,体现 接口编程+动态绑定+匿名内部类
        Arrays.sort(arr, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                Integer i1 = (Integer) o1;
                Integer i2 = (Integer) o2;
                return i2 - i1;
            }
        });
        System.out.println(Arrays.toString(arr));//[7, 6, 5, 3, 1, -1, -3]

        //binarySearch，如果不存在，return -(low + 1)
        Integer[] arr2 = {0,1,2,3,4,8,9,10};
        int index = Arrays.binarySearch(arr2,8);
        System.out.println(index);//5

        //copyOf  拷贝长度<0，抛出异常
        Integer[] newArr = Arrays.copyOf(arr2,arr2.length);//从arr2中，拷贝arr2.length个元素到newArr
        System.out.println(Arrays.toString(newArr));//[0, 1, 2, 3, 4, 8, 9, 10]

        //fill
        Integer[] num = new Integer[]{1,2,3,4};
        Arrays.fill(num,5);//用5填充所有元素
        System.out.println(Arrays.toString(num));//[5, 5, 5, 5]

        //equals
        System.out.println(Arrays.equals(arr,arr2));//false

        //asList 将（）转成一个List集合
        List asList = Arrays.asList(1,2,3,4,5);
        System.out.println(asList);//[1, 2, 3, 4, 5]
        System.out.println(asList.getClass());//运行类型java.util.Arrays$ArrayList，是Arrays类的静态内部类
    }
}

/*
    System类常见方法
    1.exit                  //退出当前程序
    2.arraycopy             //复制数组元素，适合底层调用，一般使用Arrays.copyOf
    3.currentTimeMillis     //返回当前时间距离1970-1-1的毫秒数
    4.gc                    //运行垃圾回收机制

    大数处理
    1.BigInteger            //适合保存比较大的整型
    2.BigDecimal            //适合保存精度更高的浮点型（小数）

 */
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Arrays;
public class System_ {
    public static void main(String[] args) {
        //exit
        System.out.println("开始执行");
       // System.exit(0);//0表示一个状态 , 正常的状态
        System.out.println("继续执行程序...");

        //arraycopy
        int[] arr1 = {1,2,3};
        int[] arr2 = new int[4];
        System.arraycopy(arr1, 0, arr2, 1, arr1.length);
        //源数组 arr1, 从索引0开始拷贝，拷贝到arr2，从索引1开始，拷贝arr.length个
        System.out.println(Arrays.toString(arr2));//[0, 1, 2, 3]

        //currentTimeMillis
        System.out.println(System.currentTimeMillis());

        //BigInteger
        BigInteger bigInteger1 = new BigInteger("999999999999999999999999");
        System.out.println(bigInteger1);
        //进行加减乘除时要使用对应方法，不能直接+，-，*，/
        BigInteger bigInteger2 = new BigInteger("2");

        System.out.println(bigInteger1.add(bigInteger2));//加
        System.out.println(bigInteger1.subtract(bigInteger2));//减
        System.out.println(bigInteger1.multiply(bigInteger2));//乘
        System.out.println(bigInteger1.divide(bigInteger2));//除

        //BigDecimal
        BigDecimal bigDecimal1 = new BigDecimal("1.9999999999999999999999999999");
        System.out.println(bigDecimal1);
        进行加减乘除时要使用对应方法，不能直接+，-，*，/
        BigDecimal bigDecimal2 = new BigDecimal("6.6");

        System.out.println(bigDecimal1.add(bigDecimal2));//加
        System.out.println(bigDecimal1.subtract(bigDecimal2));//减
        System.out.println(bigDecimal1.multiply(bigDecimal2));//乘
       // System.out.println(bigDecimal1.divide(bigDecimal2));//除，可能抛出异常（无限循环小数）
        //解决异常：在调用divide方法时，指定精度
        System.out.println(bigDecimal1.divide(bigDecimal2,BigDecimal.ROUND_CEILING));//保留到被除数精度

    }
}