【Java学习笔记】50 - Math类,Array类,System类,BigInteger和BigDecimal类

项目代码

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类

一、基本介绍

二、常用方法

Arrays类

一、基本介绍

2.Arrays方法(建议多看看排序方法)

1)基本用法

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

3.其他方法

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

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

3.fill 数组元素的填充

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

二、练习(也可以多看看这个)

System类

一、常用方法

BigInteger和BigDecimal类

一、基本介绍

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

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


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));
        //如果有无限循环小数,就会保留 分子 的精度
    }
}

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

yinhai1114

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值