【JavaSE】Arrays工具类

前言：上一篇文章中我们学习了数组，今天我们来说说针对数组操作的工具类 Arrays 部分方法的使用方法。

1. 对数组进行打印

1. Arrays.toString()打印一维数组

根据上面可以看到，我们需要在 toString() 方法传入一个数组，它会把这个数组中的元素以字符串的形式返回。

import java.util.Arrays;
public class Main {
	public static void main(String[] args) {
		int[] array = {1, 3, 8, 2};
		String ret = Arrays.toString(array);
		System.out.println(ret);
	}
}

注意：使用 Arrays 工具类时需要加上 import java.util.Arrays; 原因是使用库的工具类时需要说明，即导入Arrays。

接下来我们也可以来模拟一下 toString() 的实现，练一练手。

public class Main {
    public static String myToString(int[] array) {
        String str = "[";
        for (int i = 0; i < array.length; i++) {
            str += array[i];
            if (i != array.length - 1) {
                str += ",";
            }
        }
        str += "]";
        return str;
    }
    public static void main(String[] args){
        int[] array = {1, 2, 3, 4, 5};
        String ret  = myToString(array);
        System.out.println(ret);
    }
}

2. Arrays.deepToString()打印二维数组

和 toString()方法一样它也是返回一个字符串

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

2. 实现数组的拷贝

1. 使用for循环

public class Main {
    public static void main1(String[] args) {
        int[] array1 = {1, 2, 3, 4};
        int[] copy = new int[array1.length];
        for (int i = 0; i < array1.length; i++) {
            copy[i] = array1[i];
        }
        System.out.println(Arrays.toString(copy));
    }
}

2. Arrays.copyOf()

当我们想要拷贝一个数组时，可以使用 for 循环进行拷贝，也可以使用Arrays.copyOf()。
copyOf() 这个方法需要我们传入两个参数，如上图说明，它会返回一个和你要拷贝的数组一样的数组类型。

import java.util.Arrays;
public class Main {
    public static void main(String[] args) {
        int[] array = {1, 3, 8, 2};
        int[] copy = Arrays.copyOf(array, array.length); 
        System.out.println("array=" + Arrays.toString(array));
        System.out.println("copy=" + Arrays.toString(copy));
    }
}

当然我们也可以使用 Arrays.copyOf() 以达到数组的扩容

import java.util.Arrays;
public class Main {
    public static void main2(String[] args) {
        int array[] = {1, 2, 3, 4};
        //虽然是拷贝，但也可以用此实现扩容
        int[] copy = Arrays.copyOf(array, 2*array.length);
        System.out.println(Arrays.toString(copy));
    }
}

3. Arrays.copyOfRange() 部分拷贝

注意：结束拷贝 int to 不包含此下标，即 [int from, int to)。

import java.util.Arrays;
public class Main {
    public static void main(String[] args) {
        int[] array = {1, 3, 8, 2};
        int[] copy = Arrays.copyOfRange(array, 1, 3); //从1下标拷贝到2下标处，左闭右开
        System.out.println("array=" + Arrays.toString(array));
        System.out.println("copy=" + Arrays.toString(copy));
    }
}

也可以实现数组的扩容

import java.util.Arrays;
public class Main {
    public static void main(String[] args) {
        int[] array = {1, 3, 8, 2};
        int[] copy = Arrays.copyOfRange(array, 1, 5);
        System.out.println("array=" + Arrays.toString(array));
        System.out.println("copy=" + Arrays.toString(copy));
    }
}

4. 引用.clone() 实现

public class Main {
    public static void main(String[] args) {
        int[] array = {1, 3, 8, 2};
        int[] copy = array.clone();
        System.out.println("copy=" + Arrays.toString(copy));
    }
}

当 array 引用调用 clone() 时，会使 array 所引用的对象产生一个和 array 地址不同的副本，然后传给copy。

3. Arrays.equals()的使用

Arrays.equals() 是比较两个数组中元素是否相同

import java.util.Arrays;
public class Main {
    public static void main(String[] args) {
        int[] array1 = {1, 3, 8, 2};
        int[] array2 = {1, 3, 8, 2};
        boolean ret = Arrays.equals(array1, array2);
        System.out.println(ret);
    }
}

4. Arrays.fill()的使用

Arrays.fill()的作用是对一个数组进行填充

1. 第一种方式

import java.util.Arrays;
public class Main {
    public static void main(String[] args) {
        int[] array1 = new int[10];
        Arrays.fill(array1, 1);//将array1中元素全部填充为1
        System.out.println("array1=" + Arrays.toString(array1));
    }
}

2. 第二种方式

import java.util.Arrays;
public class Main {
    public static void main(String[] args) {
        int[] array1 = new int[10];
        Arrays.fill(array1, 8, 10, 20);//8到9下标的元素变为20，和copyOfRange一样是左闭右开
        System.out.println("array1=" + Arrays.toString(array1));
    }
}

注意：数组不能越界不然会报错

5. 二分查找

5.1 Arrays.sort()

当我们想要使用二分查找时，数组必须是有序的，当数组没有有序时，可以采用 Arrays.sort() 进行升序排序，传入需要排序的数组即可。

/*
    2.二分查找,返回数组下标，使用二分查找数组必须有序的
 */
import java.util.Arrays;
public class Main2 {
    public static int binarySearch(int[] array,int key) {
        int left = 0;
        int right = array.length - 1;
        while (left <= right) {
            int mid = (left+right) / 2;
            if (key > array[mid]) {
                left = mid + 1;
            } else if (key < array[mid]) {
                right = mid - 1;
            } else if (key == array[mid]) {
                return mid;
            }
        }
        return -1;//数组没有负数，返回负数代表数组没有这个数
    }
    public static void main(String[] args) {
        int key = 15;
        int[] array = {1, 3, 8, 9, 11, 33, 15};
        Arrays.sort(array);
        int ret = binarySearch(array,key);
        if (ret == -1) {
            System.out.println("找不到此数字");
        } else {
            System.out.println("找到了，下标为" + ret);
        }
    }
}

1、sort方法默认是升序排序
2、对于我现在的简单数据类型能不能采用降序排序，做不到。
3、怎么样可以做到指定的升序或者降序，我们需要继续向后学习。

5.2 Arrays.binarySearch()

当然我们也可以使用 Arrays.binarySearch() 实现二分查找

使用 Arrays.binarySearch() 返回的是一个整型：

1. 当在数组中找到与 key 相同的元素时，返回该元素的下标。
2. 当在数组中找不到与 key 相同的元素时， 返回该数组最后一个下标加一的负值。
   例如：int[] array = {1, 2, 3, 4}; 当找不到与 key 相同的元素时，return -(3 + 1)。

如下图是 java 实现 binarySearch() 方法时的源代码

import java.util.Arrays;
public class TestDemo3 {
        public static void main(String[] args) {
            int key = 11;
            int[] array = {1, 3, 8, 9, 11, 15, 33};
            int index = Arrays.binarySearch(array,key);
            if (index < 0) { //返回的是下标无负数
                System.out.println("找不到此数字");
            } else {
                System.out.println("找到了，下标为" + index);
            }
        }
}

好了本篇文章就到这里了，如发现有错误，请各位大佬及时指出。