Collection和Collections的区别

原创于 2017-03-06 15:55:08 发布 · 607 阅读

2 ·

CC 4.0 BY-SA版权

Java 专栏收录该内容

17 篇文章

订阅专栏

本文详细介绍了Java集合框架中的Collection接口及其子接口Set和List的区别，深入探讨了ArrayList和LinkedList的特点及适用场景，并提供了如何使ArrayList线程安全的方法。此外，还讲解了Collections工具类的各种实用方法，包括排序、混排、反转、替换所有元素、拷贝、查找最大最小值等。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、Collection

Collection是集合类的顶级接口，其派生了两个子接口Set和List：

1、Set：不可重复且无序

2、List：可重复且有序

List有两个重要的实现类，ArrayList和LinkedList。

ArrayList：动态数组，适用于随机访问，支持null，线程不安全；

LinkedList：双向链表，适用于批量插入和删除操作，线程不安全；

所谓的线程安全，指的是多线程访问时，采用了加锁机制。也就是当一个线程访问某个类的某个数据时，对数据进行保护，其他线程不能读取该数据，直到该线程读取完。

如果想要使ArrayList线程安全，有两个方法：

1)使用synchronize关键字，一般有两个用法。一是使用synchronize修饰方法或者静态方法；二是使用synchronize(this){ 需要同步的代码块 }；

2)使用Collection.synchronizeList()。用法如下：List<String> list1 = Collections.synchronizedList(new ArrayList<String>());

二、Collections

Collections则是集合类的一个工具类/帮助类，其中提供了一系列静态方法，用于对集合中元素进行排序、搜索以及线程安全等各种操作。

1、排序（sort）

可以根据元素的自然顺序，对指定列表按升序进行排序。

public static void main(String[] args) throws InterruptedException {
    	List<Integer> list=new ArrayList<Integer>();
    	int array[] = {2,55,6,443,776};
    	for (int i = 0; i < array.length; i++) {
    	list.add(array[i]);
    	}
    	Collections.sort(list);
    	for (int i = 0; i < array.length; i++) {
    	   System.out.print(list.get(i)+";");
    	}
    }

运行结果：2,6,55,443,776,

2、混排(shuffle)

随机排列。

 public static void main(String[] args) throws InterruptedException {
    	List<Integer> list=new ArrayList<Integer>();
    	int array[] = {2,55,6,443,776};
    	for (int i = 0; i < array.length; i++) {
    	list.add(array[i]);
    	}
    	Collections.shuffle(list);
    	for (int i = 0; i < array.length; i++) {
    	   System.out.print(list.get(i)+";");
    	}
    }

运行结果1：443,55,776,6,2,

运行结果2：2,55,776,6,443,

3、反转（reverse）

把原先顺序逆反。

public static void main(String[] args) throws InterruptedException {
    	List<Integer> list=new ArrayList<Integer>();
    	int array[] = {2,55,6,443,776};
    	for (int i = 0; i < array.length; i++) {
    	list.add(array[i]);
    	}
    	Collections.reverse(list);
    	for (int i = 0; i < array.length; i++) {
    	   System.out.print(list.get(i)+",");
    	}
    }

运行结果；776,443,6,55,2,

4、替换所有元素（fill）

public static void main(String[] args) throws InterruptedException {
    	List<Integer> list=new ArrayList<Integer>();
    	int array[] = {2,55,6,443,776};
    	for (int i = 0; i < array.length; i++) {
    	list.add(array[i]);
    	}
    	Collections.fill(list,33);
    	for (int i = 0; i < array.length; i++) {
    	   System.out.print(list.get(i)+",");
    	}
    }

运行结果：33,33,33,33,33,

5、拷贝（copy）

将原列表的元素复制并覆盖到新集合。

初始化时size的大小永远默认为0，只有在进行add和remove等相关操作时，size的大小才变化。然而进行copy()时候，首先做的是将目标列表的size

和原列表的size大小进行比较，只有当目标列表的 size 大于或者等于原列表的size时才能进行拷贝，否则抛出IndexOutOfBoundsException异常；

第一种方法：

public static void main(String[] args) throws InterruptedException {
    	List<String> src = new ArrayList<String>();  
  	  src.add("111");  
  	  src.add("222");  
  	  src.add("333");  
  	  src.add("444");  
  	  List<String> dic = new ArrayList<String>(Arrays.asList(new String[src  
  	    .size()]));  
  	  Collections.copy(dic, src);  
  	  for (Object s : dic) {  
  	   System.out.print(s+",");  
  	  }  
  	 }

运行结果：111,222,333,444,

第二种方法：

public static void main(String[] args) throws InterruptedException {
    	  List<String> src = new ArrayList<String>();  
    	  src.add("111");  
    	  src.add("222");  
    	  src.add("333");  
    	  src.add("444");  
    	  List<String> dest1  =   new  ArrayList<String>();  
    	  Collections.addAll(dest1,  new  String[src.size()]);  
    	  Collections.copy(dest1, src);  
    	  for (Object s : dest1) {  
    	   System.out.print(s+",");
    	  }
    }

运行结果：111,222,333,444,

6、max和min

返回列表的最大值和最小值。

public static void main(String[] args) throws InterruptedException {
    	List<String> src = new ArrayList<String>();  
  	  src.add("111");  
  	  src.add("222");  
  	  src.add("333");  
  	  src.add("444"); 
  	  System.out.println("max:"+Collections.max(src));
  	  System.out.println("min:"+Collections.min(src));
  	    
    }

运行结果：

max:444

min:111

7、lastIndexOfSubList(原列表，目标列表)

方法调用返回指定目标列表的最后出现的起始位置指定源列表，或者-1，如果没有这样发生。

      List arrlistsrc = new ArrayList();
      List arrlisttarget = new ArrayList();
      
      // populate two lists
      arrlistsrc.add("A");
      arrlistsrc.add("B");
      arrlistsrc.add("C");
      arrlistsrc.add("D");
      arrlistsrc.add("E"); 
      
      arrlisttarget.add("C");
      arrlisttarget.add("D");
      arrlisttarget.add("E");
           
      // check starting position of the last occurrenc
      int index = Collections.lastIndexOfSubList(arrlistsrc, arrlisttarget);
      
      System.out.println("Starting position is: "+index);

运行结果：Starting position is: 2

8、IndexOfSubList

返回指定源列表中第一次出现指定目标列表的起始位置

  List arrlistsrc = new ArrayList();
      List arrlisttarget = new ArrayList();
      
      // populate two lists
      arrlistsrc.add("A");
      arrlistsrc.add("B");
      arrlistsrc.add("C");
      arrlistsrc.add("D");
      arrlistsrc.add("E"); 
      
      arrlisttarget.add("C");
      arrlisttarget.add("D");
      arrlisttarget.add("E");
           
      // check starting position of the last occurrenc
      int index = Collections.indexOfSubList(arrlistsrc, arrlisttarget);
      
      System.out.println("Starting position is: "+index);

9、Rotate

根据指定的距离循环移动指定列表中的元素

public static void main(String[] args) throws InterruptedException {
    	double array[] = {112, 111, 23, 456, 231 };
    	List list = new ArrayList();
    	for (int i = 0; i < array.length; i++) {
    	list.add(new Double(array[i]));
    	}
    	Collections.rotate(list,2);
    	for (int i = 0; i <list.size(); i++) {
    		System.out.println("list[" + i + "]=" + list.get(i));
    	}
    }

运行结果：list[0]=456.0
list[1]=231.0
list[2]=112.0
list[3]=111.0
list[4]=23.0