Java中Arrays和Collections类的使用

Collections:是java.util.*下的一个类，对集合进行操作

常用静态方法：

static Object max(Collection coll) 根据元素的自然顺序，返回给定 collection 的最大元素。

static Object min(Collection coll) 根据元素的自然顺序，返回给定 collection 的最小元素。

static void fill(List list, Object obj) 使用指定元素替换指定列表中的所有元素。

static void sort(List list):自然升序排序

static int binarySearch(List list, Object key) 使用二分搜索法搜索指定列表，以获得指定对象。

public static Comparator reverseOrder():可以**强行逆转**Collection的自然排序

public static Comparator reverseOrder(Comparator cmp)：可以强行逆转指定比较器的顺序

static void shuffle(List list):对集合元素随机排序（可以用于骰子，扑克的发牌（见Random））

Arrays： java.util.*下面的类，用来操作数组

数组变集合：可以用集合的思想来操作数组，比较方便

public static List asList(Object… a)返回一个受指定数组支持的固定大小的列表(返回的是不可变的List(长度固定))。

注意： 
1.将数组变成集合，不可以使用集合的增删方法，因为数组的长度是固定的 
2.如果数组中的元素都是对象，变成集合时，会将数组中的对象变成集合中的元素 
如果数组中的元素都是基本数据类型，那么会将数组变成集合中的元素存在 
如：

int[] a0 = {1,2,3};
        List<int[]> list = Arrays.asList(a0);
        System.out.println(list);//[[I@659e0bfd]
        Integer[] a = {1,2,3};
        List<Integer> arr = Arrays.asList(a);
        System.out.println(arr);//[1, 2, 3]

集合变数组：为了限定对元素的操作 
Collection.toArray() ：

返回的数组长度如何确定:

如果指定数组的长度小于集合的size，方法内部会创建一个新数组，长度为size

如果指定数组长度大于集合的size,就不会创建数组了，使用传进来的数组，长度为size

    String[] str = arr.toArray(new String[arr.size()]);
    System.out.println(Arrays.toString(str));
ArrayList<Integer>newlist=new ArrayList<Integer>();  
            newlist.add(1);  
            newlist.add(2);  
            newlist.add(3);  
            newlist.add(4);  
            //正确写法  ,将容器里面存放的类型转成相应的数组  
            Integer IntegerArray[]=newlist.toArray(new Integer[4]);    
            //下面的方法是错误的  
            //Long  LongArray[]=newlist.toArray(new Long[4]); //这个里面含有类型转换,故错误

Arrays.asList()和Collection.toArray() 一起，充当了基于数组的 API 与基于 collection 的 API 之间的桥梁。返回的列表是可序列化的，并且实现了 RandomAccess。

java.util.Arrays类能方便地操作数组，它提供的所有方法都是静态的。具有以下功能：

² 给数组赋值：通过fill方法。

² 对数组排序：通过sort方法,按升序。

² 比较数组：通过equals方法比较数组中元素值是否相等。

² 查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作。

 

 

import java.util.Arrays;

public class TestArrays {

public static void output(int[] array) {

if (array!=null) {

for (int i = 0; i < array.length; i++) {

System.out.print(array[i]+" ");

}

}

System.out.println();

}

public static void main(String[] args) {

int[] array = new int[5];

//填充数组

Arrays.fill(array, 5);

System.out.println("填充数组：Arrays.fill(array, 5)：");

TestArrays.output(array);

 

//将数组的第2和第3个元素赋值为8

Arrays.fill(array, 2, 4, 8);

System.out.println("将数组的第2和第3个元素赋值为8：Arrays.fill(array, 2, 4, 8)：");

TestArrays.output(array);

 

int[] array1 = {7,8,3,2,12,6,3,5,4};

//对数组的第2个到第6个进行排序进行排序

Arrays.sort(array1,2,7);

System.out.println("对数组的第2个到第6个元素进行排序进行排序：Arrays.sort(array,2,7)：");

TestArrays.output(array1);

 

//对整个数组进行排序

Arrays.sort(array1);

System.out.println("对整个数组进行排序：Arrays.sort(array1)：");

TestArrays.output(array1);

 

//比较数组元素是否相等

System.out.println("比较数组元素是否相等:Arrays.equals(array, array1):"+"\n"+Arrays.equals(array, array1));

int[] array2 = array1.clone();

System.out.println("克隆后数组元素是否相等:Arrays.equals(array1, array2):"+"\n"+Arrays.equals(array1, array2));

 

//使用二分搜索算法查找指定元素所在的下标（必须是排序好的，否则结果不正确）

Arrays.sort(array1);

System.out.println("元素3在array1中的位置：Arrays.binarySearch(array1, 3)："+"\n"+Arrays.binarySearch(array1, 3));

//如果不存在就返回负数

System.out.println("元素9在array1中的位置：Arrays.binarySearch(array1, 9)："+"\n"+Arrays.binarySearch(array1, 9));

}

}

 

输出结果：

填充数组：Arrays.fill(array, 5)：
5 5 5 5 5
将数组的第2和第3个元素赋值为8：Arrays.fill(array, 2, 4, 8)：
5 5 8 8 5
对数组的第2个到第6个元素进行排序进行排序：Arrays.sort(array,2,7)：
7 8 2 3 3 6 12 5 4
对整个数组进行排序：Arrays.sort(array1)：
2 3 3 4 5 6 7 8 12
比较数组元素是否相等:Arrays.equals(array, array1):
false
克隆后数组元素是否相等:Arrays.equals(array1, array2):
true
元素3在array1中的位置：Arrays.binarySearch(array1, 3)：
1
元素9在array1中的位置：Arrays.binarySearch(array1, 9)：
-9