Math类+Arrays类-摩杜云开发者社区

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

2. 方法一览(均为静态方法)

Math类+Arrays类

代码在com.stulzl.math_.包中 480

Math_Method

package com.stulzl.math_;

//Math类的常用方法  480
public class Math_Method {
    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

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

    }
}

2.2 小练习 480

请写出获取 a-b之间的一个随机整数,a,b均为整数，比如 a = 2, b=7

即返回一个数 x 2 <= x <= 7

代码在com.stulzl.math_.包中

Exercise

package com.stulzl.math_;

public class Exercise {
    public static void main(String[] args) {
        //7.random 求随机数
        //  random 返回的是 0 <= x < 1 之间的一个随机小数[0,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 < 10; i++) {
            System.out.println((int)(2 +  Math.random() * (7 - 2 + 1)));
        }
    }
}

3. Arrays类

3.1 Arrays 类常见方法应用案例 481

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

1) toString返回数组的字符串形式

Arrays.toString(arr)

2) sort排序(自然排序和定制排序)

Integer arr[] = {1,-1, 7, 0, 89};

3) binarySearch通过二分搜索法进行查找，要求必须排好序

int index = Arrays.binarySearch(arr, 3);

4) copyOf数组元素的复制

Integer[] newArr = Arrays.copyOf(arr, arr.length);

5) fill数组元素的填充

Integer[] num = new Integer[]{9,3,2};

Arrays.fill(num, 99);

6) equals比较两个数组元素内容是否完全一致

boolean equals = Arrays.equals(arr, arr2);

7) asList将一组值，转换成list

List asList = Arrays.asList(2,3,4,5,6,1);

System.out.println(" asList=" + asList);

代码在com.stulzl.arrays_.包中 481

ArraysMethods01

package com.stulzl.arrays_;

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

//arrays方法 481-483
public class ArraysMethods01 {
    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));//[1, 20, 90]

        //演示sort排序方法
        Integer arr[] = {1,-1,7,0,89};
        // 因为数组是引用类型，所以通过 sort 排序后，会直接影响到 实参 arr
        Arrays.sort(arr);
        System.out.println("====排序后====");
        System.out.println(Arrays.toString(arr));//从小到大排
        //定制排序
        // sort 重载的，也可以通过传入一个接口 Comparator 实现定制排序
        //4. 调用 定制排序 时，传入两个参数 (1) 排序的数组 arr
        // (2) 实现了 Comparator 接口的匿名内部类 , 要求实现 compare 方法
        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("====排序后====");
        System.out.println(Arrays.toString(arr));//从小到大排
    }
}

ArraysMethods02 483

package com.stulzl.arrays_;

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

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

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

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

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

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

4. 自我实现自定义排序 482

代码在com.stulzl.arrays_sort_custom.包中

ArraysSortCustom

package com.stulzl.arrays_sort_custom;

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

//自我实现自定义排序  482
public class ArraysSortCustom {
    public static void main(String[] args) {
        int arr[] = {18,96,-7,23,2};

        //bubble01(arr);

        bubble02(arr, new Comparator() {//匿名内部类
            @Override
            public int compare(Object o1, Object o2) {
                Integer i1 = (Integer)o1;
                Integer i2 = (Integer)o2;
                return i2-i1;  //return i1-i2; //主动权 两种情况可以控制不同顺序的排序
            }
        });

        System.out.println("====排序后====");
        System.out.println(Arrays.toString(arr));
    }
    //使用冒泡排序
    public static void bubble01(int arr[]){
        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]){
                    int temp = arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
    }

    //结合冒泡实现定制排序
    public static void bubble02(int arr[], Comparator c){//Comparator是一个接口
        for (int i = 0; i < arr.length-1; i++) {
            for(int j = 0;j<arr.length-1-i;j++){

                //这里解释(判断式)为什么只写>0
                //1. arr[j]-arr[j+1] > 0  进入交换  小-->大
                //2. arr[j]-arr[j+1] < 0  进入交换  大-->小
                //但是我们为了只写一个判断式，就将2小小的改动一下
                // -(arr[j]-arr[j+1]) > 0 打开负号
                //等价于 arr[j+1]-arr[j] > 0  进入交换 大-->小
                if(c.compare(arr[j],arr[j+1])>0){//这里的>0  <0,直接影响排序的结果
                    int temp = arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
    }
}