当前位置：首页 > article >正文

【JAVA学习笔记】50 - Math类，Array类，System类，BigInteger和BigDecimal类

article 2024/11/15 13:42:19

项目代码

https://github.com/yinhai1114/Java_Learning_Code/tree/main/IDEA_Chapter13/src/com/yinhai/wrapper_/math_

https://github.com/yinhai1114/Java_Learning_Code/tree/main/IDEA_Chapter13/src/com/yinhai/wrapper_/array_

https://github.com/yinhai1114/Java_Learning_Code/tree/main/IDEA_Chapter13/src/com/yinhai/wrapper_/system_

https://github.com/yinhai1114/Java_Learning_Code/tree/main/IDEA_Chapter13/src/com/yinhai/wrapper_/bignum_

Math类

一、基本介绍

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

二、常用方法

public class MathMethod {
    public static void main(String[] args) {
        //看看Math常用的方法(静态方法)
        //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
        //3.ceil 向上取整,返回>=该参数的最大整数(转成double);
        double ceil = Math.ceil(3.9);
        System.out.println(ceil);//4.0
        //4.floor 向下取整，返回<=该参数的最小整数(转成double)
        double floor = Math.floor(4.001);
        System.out.println(floor);//4.0
        //5.round 四舍五入  Math.floor(该参数+0.5)
        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 求随机数
        //  random 返回的是 0 <= x < 1 之间的一个随机小数
        // 思考：请写出获取 a-b之间的一个随机整数,a,b均为整数 ，比如 a = 2, b=7
        //  即返回一个数 x  2 <= x <= 7
        // 老韩解读 Math.random() * (b-a) 返回的就是 0  <= 数 <= b-a
        // (1) (int)(a) <= x <= (int)(a + Math.random() * (b-a +1) )
        // (2) 使用具体的数给小伙伴介绍 a = 2  b = 7
        //  (int)(a + Math.random() * (b-a +1) ) = (int)( 2 + Math.random()*6)
        //  Math.random()*6 返回的是 0 <= x < 6 小数
        //  2 + Math.random()*6 返回的就是 2<= x < 8 小数
        //  (int)(2 + Math.random()*6) = 2 <= x <= 7
        // (3) 公式就是  (int)(a + Math.random() * (b-a +1) )
        for(int i = 0; i < 100; i++) {
            System.out.println((int)(2 +  Math.random() * (7 - 2 + 1)));
        }

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

    }
}

Arrays类

一、基本介绍

Arrays里面包含了一系列静态方法，用于管理或操作数组(比如排序和搜索)。

1.toString返回数组的字符串形式Arrays.toString(arr)

