非零基础自学Java (老师：韩顺平) 第13章 常用类 13.8 Arrays类

非零基础自学Java (老师：韩顺平)

✈【【零基础 快速学Java】韩顺平 零基础30天学会Java】

第13章 常用类

13.8 Arrays类

13.8.1 Arrays 类常见方法应用案例

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

• toString 返回数组的字符串形式

  Arrays.toString(arr)

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

• binarySearch 通过二分搜索法进行查找【要求必须排好序】

• copyOf 数组元素的复制

• fill 数组元素的填充

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

• asList 将一组值，转换为 list

【举个栗子】

package com.dingjiaxiong.arrays_;

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

/**
 * ClassName: ArraysMethod01
 * date: 2022/9/4 17:34
 *
 * @author DingJiaxiong
 */

public class ArraysMethod01 {
    public static void main(String[] args) {
        Integer[] integers = {1 , 20 , 90};
        //直接使用Arrays.toString 方法，显示数组
        System.out.println(Arrays.toString(integers));

        //sort方法
        //1. 可以直接使用冒泡排序 , 也可以直接使用 Arrays 提供的 sort 方法排序
        //2. 因为数组是引用类型，所以通过 sort 排序后，会直接影响到 实参 arr
        //3. sort 重载的，也可以通过传入一个接口 Comparator 实现定制排序
        //4. 调用 定制排序 时，传入两个参数
        // (1) 排序的数组 arr
        // (2) 实现了 Comparator 接口的匿名内部类 , 要求实现 compare 方法
        Integer arr[] = {1 , -1 , 7 ,0 , 89};

        //默认排序
//        Arrays.sort(arr);

        //定制排序

        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));

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

运行结果

【再一个栗子】

package com.dingjiaxiong.arrays_;

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

/**
 * ClassName: ArraysSortCustom
 * date: 2022/9/4 17:44
 *
 * @author DingJiaxiong
 */

public class ArraysSortCustom {
    public static void main(String[] args) {
        int[] arr = {1, -1, 8 , 0, 20};
//        bubble01(arr);

        bubble02(arr, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                //从大到小
                int i1 = (int) o1;
                int i2 = (int) o2;
                return i2 - i1;
            }
        });

        System.out.println("======定制排序后的结果=========");
        System.out.println(Arrays.toString(arr));
    }

    //使用冒泡完成排序
    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;
                }
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

运行结果

【还有个栗子】

package com.dingjiaxiong.arrays_;

import java.awt.*;
import java.util.Arrays;
import java.util.List;

/**
 * ClassName: ArraysMethod02
 * date: 2022/9/4 19:04
 *
 * @author DingJiaxiong
 */

public class ArraysMethod02 {
    public static void main(String[] args) {
        Integer[] arr = {1 , 2 , 90 , 123 , 567};
        //二分查找要求必须排好序

        int index = Arrays.binarySearch(arr , 567);
        System.out.println("index = " + index);

        //copyOf数组元素的复制
        Integer[] newArr = Arrays.copyOf(arr , arr.length);
        System.out.println("=====拷贝执行完毕后=====");
        System.out.println(Arrays.toString(newArr));

        //fill 数组元素的填充
        Integer[] num = new Integer[]{9 , 3 , 2};
        Arrays.fill(num , 99);
        System.out.println("=====num数组填充后=====");
        System.out.println(Arrays.toString(num));


        //equals 比较两个数组元素内容是否完全一致
        Integer[] arr2 = {1,2,90,123};

        boolean equals = Arrays.equals(arr,arr2);
        System.out.println("equals = " + equals);

        //asList 将一组值，转换成 list
        List asList = Arrays.asList(2, 3, 4, 5, 7, 1);
        System.out.println("asList = " + asList);

        System.out.println("asList的运行类型" + asList.getClass());

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

运行结果