Math 类、Arrays 类、System 类

Math类

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

如以下代码：

public class Test {
    public static void main(String[] args) {
        // abs 绝对值
        int abs = Math.abs(-1);
        System.out.println(abs); // 1

        // pow 求幂（返回类型为 double） 以下求 2 的 4 次方
        double pow = Math.pow(2, 4);
        System.out.println(pow); // 16.0

        // ceil 向上取整，返回 >= 参数的最小整数（返回类型为 double）
        double ceil = Math.ceil(-3.002);
        System.out.println(ceil); //-3.0

        // floor 向下取整，返回 <= 参数的最大整数（返回类型为 double）
        double floor = Math.floor(-4.999); 
        System.out.println(floor); // -5.0

        // round 四舍五入 Math.floor(参数 + 0.5)
        long round = Math.round(-5.001);
        System.out.println(round); // -5.0

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

        // min/max 返回参数里的最小/最大值
        System.out.println(Math.max(10, 30)); // 30
        System.out.println(Math.min(20, 10)); // 10

        // random 求随机数 该函数返回 [0, 1) 之间的一个随机小数
        // 返回 a ~ b 之间的一个随机数，比如 a = 2, b = 7
        /*
         * 从极端情况考虑：
         * 假如 Math.random() 取到 0 和 Math.random() 取到 1 （实际上取不到1）
         * 所以有： int(2 + Math.random() * (b - a + 1))
         * 当 Math.random() 取到 0 时，上述公式的取值为 2
         * 当 Math.random() 取到 1 时，上述公式的取值为 8 
         * 但因为实际上取不到 1 ，所以最后的值会是七点几的小数，再转为 int 就只有 7 了
         * 所以最终的公式是：
         * (int)(a + Math.random() * (b - a + 1))  
         */
        int a = 2;
        int b = 7;
        int res = (int)(a + Math.random() * (b - a + 1)); 
        System.out.println(res);
    }
}

Arrays 类

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

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        // toString 方法，把数组元素转换成字符串
        int arr1[] = {2, 5, 6};
        System.out.println(Arrays.toString(arr1));

        // sort 方法，排序
        int arr2[] = {1, -2, 5, 7, 4, 10};
        // 因为数组是引用类型，所以通过 sort 方法排序后，会直接影响到数组本身
        Arrays.sort(arr2); // 默认升序排序
        System.out.println(Arrays.toString(arr2));

        Integer arr3[] = {1, -2, 5, 7, 4, 10};
        /**
         * sort 是重载的，可以通过传入一个接口 Comparator 实现自定义排序
         * 自定义排序时，传入两个参数：待排序的数组和实现 Comparator 接口的匿名内部类
         * 该接口要求实现 compare 方法，体现了接口编程的方式，具体可以通过debug看源码
         */
        Arrays.sort(arr3, new Comparator() {
            public int compare(Object o1, Object o2){
                Integer i1 = (Integer)o1;
                Integer i2 = (Integer)o2;
                
                // return i1 - i2; // 升序排序
                return i2 - i1; // 降序排序
            }
        });
        System.out.println(Arrays.toString(arr3));

        int arr4[] = {1, -2, 5, 7, 4, 10};
        // 以冒泡排序为例，采用 Comparator 接口实现自定义排序
        bubble(arr4, new Comparator() {
            @Override
            public int compare(Object o1, Object o2){
                int i1 = (Integer)o1;
                int i2 = (Integer)o2;

                // 调用 compare 方法返回一个数，用于判断排序的标准（升序还是降序）
                return i1 - i2;
            }
        });
        System.out.println(Arrays.toString(arr4));

        // binarySearch 方法，通过二分搜索法进行查找，要求必须排好序
        Integer arr5[] = {1, 2, 12, 14, 15, 47, 99}; //  要求数组是有序的（可升序或者降序）
        // 找到返回元素的索引，
        // 通过看源码，如果找不到元素，则返回 -(low + 1)
        // low 表示所查找的元素如果在数组中时，它的索引
        // 比如查找 3, 3不存在，如果3在数组中，则它的索引是2，即 low = 2，所以会返回-3 
        int index = Arrays.binarySearch(arr5, 14);
        System.out.println(index); // 3
        System.out.println(Arrays.binarySearch(arr5, 3)); // -3

        // copyOf 数组元素的复制
        // 从 arr5 数组中，复制 arr5.length 个元素放在 arr6 中
        // 如果第二个参数大于 arr5 数组的长度，则多出的部分会用 null 填充
        // 如果第二个参数小于0，则会抛出异常
        Integer arr6[] = Arrays.copyOf(arr5, arr5.length);
        System.out.println(Arrays.toString(arr6));

        // fill 数组元素的填充
        Integer arr7[] = {1, 2, 3};
        // 用 99 替换掉数组中的所有元素
        Arrays.fill(arr7, 99);
        System.out.println(Arrays.toString(arr7)); // [99, 99, 99]

        // equals 比较两个数组元素内容是否一致
        Integer arr8[] = {99, 99, 99};
        System.out.println(Arrays.equals(arr7, arr8)); // true

        // asList 将一组值，转换成 List , 即将数组转换成集合
        List asList = Arrays.asList(arr8);
        System.out.println(asList); // [99, 99, 99]
        // 输出：asList 的运行类型：class java.util.Arrays$ArrayList
        System.out.println("asList 的运行类型：" + asList.getClass());
    }


    // 以冒泡排序为例，采用 Comparator 接口实现自定义排序
    public static void bubble(int[] arr, Comparator c) {
        int t = 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]){ // 按升序还是降序由此语句判断
                // 现在采用 Comparator 接口可以实现自定义排序，即由用户决定是升序还是降序
                // 而不是写死
                // c.compare(arr[j], arr[j+1]) 方法的返回值决定了排序是升序还是降序
                if(c.compare(arr[j], arr[j+1]) > 0){
                    t = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = t;
                }
            }
        }
    } 
}

System 类

public class Test {
    public static void main(String[] args) {
        // exit 退出当前程序
        // exit() 中的参数表示程序的状态，0表示正常状态
        // System.exit(0);

        // arraycopy 复制数组元素，比较适合底层调用
        // 一般使用 Arrays.copyOf 复制数组，该方法底层就是调用的 arraycopy 方法
        int arr[] = {1, 2, 3};
        int newArr[] = new int[3]; // 初始为 [0, 0, 0]
        /*
         * 第一个参数：原数组
         * 第二个参数：从原数组的哪个位置开始拷贝
         * 第三个参数：目标数组
         * 第四个参数：从目标数组的哪个位置开始放
         * 第五个参数：拷贝几个元素
         * 下面的意思就是：
         * 从 arr 数组的第0个位置开始，拷贝3个元素，从 newArr 的第0个位置开始依次放这三个元素
         */
        System.arraycopy(arr, 0, newArr, 0, 3);
        System.out.println(Arrays.toString(newArr));

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

        // gc 运行垃圾回收机制 System.gc() （前面讲过，不再举例）
    }
}