Java Arrays 对象数组

---

Arrays

• Arrays 类可以更方便地操作数组；
• java.util.Arrays，详见：JavaSE 8 Class Arrays；

---

1. API

类型	方法	说明
boolean	equals(E[ ] e1, E[ ] e2)	给定的两个相同类型的数组彼此相等则返回 true，相等指大小、顺序、包含元素都是一样的
void	fill(E[ ], E)	将指定类型的值分配给相同类型的数组的每个元素
void	sort(E e)	将数组按从小到大排序
String	toString(E e)	将数组变成字符串返回
int	binarySearch(E[ ] e, E e)	用二分搜索法搜索给定的值是否在给定的数组内，存在则返回索引，不存在则返回 -1 或 “-” 后跟插入点的索引
int	binarySearch(E[ ] e, int fromIndex, int endIndex, E e)	用二分搜索法搜索给定的值是否在给定的数组内，存在则返回索引，不存在则返回 -1 或 “-” 后跟插入点的索引

---

2. 常用方法

a. Arrays.fill()

import java.util.Arrays;

public class test {
    public static void main(String[] args) {
        int[] a = new int[6];
        Arrays.fill(a, 1);
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i]);//输出结果：111111
        }
    }
}

b. Arrays.sort()

• 是自然排序；

import java.util.Arrays;

public class test {
    public static void main(String[] args) {
        int[] a = {3, 1, 2};
        Arrays.sort(a);
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");//输出结果：[1, 2, 3]
        }
    }
}

c. Arrays.toString()

• a.toString() 调用的是默认的方法 toString()，不是 Arrays 重写的方法 toString()，所以输出的是地址值；

public class test {
    public static void main(String[] args) {
        int[] a = {1, 2, 3};
        System.out.println(a.toString());//输出结果：[I@23fc625e
        System.out.println(Arrays.toString(a));//输出结果：[1, 2, 3]
    }
}

---

3. 二分搜索法 binarySearch()

• 必须先用 Arrays.sort() 排序；
• 有两种参数形式；
• 详见：Java 二分查找图解；

a. binarySearch(Object[ ] o, Object key)

1. key 是数组元素，从0开始计数，返回索引；
2. key 不是数组元素，在数组元素范围内，从1开始计数，返回 “-” 后跟索引（这样不会与第4条重复）；
3. key 不是数组元素，大于数组的所有元素，返回 “-(length+1)”；
4. key 不是数组元素，小于数组的所有元素，返回 “-1”；

import java.util.Arrays;

public class test {
    public static void main(String[] args) {
        int[] a = {4, 1, 2};
        Arrays.sort(a);
        System.out.println(Arrays.binarySearch(a, 1));//0
        System.out.println(Arrays.binarySearch(a, 3));//-3
        System.out.println(Arrays.binarySearch(a, 5));//-4
        System.out.println(Arrays.binarySearch(a, 0));//-1
    }
}

b. binarySearch(Object[ ] o, int fromIndex, int endIndex, Object key)

指定数组范围 [fromIndex, endIndex) 搜索；

1. key 是数组元素，从0开始计数，返回原数组的索引；
2. key 不是数组元素，在指定数组元素范围内，从1开始计数，返回 “-” 后跟原数组的索引（这样不会与第4条重复）；
3. key 不是数组元素，大于指定数组的所有元素，返回 “-(endIndex+1)”；
4. key 不是数组元素，小于指定数组的所有元素，返回 “-(fromIndex+1)”；

import java.util.Arrays;

public class test {
    public static void main(String[] args) {
        int[] a = {7, 6, 5, 3, 2, 1};
        Arrays.sort(a);
        System.out.println(Arrays.binarySearch(a, 1, 4, 2));//1
        System.out.println(Arrays.binarySearch(a, 1, 4, 4));//-4
        System.out.println(Arrays.binarySearch(a, 1, 4, 7));//-5
        System.out.println(Arrays.binarySearch(a, 1, 4, 1));//-2
    }
}

c. 二分法查找数组是否存在该元素

import java.util.Arrays;

public class test {
    //针对已经排序好的数组进行查找
    public static boolean binarySearch(int[] array, int target) {
        int left = 0;
        int right = array.length - 1;
        int mid = (left + right) / 2;
        while (array[mid] != target && right > left) {
            //缩小判断范围
            if (array[mid] > target) {
                right = mid - 1;
            } else if (array[mid] < target) {
                left = mid + 1;
            }
            mid = (left + right) / 2;
            //判断在缩小范围后，新的left或者right是否会将target排除
            if (array[right] < target) {
                break;//若缩小后right比target小，即target不在数组中
            } else if (array[left] > target) {
                break;//若缩小后left比target大，即target不在数组中
            }
        }
        return (array[mid] == target);
    }

    public static void main(String[] args) {
        int[] a = {7, 6, 5, 3, 2, 1};
        Arrays.sort(a);
        System.out.println(binarySearch(a, 1));//true
        System.out.println(binarySearch(a, 4));//false
        System.out.println(binarySearch(a, 0));//false
        System.out.println(binarySearch(a, 7));//true
    }
}

d. Arrays.binarysort()

    public static int binarySearch(int[] a, int fromIndex, int toIndex,
                                   int key) {
        rangeCheck(a.length, fromIndex, toIndex);
        return binarySearch0(a, fromIndex, toIndex, key);
    }

    // Like public version, but without range checks.
    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.
    }