java中Arrays工具类的用法

java.util.Arrays类能方便地操作数组，它提供的所有方法都是静态的。具有以下功能：
给数组赋值：通过fill方法。
对数组排序：通过sort方法,按升序
比 较 数 组： 通过equals方法比较数组中元素值是否相等。
查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作。
截取数组元素：通过copyOf方法和copyOfRange对数组元素进行截取。
打印数组元素：通过toString方法打印数组元素。
将数组转换为list：通过asList方法转换为List。
在此先创建一个打印数组的方法，方便后面直接使用
public static void output(int[] list){
for(int i = 0;i < list.length;i++){
System.out.print(list[i]+" ");
}
System.out.println();
}
排序 : sort()
// *****排序 sort****
int a[] = { 1, 3, 2, 7, 6, 5, 4, 9 };
// sort(int[] a)方法按照数字顺序排列指定的数组。
Arrays.sort(a);
System.out.println("Arrays.sort(a):");
for (int i : a) {
System.out.print(i);
}
// 换行
System.out.println();
// sort(int[] a,int fromIndex,int toIndex)按升序排列数组的指定范围
int b[] = { 1, 3, 2, 7, 6, 5, 4, 9 };
Arrays.sort(b, 2, 6);
System.out.println("Arrays.sort(b, 2, 6):");
for (int i : b) {
System.out.print(i);
}
// 换行
System.out.println();

    int c[] = { 1, 3, 2, 7, 6, 5, 4, 9 };
    // parallelSort(int[] a) 按照数字顺序排列指定的数组(并行的)。同sort方法一样也有按范围的排序
    Arrays.parallelSort(c);
    System.out.println("Arrays.parallelSort(c)：");
    for (int i : c) {
        System.out.print(i);
    }
    // 换行
    System.out.println();
    // parallelSort给字符数组排序，sort也可以
    char d[] = { 'a', 'f', 'b', 'c', 'e', 'A', 'C', 'B' };
    Arrays.parallelSort(d);
    System.out.println("Arrays.parallelSort(d)：");
    for (char d2 : d) {
        System.out.print(d2);
    }
    // 换行
    System.out.println();