2.sort排序(自然排序和定制排序)Integer arr[ = {1,-1, 7. 0, 89};

3. binarySearch通过二分搜索法进行查找，要求必须排好序int index = Arrays.binarySearch(arr, 3);

2.Arrays方法（建议多看看排序方法）

1）基本用法

public class ArraysMethod01 {
    public static void main(String[] args) {

        Integer[] integers = {1, 20, 90};
        //遍历数组
        for (int i = 0; i < integers.length; i++) {
            System.out.println(integers[i]);
        }
        //直接使用Arrays.toString方法，显示数组
        System.out.println(Arrays.toString(integers));

        //演示 sort方法的使用

        Integer arr[] = {1, -1, 7, 0, 89};
        //进行排序
        //1. 可以直接使用冒泡排序 , 也可以直接使用Arrays提供的sort方法排序
        //2. 因为数组是引用类型，所以通过sort排序后，会直接影响到 实参 arr
        //Arrays.sort(arr); // 默认排序方法
        System.out.println("===排序后===");
        System.out.println(Arrays.toString(arr));

        //3. sort重载的，也可以通过传入一个接口 Comparator 实现定制排序
        //4. 调用 定制排序 时，传入两个参数 (1) 排序的数组 arr
        //   (2) 实现了Comparator接口的匿名内部类 , 要求实现  compare方法
        Arrays.sort(arr, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {//5. 这里体现了接口编程的方式 , 看看源码，就明白
                Integer i1 = (Integer) o1;
                Integer i2 = (Integer) o2;
                return i2 - i1;
            }
        });

        //   源码分析
        //(1) Arrays.sort(arr, new Comparator()
        //(2) 最终到 TimSort类的
        // private static <T> void binarySort(T[] a, int lo, int hi, int start,Comparator<? super T> c)()
        //(3) 执行到 binarySort方法的代码, 会根据动态绑定机制 c.compare()执行我们传入的匿名内部类的 compare ()
        //     while (left < right) {
        //                int mid = (left + right) >>> 1;
        //                if (c.compare(pivot, a[mid]) < 0)
        //                    right = mid;
        //                else
        //                    left = mid + 1;
        //            }
        //(4) new Comparator() {
        //            @Override
        //            public int compare(Object o1, Object o2) {
        //                Integer i1 = (Integer) o1;
        //                Integer i2 = (Integer) o2;
        //                return i2 - i1;
        //            }
        //        }
        //(5) public int compare(Object o1, Object o2) 返回的值>0 还是 <0
        //    会影响整个排序结果, 这就充分体现了 接口编程+动态绑定+匿名内部类的综合使用将来的底层框架和源码的使用方式，会非常常见


        System.out.println("===排序后===");
        System.out.println(Arrays.toString(arr));//


    }
}

2）手写模拟Arrays定制排序的处理

public class ArraysSortCustom {
    public static void main(String[] args) {

        int[] arr = {1, -1, 8, 0, 20};
        // bubble01(arr);
        // System.out.println("==排序后的情况==");
        // System.out.println(Arrays.toString(arr));

        bubble02(arr, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {//arr[j] arr[j+1]传入这里
                int i1 = (Integer) o1;//拆箱
                int i2 = (Integer) o2;//拆箱
                return i2 - i1;// 判断我们的逻辑是小到大(i1 - i2 > 0)执行排序还是大到小(i2 - i1 > 0)执行排序;
            }
        });

        System.out.println("==定制排序后的情况==");
        System.out.println(Arrays.toString(arr));

    }

    //1.使用冒泡完成排序
    public static void bubble01(int[] arr) {
        int temp = 0;
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                //从小到大
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

    //结合冒泡 + 定制
    public static void bubble02(int[] arr, Comparator c) {
        int temp = 0;
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                //数组排序由 c.compare(arr[j], arr[j + 1])返回的值决定
                if (c.compare(arr[j], arr[j + 1]) > 0) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
}

3.其他方法

1.binarySearch 通过二分搜索法进行查找，要求必须排好

//1. 使用 binarySearch 二叉查找
//2. 要求该数组是有序的. 如果该数组是无序的，不能使用binarySearch
int index = Arrays.binarySearch(arr, 167);
System.out.println("index=" + index);
//3. 如果数组中不存在该元素，就返回 return -(low + 1); // key not found.
//low指的是搜索的值应该在的值，比如167就是 -(5 + 1),如果是3就是-(2 + 1)

2.copyOf 数组元素的复制拷贝

//1. 从 arr 数组中，拷贝 arr.length个元素到 newArr数组中
//2. 如果拷贝的长度 > arr.length 就在新数组的后面增加 null
Integer[] newArr = Arrays.copyOf(arr, arr.length);
System.out.println("==拷贝执行完毕后==");
System.out.println(Arrays.toString(newArr));
//3. 如果拷贝长度 < 0 就抛出异常NegativeArraySizeException
//4. 该方法的底层使用的是 System.arraycopy()

3.fill 数组元素的填充

Integer[] num = new Integer[]{9,3,2};
//1. 使用 99 去填充 num数组，可以理解成是替换原理的元素
Arrays.fill(num, 99);
System.out.println("==num数组填充后==");
System.out.println(Arrays.toString(num));

//equals 比较两个数组元素内容是否完全一致
Integer[] arr2 = {1, 2, 90, 123};
//1. 如果arr 和 arr2 数组的元素一样，则方法true;
//2. 如果不是完全一样，就返回 false
boolean equals = Arrays.equals(arr, arr2);
System.out.println("equals=" + equals);

4.asList 将一组值，转换成list

//1. asList方法，会将 (2,3,4,5,6,1)数据转成一个List集合
List asList = Arrays.asList(2,3,4,5,6,1);
System.out.println("asList=" + asList);
System.out.println("asList的运行类型" + asList.getClass());
//2. 返回的 asList 编译类型 List(接口)
//3. asList 运行类型 java.util.Arrays#ArrayList, 是Arrays类的
// 静态内部类 private static class ArrayList<E> extends AbstractList<E>
// implements RandomAccess, java.io.Serializable
}

