【Java学习笔记】Arrays类

Arrays 类

1. 导入包：import java.util.Arrays

2. 常用方法一览表

一、Arrays.toString()

优点：方便查看数组内容，避免了通过遍历来输出内容的繁琐

代码示例

import java.util.Arrays;
public class main {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6};
        System.out.println(Arrays.toString(arr));
    }
}

// 输出结果
[1, 2, 3, 4, 5, 6]

二、Arrays.sort()（重点！）

1. 自然排序（底层：快速排序）

import java.util.Arrays;
public class main {
    public static void main(String[] args) {
        int[] arr = {6,5,9,8,32,1,4};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

// 输出结果
[1, 4, 5, 6, 8, 9, 32]

2. 定制排序

（1）引入接口：Comprator

（2）实现接口方法compare

• 注意：返回值是int类型

• 延申：如何处理小数？

  • （1）影响排序结果的本质：判断和 0 的大小关系

  • （2）创建一个临时变量保存差值结果，判断和 0 的大小关系来返回对应的值

    • 大于 0：返回 1

    • 小于 0：返回-1

    • 等于 0：返回 0

（3）代码示例

1. 原先代码

Arrays.sort(integer_arr, new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return 0;
    }
});

说明：当前还没有学习泛型，代码修改为如下形式

2. 修改后的代码

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


public class main {
    public static void main(String[] args) {
        Integer[] integer_arr = {6,5,9,8,32,1,4};
        Arrays.sort(integer_arr, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                Integer n1 = (Integer) o1;
                Integer n2 = (Integer) o2;
                return n1 - n2;
            }
        });
        System.out.println(Arrays.toString(integer_arr));
    }
}

// 输出结果
[1, 4, 5, 6, 8, 9, 32]

代码说明

• （1）使用自定义排序

  • 1. 传入的参数为实现了 Comparator 接口的匿名内部类

  • 2. 要求实现compare()方法

    • 注意：返回值是int类型

• （2）去掉泛型部分：<Integer>，把compare方法中的参数改为Object，然后再方法中使用向下转型

三、实现定制排序的底层探究

1. 进入 sort 方法的底层源码

public static <T> void sort(T[] a, Comparator<? super T> c) {
    if (c == null) {
        sort(a);
    } else {
        if (LegacyMergeSort.userRequested)
            legacyMergeSort(a, c);
        else
            TimSort.sort(a, 0, a.length, c, null, 0, 0);
    }
}

2. 进入 TimeSort 类的 sort 方法

static <T> void sort(T[] a, int lo, int hi, Comparator<? super T> c,
                        T[] work, int workBase, int workLen) {
    assert c != null && a != null && lo >= 0 && lo <= hi && hi <= a.length;

    int nRemaining  = hi - lo;
    if (nRemaining < 2)
        return;  // Arrays of size 0 and 1 are always sorted

    // If array is small, do a "mini-TimSort" with no merges
    if (nRemaining < MIN_MERGE) {
        int initRunLen = countRunAndMakeAscending(a, lo, hi, c);
        binarySort(a, lo, hi, lo + initRunLen, c);
        return;
    }

3. 进入binarrySort方法

private static <T> void binarySort(T[] a, int lo, int hi, int start,
                                    Comparator<? super T> c) {
    assert lo <= start && start <= hi;
    if (start == lo)
        start++;
    for ( ; start < hi; start++) {
        T pivot = a[start];

        // Set left (and right) to the index where a[start] (pivot) belongs
        int left = lo;
        int right = start;
        assert left <= right;
        /*
            * Invariants:
            *   pivot >= all in [lo, left).
            *   pivot <  all in [right, start).
            */
        while (left < right) {
            int mid = (left + right) >>> 1;
            if (c.compare(pivot, a[mid]) < 0)
                right = mid;
            else
                left = mid + 1;
        }
        assert left == right;

4. 本质：通过c.compare(pivot, a[mid])的结果来影响排序结果

核心部分代码

while (left < right) {
    int mid = (left + right) >>> 1;
    if (c.compare(pivot, a[mid]) < 0)
        right = mid;
    else
        left = mid + 1;
}

总结

• （1）public int compare(Object o1, Object o2) 返回的值 > 0 还是 < 0 会影响整个排序的结果

• （2）小于 0：从小到大排序

• （3）大于 0：从大到小排序

四、Arrays.binarySearch()

二分查找方法（返回查找元素下标索引）

• 使用前提：数组是有序的

• 使用方法：Arrays.binarySearch(数组，查找元素)

注意点

• 若查找元素存在：返回下标索引

• 若查找元素不存在：返回-(low + 1)，low是应该插入的位置

底层源码

private static int binarySearch0(int[] a, int fromIndex, int toIndex,
                                    int key) {
    int low = fromIndex;
    int high = toIndex - 1;

    while (low <= high) {
        int mid = (low + high) >>> 1;
        int midVal = a[mid];

        if (midVal < key)
            low = mid + 1;
        else if (midVal > key)
            high = mid - 1;
        else
            return mid; // key found
    }
    return -(low + 1);  // key not found.
}

代码示例

import java.util.Arrays;

public class main {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        System.out.println(Arrays.binarySearch(arr, 2));

        System.out.println(Arrays.binarySearch(arr, 10));
    }
}

// 输出结果
1
-4

代码说明

查找的元素10不存在，应该插入的位置为3（下标索引），返回- (low + 1)，即- (3 + 1)，所以返回-4

五、Arrays.copyOf()

数组的拷贝

• 1. 使用方法：Arrays.copyOf(原数组，拷贝长度)

• 2. 注意点

  • （1）如果拷贝的长度大于原数组，会在新数组的后面增加null

  • （2）如果拷贝长度小于 0，，会抛出异常NegativeArraySizeException

代码示例

import java.util.Arrays;

public class main {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        int[] new_arr = Arrays.copyOf(arr,arr.length);
        System.out.println("arr: " + Arrays.toString(arr));
        System.out.println("new_arr：" + Arrays.toString(new_arr));
    }
}

// 输出结果
arr: [1, 2, 3]
new_arr：[1, 2, 3]

六、Arrays.fill()

使用方法：Arrays.fill(目标数组，填充值)

理解：把原数组中的所有数替换成填充数

代码示例

import java.util.Arrays;

public class main {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        Arrays.fill(arr,1);
        System.out.println("after_fill：" + Arrays.toString(arr));
    }
}

// 输出结果
after_fill：[1, 1, 1]

七、Arrays.equals()

比较两个数组的内容是否一致

使用方法：Arrays.equals(数组一，数组二)

代码示例

import java.util.Arrays;

public class main {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        int[] arr1 = {4,5,6};
        System.out.println("arr.equals(arr1)？ " + Arrays.equals(arr,arr1));
    }
}

// 输出结果
arr.equals(arr1)？ false

八、Arrays.asList()

1. 将一维数组转成 List 集合

2. 编译类型：List（接口）

3. 运行类型：java.util.Arrays#ArrayList，是 Arrays 类的静态内部类

private static class ArrayList<E> extends AbstractList<E>implements RandomAccess, java.io.Serializable

代码示例

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

public class main {
    public static void main(String[] args) {
        List aslist = Arrays.asList(1,2,3);
        System.out.println("aslist：" + aslist);
        System.out.println("getclass()：" + aslist.getClass());
    }
}

// 运行结果
aslist：[1, 2, 3]
getclass()：class java.util.Arrays$ArrayList