Java集合(三)--Collection、Collections和Arrays

Collection：

　　Collection是集合类的顶级接口，提供了对集合对象进行基本操作的通用接口方法。Collection接口的意义是为各种具体的集合提供了最大化

的统一操作方式，其直接继承接口有List与Set。

public interface Collection<E> extends Iterable<E> {
    int size();　　//集合的容量

    boolean isEmpty();　　//是否为空

    boolean contains(Object var1);　　//是否包含某个元素

    Iterator<E> iterator();　　//返回迭代器，进行数据迭代

    Object[] toArray();　　//转换为Object数组

    <T> T[] toArray(T[] var1);　　//将list转换为所需要类型的数组

    boolean add(E var1);　　//添加元素

    boolean remove(Object var1);　　//去除元素

    boolean containsAll(Collection<?> var1);　　//是否包含某个集合内所有的元素

    boolean addAll(Collection<? extends E> var1);　　//添加一个集合

    boolean removeAll(Collection<?> var1);　　//删除一个集合的元素

    boolean retainAll(Collection<?> var1);　　//取交集

    void clear();　　//清空集合

    boolean equals(Object var1);　　//比较

    int hashCode();　　//hash码

}

public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(2);
        list.add(1);
        list.add(3);
        System.out.println("list size: " + list.size());
        System.out.println("list isEmpty: " + list.isEmpty());
        System.out.println("list iscontains: " + list.contains(1));
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println("list.iterator(): " + iterator.next());
        }
        Object[] integers = list.toArray();
        for (Object o : integers) {
            System.out.println("list.toArray(): " + o);
        }
        list.add(1, 7);
        list.remove(1);
        System.out.println(list.containsAll(Arrays.asList(2, 1, 3)));
        System.out.println(list.toString());
        System.out.println(list.retainAll(Arrays.asList(2, 11, 13)));
        System.out.println("交集：" + list.toString());
        list.clear();
        System.out.println("清空集合：" + list.toString());
}

结果：

list size: 3
list isEmpty: false
list iscontains: true
list.iterator(): 2
list.iterator(): 1
list.iterator(): 3
list.toArray(): 2
list.toArray(): 1
list.toArray(): 3
true
[2, 1, 3]
true
交集：[2]

清空集合：[]

Collections：

Collections是集合的工具类，包含很多静态方法，用于对集合的各种操作

public static void main(String[] args) {
	List<Integer> list = new ArrayList<>();
	list.add(2);
	list.add(1);
	list.add(3);
	list.add(5);
	list.add(4);
	System.out.println("排序前：" + list);
	Collections.sort(list);
	System.out.println("排序后：" + list);
	Collections.shuffle(list);
	System.out.println("打乱排序：" + list);
	Collections.reverse(list);
	System.out.println("倒序排序：" + list);
	List<Integer> list1 = Arrays.asList(12, 1, 5, 8, 9, 6, 7);
	Collections.copy(list1, list);
	System.out.println("复制集合list1的元素：" + list1);
	System.out.println("集合最大值：" + Collections.max(list));
	System.out.println("集合最小值：" + Collections.min(list));
	Collections.fill(list, 100);
	System.out.println("list中元素替换成：" + list);
}

结果：

排序前：[2, 1, 3, 5, 4]
排序后：[1, 2, 3, 4, 5]
打乱排序：[4, 3, 5, 1, 2]
倒序排序：[2, 1, 5, 3, 4]
复制集合list1的元素：[2, 1, 5, 3, 4, 6, 7]
集合最大值：5
集合最小值：1
list中元素替换成：[100, 100, 100, 100, 100]

常用方法：

sort()：将集合内元素升序进行排序，被排序的集合必须实现Comparable接口，否则会出现异常

shuffle()： 打乱集合内元素可能存在的排序

Reverse()： 将集合内元素按倒序进行排序，不是降序，这个要注意

copy()： Collections.copy(targetList,sourceList)，targetList至少与sourceList一样长，否则会报异常。如果更长，targetList中剩余元素

不受影响

min()： 集合中最小值

max()： 集合中最大值

Fill()： 将集合的元素全部替换为指定元素

Arrays：

Arrays是数组的工具类，包含很多静态方法，用于对集合的各种操作

public static void main(String[] args) {
	Integer[] integers = new Integer[] {1, 3, 9, 2, 4, 88};
	System.out.print("排序前：");
	for (Integer integer : integers) {
		System.out.print(integer + " ");
	}
	Arrays.sort(integers);
	System.out.println("");
	System.out.print("排序后：");
	for (Integer integer : integers) {
		System.out.print(integer + " ");
	}
	Integer[] integers1 = new Integer[] {1, 3, 9, 2, 4, 88};
	Arrays.sort(integers1, 0, 4);
	System.out.println("");
	System.out.print("0-4之间进行排序后：");
	for (Integer integer : integers1) {
		System.out.print(integer + " ");
	}
	List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
	String s = Arrays.toString(integers);
	System.out.println("");
	System.out.println("数组integers转换成String：" + s);
	String s1 = Arrays.deepToString(integers);
	System.out.println("数组integers转换成String：" + s1);

	Integer[][] integers2 = new Integer[][] {{1, 3, 9},{ 2, 4, 88}};
	String s2 = Arrays.toString(integers2);
	System.out.println("数组integers转换成String：" + s2);
	String s3 = Arrays.deepToString(integers2);
	System.out.println("数组integers转换成String：" + s3);

	System.out.println("元素9的位置：" + Arrays.binarySearch(integers, 9));
	Integer[] integers3 = Arrays.copyOf(integers, 12);
	System.out.print("复制后的集合元素：");
	for (Integer integer : integers3) {
		System.out.print(integer + " ");
	}
	Arrays.fill(integers, 2);
	System.out.print("将集合元素全部替换成2：");
	for (Integer integer : integers) {
		System.out.print(integer + " ");
	}
	Integer[] integers4 = Arrays.copyOfRange(integers3, 0, 4);
	System.out.println("");
	System.out.print("只复制0-4区间的集合元素：");
	for (Integer integer : integers4) {
		System.out.print(integer + " ");
	}
}

结果：

排序前：1 3 9 2 4 88 
排序后：1 2 3 4 9 88 
0-4之间进行排序后：1 2 3 9 4 88 
数组integers转换成String：[1, 2, 3, 4, 9, 88]
数组integers转换成String：[1, 2, 3, 4, 9, 88]
数组integers转换成String：[[Ljava.lang.Integer;@1be6f5c3, [Ljava.lang.Integer;@6b884d57]
数组integers转换成String：[[1, 3, 9], [2, 4, 88]]
元素9的位置：4
复制后的集合元素：1 2 3 4 9 88 null null null null null null 将集合元素全部替换成2：2 2 2 2 2 2 
只复制0-4区间的集合元素：1 2 3 4 

sort(T[])：将数组内元素升序进行排序

sort(T[], fromIndex, toIndex)：将数组内部分元素区间升序进行排序，从fromIndex到toIndex，左开右闭

toString()：将一维数组转为String，无法将多维数组元素转换成String

deepToString()：将多维数组转为String，也可以转换一维数组

copyof(T[], newLength)：复制数组元素到新的数组，重新定义新数组的长度

copyOfRange(T[], from, to)：复制部分数组元素到新的数组，重新定义新数组的长度to-from

fill()： 将数组的元素全部替换为指定元素