public class ArraysMethod02 {
    public static void main(String[] args) {
        Integer[] arr = {1, 2, 90, 123, 160};
        // binarySearch 通过二分搜索法进行查找，要求必须排好
        //1. 使用 binarySearch 二叉查找
        //2. 要求该数组是有序的. 如果该数组是无序的，不能使用binarySearch
        int index = Arrays.binarySearch(arr, 167);
        System.out.println("index=" + index);
        //3. 如果数组中不存在该元素，就返回 return -(low + 1);  // key not found.
        //low指的是搜索的值应该在的值，比如167就是 -(5 + 1),如果是3就是-(2 + 1)

        //copyOf 数组元素的复制拷贝
        //1. 从 arr 数组中，拷贝 arr.length个元素到 newArr数组中
        //2. 如果拷贝的长度 > arr.length 就在新数组的后面 增加 null
        Integer[] newArr = Arrays.copyOf(arr, arr.length);
        System.out.println("==拷贝执行完毕后==");
        System.out.println(Arrays.toString(newArr));
        //3. 如果拷贝长度 < 0 就抛出异常NegativeArraySizeException
        //4. 该方法的底层使用的是 System.arraycopy()


        //ill 数组元素的填充
        Integer[] num = new Integer[]{9,3,2};
        //1. 使用 99 去填充 num数组，可以理解成是替换原理的元素
        Arrays.fill(num, 99);
        System.out.println("==num数组填充后==");
        System.out.println(Arrays.toString(num));

        //equals 比较两个数组元素内容是否完全一致
        Integer[] arr2 = {1, 2, 90, 123};
        //1. 如果arr 和 arr2 数组的元素一样，则方法true;
        //2. 如果不是完全一样，就返回 false
        boolean equals = Arrays.equals(arr, arr2);
        System.out.println("equals=" + equals);

        //asList 将一组值，转换成list
        //1. asList方法，会将 (2,3,4,5,6,1)数据转成一个List集合
        List asList = Arrays.asList(2,3,4,5,6,1);
        System.out.println("asList=" + asList);
        System.out.println("asList的运行类型" + asList.getClass());
        //2. 返回的 asList 编译类型 List(接口)
        //3. asList 运行类型 java.util.Arrays#ArrayList, 是Arrays类的
        //   静态内部类 private static class ArrayList<E> extends AbstractList<E>
        //              implements RandomAccess, java.io.Serializable
    }
}

二、练习（也可以多看看这个）