在做算法面试题的时候，我们还可能会经常遇到对字符串排序的情况,Arrays.sort() 对每个字符串的特定位置进行比较，然后按照升序排序。
String[] strs = { "abcdehg", "abcdefg", "abcdeag" };
Arrays.sort(strs);
System.out.println(Arrays.toString(strs));//[abcdeag, abcdefg, abcdehg]
eg1
int[] intTest={15,78,32,5,29,22,17,34};
Arrays.sort(intTest);
output(intTest);
结果是：5 15 17 22 29 32 34 78
分析：给所有数按升序排序
eg2
int[] intTest={15,78,32,5,29,22,17,34};
Arrays.sort(intTest,2,6);
output(intTest);
结果是：15 78 5 22 29 32 17 34
分析：给第2位（0开始）到第6位（不包括）排序
查找 : binarySearch()
// *查找 binarySearch()****
char[] e = { 'a', 'f', 'b', 'c', 'e', 'A', 'C', 'B' };
// 排序后再进行二分查找，否则找不到
Arrays.sort(e);
System.out.println("Arrays.sort(e)" + Arrays.toString(e));
System.out.println("Arrays.binarySearch(e, 'c')：");
int s = Arrays.binarySearch(e, 'c');
System.out.println("字符c在数组的位置：" + s);
注意：数组一定是排好序的，否则会出错。找到元素，只会返回最后一个位置
eg1
int[] testA={5,7,12,45,57,66,81};
System.out.println(Arrays.binarySearch(testA, 12));
结果是：2
分析：能找到该元素，返回下标为2（0开始）
eg2
int[] testA={5,7,12,45,57,66,81};
System.out.println(Arrays.binarySearch(testA, 9));
结果是：-3
分析：找不到元素，返回-x，从-1开始数，如题，返回-3
eg3
int[] testA={5,7,12,45,57,66,81};
System.out.println(Arrays.binarySearch(testA, 0,3,12));
结果是：2
分析：从0到3位（不包括）找12，找到了，在第2位，返回2
eg4
int[] testA={5,7,12,45,57,66,81};
System.out.println(Arrays.binarySearch(testA, 0,2,12));
结果是：-3
分析：从0到2位（不包括）找12，找不到，从-1开始数，返回-3
比较: equals()
// *比较 equals****
char[] e = { 'a', 'f', 'b', 'c', 'e', 'A', 'C', 'B' };
char[] f = { 'a', 'f', 'b', 'c', 'e', 'A', 'C', 'B' };
/*

• 元素数量相同，并且相同位置的元素相同。 另外，如果两个数组引用都是null，则它们被认为是相等的 。
  */
  // 输出true
  System.out.println("Arrays.equals(e, f):" + Arrays.equals(e, f));
  int []arr1 = {1,2,3};
  int []arr2 = {1,2,3};
  System.out.println(Arrays.equals(arr1,arr2));
  结果是：true
  分析：如果是arr1.equals(arr2),则返回false，因为equals比较的是两个对象的地址，不是里面的数，而Arrays.equals重写了equals，所以，这里能比较元素是否相等。
  注意：如果两个数组元素值一样，但是两个数组对应位置元素不同，Arrays.equals返回结果是false。
  int[] intTesta={15,78,32,5,29,22,17,34};
  int[] intTestb={78,15,32,5,29,22,17,34};
  System.out.println(Arrays.equals(intTesta, intTestb));
  结果是：false
  分析：两个数组对应位置的元素不相等。
  填充 : fill()
  // *****填充fill(批量初始化)****
  int[] g = { 1, 2, 3, 3, 3, 3, 6, 6, 6 };
  // 数组中所有元素重新分配值
  Arrays.fill(g, 3);
  System.out.println("Arrays.fill(g, 3)：");
  // 输出结果：333333333
  for (int i : g) {
  System.out.print(i);
  }
  // 换行
  System.out.println();

  int[] h = { 1, 2, 3, 3, 3, 3, 6, 6, 6, };
  // 数组中指定范围元素重新分配值
  Arrays.fill(h, 0, 2, 9);
  System.out.println("Arrays.fill(h, 0, 2, 9);：");
  // 输出结果：993333666
  for (int i : h) {
      System.out.print(i);
  }

  eg1
  int[] array=new int[5];
  Arrays.fill(array,5);
  System.out.println("填充数组：Arrays.fill(array, 5)：");
  output(array);
  结果是：5 5 5 5 5
  分析：给所有值赋值5
  eg2
  int[] array=new int[5];
  Arrays.fill(array, 2, 4, 8);
  output(array);
  结果是：5 5 8 8 5
  分析：给第2位（0开始）到第4位（不包括）赋值8
  转列表 asList()
  // *****转列表 asList()****
  /*

  • 返回由指定数组支持的固定大小的列表。
  • （将返回ZFX返佣www.fx61.com/brokerlist/zfx.html的列表更改为“写入数组”。）该方法作为基于数组和基于集合的API之间的桥梁，与Collection.toArray()相结合 。
  • 返回的列表是可序列化的，并实现RandomAccess 。
  • 此方法还提供了一种方便的方式来创建一个初始化为包含几个元素的固定大小的列表如下：
    */
    List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");
    System.out.println(stooges);
    将数组转换为List
    String[] stringTest = {"hello","how","are","you","!"};
    List<String> list = Arrays.asList(stringTest);
    for(String te : list){
    System.out.print(te+" ");
    }
    结果：hello how are you !
    转字符串 toString()
    // *****转字符串 toString()****
    /*
• 返回指定数组的内容的字符串表示形式。
  */
  char[] k = { 'a', 'f', 'b', 'c', 'e', 'A', 'C', 'B' };
  System.out.println(Arrays.toString(k));// [a, f, b, c, e, A, C, B]
  直接toString方法打印数组元素
  String[] stringTest = {"hello","how","are","you","!"};
  System.out.println(Arrays.toString(stringTest));
  结果：[hello, how, are, you, !]
  复制 copyOf()
  // *****复制 copy****
  // copyOf 方法实现数组复制,h为数组，6为复制的长度
  int[] h = { 1, 2, 3, 3, 3, 3, 6, 6, 6, };
  int i[] = Arrays.copyOf(h, 6);
  System.out.println("Arrays.copyOf(h, 6);：");
  // 输出结果：123333
  for (int j : i) {
  System.out.print(j);
  }
  // 换行
  System.out.println();
  // copyOfRange将指定数组的指定范围复制到新数组中
  int j[] = Arrays.copyOfRange(h, 6, 11);
  System.out.println("Arrays.copyOfRange(h, 6, 11)：");
  // 输出结果66600(h数组只有9个元素这里是从索引6到索引11复制所以不足的就为0)
  for (int j2 : j) {
  System.out.print(j2);
  }
  // 换行
  System.out.println();
  eg1 copyOf
  int[] array={5, 5, 8, 8, 5};
  int[] copyarray = Arrays.copyOf(array, 4);
  output(copyarray);
  结果是：5 5 8 8
  分析：截取array数组的4个元素赋值给数组copyarray
  eg2 copyOfRange
  int[] array={5, 5, 8, 8, 5};
  int[] copyOfRange = Arrays.copyOfRange(array, 1, 4);
  output(copyOfRange);
  结果是：5 8 8
  分析：从第1位（0开始）截取到第4位（不包括）
  java示例代码
  import java.util.Arrays;
  import java.util.List;
  public class ArrayClassTest {
  /**
  • 打印数组元素
  • @param list
    */
    public static void output(int[] list){
    for(int i = 0;i < list.length;i++){
    System.out.print(list[i]+" ");
    }
    System.out.println();
    }
    public static void main(String[] args) {
    int[] intTest={15,78,32,5,29,22,17,34};
    int[] array=new int[5];
    //填充数组
    Arrays.fill(array,5);
    System.out.println("填充数组：Arrays.fill(array, 5)：");
    output(array);
    //将数组的第2和第3个元素赋值为8
    Arrays.fill(array, 2, 4, 8);
    System.out.println("将数组的第2和第3个元素赋值为8：Arrays.fill(array, 2, 4, 8)：");
    output(array);
    //对数组的第2个到第5个进行排序进行排序
    Arrays.sort(intTest,2,6);
    System.out.println("对数组的第2个到第5个元素进行排序进行排序：Arrays.sort(intTest,2,6)：");
    output(intTest);
    //对整个数组进行排序
    Arrays.sort(intTest);
    System.out.println("对整个数组进行排序：Arrays.sort(intTest)：");
    output(intTest);
    //比较数组元素是否相等
    System.out.println("比较数组元素是否相等:Arrays.equals(array, intTest):"+"\n"+Arrays.equals(array, intTest));
    int[] array1 = array.clone();
    System.out.println("克隆后数组元素是否相等:Arrays.equals(array, array1):"+"\n"+Arrays.equals(array, array1));
    //注意：数组对应位置元素相等Arrays.equals结果才为true
    int[] intTesta={15,78,32,5,29,22,17,34};
    int[] intTestb={78,15,32,5,29,22,17,34};
    System.out.println("数组前两个元素位置颠倒结果是否相等:Arrays.equals(intTesta, intTestb):"+"\n"+Arrays.equals(intTesta, intTestb));
    //使用二分搜索算法查找指定元素所在的下标（必须是排序好的，否则结果不正确）
    int[] testA={5,7,12,45,57,66,81};
    System.out.println("元素12在testA中的位置：Arrays.binarySearch(testA, 12)："+"\n"+Arrays.binarySearch(testA, 12));
    //如果不存在就返回负数
    System.out.println("元素9在testA中的位置：Arrays.binarySearch(testA, 9)："+"\n"+Arrays.binarySearch(testA, 9));
    //从指定位置中查找元素
    System.out.println("元素12在testA中0到3的位置：Arrays.binarySearch(testA, 0,3,12)："+"\n"+Arrays.binarySearch(testA, 0,3,12));
    //从指定位置中查找元素，元素不存在
    System.out.println("元素12在testA中0到2的位置：Arrays.binarySearch(testA, 0,2,12)："+"\n"+Arrays.binarySearch(testA, 0,2,12));
    //截取数组
    int[] copyarray = Arrays.copyOf(array, 4);
    System.out.println("copyOf方法截取的数组元素为：");
    output(copyarray);
    int[] copyOfRange = Arrays.copyOfRange(array, 1, 4);
    System.out.println("copyOfRange方法截取的数组元素为：");
    output(copyOfRange);
    //toString方法打印数组元素
    String[] stringTest = {"hello","how","are","you","!"};
    System.out.println("toString方法打印数组元素：");
    System.out.println(Arrays.toString(stringTest));
    //asList方法将数组转换成List
    List<String> list = Arrays.asList(stringTest);
    System.out.println("数组转换为list，打印结果为:");
    for(String te : list){
    System.out.print(te+" ");
    }
    }
    }
    程序运行结果如下：
    填充数组：Arrays.fill(array, 5)：
    5 5 5 5 5
    将数组的第2和第3个元素赋值为8：Arrays.fill(array, 2, 4, 8)：
    5 5 8 8 5
    对数组的第2个到第5个元素进行排序进行排序：Arrays.sort(intTest,2,6)：
    15 78 5 22 29 32 17 34
    对整个数组进行排序：Arrays.sort(intTest)：
    5 15 17 22 29 32 34 78
    比较数组元素是否相等:Arrays.equals(array, intTest):
    false
    克隆后数组元素是否相等:Arrays.equals(array, array1):
    true
    数组前两个元素位置颠倒结果是否相等:Arrays.equals(intTesta, intTestb):
    false
    元素12在testA中的位置：Arrays.binarySearch(testA, 12)：
    2
    元素9在testA中的位置：Arrays.binarySearch(testA, 9)：
    -3
    元素12在testA中0到3的位置：Arrays.binarySearch(testA, 0,3,12)：
    2
    元素12在testA中0到2的位置：Arrays.binarySearch(testA, 0,2,12)：
    -3
    [5, 5, 8, 8, 5]
    copyOf方法截取的数组元素为：
    5 5 8 8
    copyOfRange方法截取的数组元素为：
    5 8 8
    toString方法打印数组元素：
    [hello, how, are, you, !]
    数组转换为list，打印结果为:
    hello how are you !