public class ArraysExercise {
    public static void main(String[] args) {
        /*
        案例：自定义Book类，里面包含name和price，按price排序(从大到小)。
        要求使用两种方式排序 , 有一个 Book[] books = 4本书对象.

        使用前面学习过的传递 实现Comparator接口匿名内部类，也称为定制排序。
        [同学们完成这个即可 10min  ],
        可以按照 price (1)从大到小 (2)从小到大 (3) 按照书名长度从大到小

         */

        Book[] books = new Book[4];
        books[0] = new Book("红楼梦", 100);
        books[1] = new Book("金瓶梅新", 90);
        books[2] = new Book("青年文摘20年", 5);
        books[3] = new Book("java从入门到放弃~", 300);
        arrCustom(books, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
               Book book1 = (Book)o1;
               Book book2 = (Book)o2;
               int temp =(int)(book1.getPrice() - book2.getPrice());
                return temp;
            }
        });
        System.out.println(Arrays.toString(books));
        arrCustom(books, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                Book book1 = (Book)o1;
                Book book2 = (Book)o2;
                int temp =(int)(book1.getPrice() - book2.getPrice());
                return -temp;
            }
        });
        System.out.println(Arrays.toString(books));
        arrMintoMax(books);
        System.out.println(Arrays.toString(books));
        arrMaxtoMin(books);
        System.out.println(Arrays.toString(books));
        arrNameLength(books);
        System.out.println(Arrays.toString(books));
    }
    public static void arrMaxtoMin(Book[] books){//记得是引用赋值，改变这个books main方法内的也会改变
        //price从大到小
        Book temp;
        for (int i = 0; i < books.length - 1; i++) {
            for (int j = 0; j <books.length - i - 1; j++) {
                if(books[j].getPrice() < books[j + 1].getPrice()){
                    temp = books[j];
                    books[j] = books[j + 1];
                    books[j + 1] = temp;
                }
            }
        }
    }
    public static void arrMintoMax(Book[] books){
        //price从小到大
        Book temp;
        for (int i = 0; i < books.length - 1; i++) {
            for (int j = 0; j < books.length - i - 1; j++) {
                if(books[j].getPrice() > books[j + 1].getPrice()){
                    temp = books[j];
                    books[j] = books[j + 1];
                    books[j + 1] = temp;
                }
            }
        }
    }
    public static void arrCustom(Book[] books,Comparator c){
        //定制
        Book temp;
        for (int i = 0; i < books.length - 1; i++) {
            for (int j = 0; j < books.length - i - 1; j++) {
                if(c.compare(books[j],books[j + 1]) > 0){
                    temp = books[j];
                    books[j] = books[j + 1];
                    books[j + 1] = temp;
                }
            }
        }
    }
    public static void arrNameLength(Book[] books){
        //书名长度从大到小
        Book temp;
        for (int i = 0; i < books.length - 1; i++) {
            for (int j = 0; j < books.length - i - 1; j++) {
                if(books[j].getName().length() < books[j + 1].getName().length()){
                    temp = books[j];
                    books[j] = books[j + 1];
                    books[j + 1] = temp;
                }
            }
        }
    }
}

class Book {
    private String name;
    private double price;

    public Book(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

System类

一、常用方法

1) exit退出当前程序

2) arraycopy :复制数组元素，比较适合底层调用，一般使用Arrays.copyOf完成复制数组

int[] src={1,2,3};

int[] dest = new int[3];

System.arraycopy(src, 0, dest, 0, 3);

3) currentTimeMillens:返回当前时间距离1970-1-1的毫秒数

4) gc:运行垃圾回收机制System.gc;

public class System_ {
    public static void main(String[] args) {

        //exit 退出当前程序

       System.out.println("ok1");

        //1. exit(0) 表示程序退出
        //2. 0 表示一个状态
       // System.exit(0);
       System.out.println("ok2");

        //arraycopy ：复制数组元素，比较适合底层调用，
        // 一般使用Arrays.copyOf完成复制数组
        int[] src={1,2,3};
        int[] dest = new int[3];// dest 当前是 {0,0,0}
        //1. 主要是搞清楚这五个参数的含义
        //2.   * @param      src      the source array. src为源数组

        //     * @param      srcPos   starting position in the source array.
        //     srcPos： 从源数组的哪个索引位置开始拷贝

        //     * @param      dest     the destination array.
        //     dest : 目标数组，即把源数组的数据拷贝到哪个数组

        //     * @param      destPos  starting position in the destination data.
        //     destPos: 把源数组的数据拷贝到 目标数组的哪个索引

        //     * @param      length   the number of array elements to be copied.
        //     length: 从源数组拷贝多少个数据到目标数组
        System.arraycopy(src, 0, dest, 0, src.length);
        // int[] src={1,2,3};
        System.out.println("dest=" + Arrays.toString(dest));//[1, 2, 3]

        //currentTimeMillens:返回当前时间距离1970-1-1 的毫秒数
        System.out.println(System.currentTimeMillis());
    }
}

BigInteger和BigDecimal类

一、基本介绍

1. BigInteger适合保存比较大的整型

1. 在对 BigInteger 进行加减乘除的时候，需要使用对应的方法，不能直接进行 + - * /
2. 可以创建一个要操作的 BigInteger 然后进行相应操作

public class BigInteger_ {

    public static void main(String[] args) {

        //当我们编程中，需要处理很大的整数，long 不够用
        // long l = 23788888899999999999999999999l;
        // System.out.println("l=" + l);
        //可以使用BigInteger的类来搞定
        BigInteger bigInteger = new BigInteger("23788888899999999999999999999");//用字符串
        BigInteger bigInteger2 = new BigInteger("10099999999999999999999999999999999999999999999999999999999999999999999999999999999");
        //本质上是对字符串进行操作
        System.out.println(bigInteger);
        System.out.println(bigInteger);
        //1. 在对 BigInteger 进行加减乘除的时候，需要使用对应的方法，不能直接进行 + - * /
        //System.out.println(bigInteger + 1);//报错
        //2. 可以创建一个 要操作的 BigInteger 然后进行相应操作
        BigInteger add = bigInteger.add(bigInteger2);
        System.out.println(add);//
        BigInteger subtract = bigInteger.subtract(bigInteger2);
        System.out.println(subtract);//减
        BigInteger multiply = bigInteger.multiply(bigInteger2);
        System.out.println(multiply);//乘
        BigInteger divide = bigInteger.divide(bigInteger2);
        System.out.println(divide);//除
    }
}

2. BigDecimal适合保存精度更高的浮点型(小数)

1. 如果对 BigDecimal进行运算，比如加减乘除，需要使用对应的方法
2. 创建一个需要操作的 BigDecimal 然后调用相应的方法即可
3.System.out.println(bigDecimal.divide(bigDecimal2));//可能抛出异常ArithmeticException无限循环小数，会抛出异常
4.在调用divide 方法时，指定精度即可. BigDecimal.ROUND_CEILING
5.如果有无限循环小数，就会保留分子的精度

public class BigDecimal_ {
    public static void main(String[] args) {
        //当我们需要保存一个精度很高的数时，double 不够用
        //可以是 BigDecimal
        //double d = 1999.11111111111999999999999977788d;
        //System.out.println(d);
        BigDecimal bigDecimal = new BigDecimal("1999.11");
        BigDecimal bigDecimal2 = new BigDecimal("3");
        System.out.println(bigDecimal);

        //1. 如果对 BigDecimal进行运算，比如加减乘除，需要使用对应的方法
        //2. 创建一个需要操作的 BigDecimal 然后调用相应的方法即可
        System.out.println(bigDecimal.add(bigDecimal2));//加
        System.out.println(bigDecimal.subtract(bigDecimal2));//减
        System.out.println(bigDecimal.multiply(bigDecimal2));//乘
        //System.out.println(bigDecimal.divide(bigDecimal2));//可能抛出异常ArithmeticException
        //可能是无限循环小数，会抛出异常
        //在调用divide 方法时，指定精度即可. BigDecimal.ROUND_CEILING
        System.out.println(bigDecimal.divide(bigDecimal2, BigDecimal.ROUND_CEILING));
        //如果有无限循环小数，就会保留 分子 的精度
    }
}

查看全文

http://www.kler.cn/a/107795.html