Collection 接口是 List 接口和 Set 接口的父接口，通常情况下不被直接使用。Collection 接口定义了一些通用的方法，通过这些方法可以实现对集合的基本操作。因为 List 接口和 Set 接口继承自 Collection 接口，所以也可以调用这些方法。

本节将介绍 Collection 接口中常用的方法，如表 1 所示。

例 1

经过前面的介绍，我们知道 Collection 是非常重要的一个接口，在表 1 中列出了其常用方法。本案例将编写一个简单的程序，演示如何使用 Collection 接口向集合中添加方法。具体实现代码如下：

1.	public static void main(Strmg[] args)
2.	{
3.	    ArrayList list1=new ArrayList();    //创建集合 iist1
4.	    ArrayList list2=new ArrayList();    //创建集合 Iist2
5.	    list1.add("one");    //向 list1 添加一个元素
6.	    list1.add("two");    //向 list1 添加一个元素
7.	    list2.addAll(list1);    //将 list1 的所有元素添加到 list2
8.	    list2.add("three");    //向 list2 添加一个元素
9.	    System.out.println("list2 集合中的元素如下：");
10.	    Iterator it1=list2.iterator();
11.	    while(it1.hasNext())
12.	    {
13.	        System.out.print(it1.next()+"、");
14.	    }
15.	}

由于 Collection 是接口，不能对其实例化，所以上述代码中使用了 Collection 接口的 ArrayList 实现类来调用 Collection 的方法。add() 方法可以向 Collection 中添加一个元素，而调用 addAll() 方法可以将指定 Collection 中的所有元素添加到另一个 Collection 中。代码创建了两个集合 list1 和 list2，然后调用 add() 方法向 list1 中添加了两个元素，再调用 addAll() 方法将这两个元素添加到 list2 中。接下来又向 list2 中添加了一个元素，最后输出 list2 集合中的所有元素，结果如下：

list2 集合中的元素如下：
one、two、three、

例 2

创建一个案例，演示 Collection 集合中 size()、remove() 和 removeAll() 方法的应用。具体代码如下：

1.	public static void main(String[] args)
2.	{
3.	    ArrayList list1=new ArrayList();    //创建集合 list1
4.	    ArrayList list2=new ArrayList();    //创建集合 list2
5.	    list1.add("one");
6.	    list1.add("two");
7.	    list1.add("three");
8.	    System.out.println("list1 集合中的元素数量："+list1.size());    //输出list1中的元素数量
9.	    list2.add("two");
10.	    list2.add("four");
11.	    list2.add("six");
12.	    System.out.println("list2 集合中的元素数量："+list2.size());     //输出list2中的元素数量
13.	    list2.remove(2);    //删除第 3 个元素
14.	    System.out.println("\nremoveAll() 方法之后 list2 集合中的元素数量："+list2.size());
15.	    System.out.println("list2 集合中的元素如下：");
16.	    Iterator it1=list2.iterator();
17.	    while(it1.hasNext())
18.	    {
19.	        System.out.print(it1.next()+"、");
20.	    }
21.	    list1.removeAll(list2);
22.	    System.out.println("\nremoveAll() 方法之后 list1 集合中的元素数量："+list1.size());
23.	    System.out.println("list1 集合中的元素如下：");
24.	    Iterator it2=list1.iterator();
25.	    while(it2.hasNext())
26.	    {
27.	        System.out.print(it2.next()+"、");
28.	    }
29.	}

list2 集合在调用 remove(2) 方法删除第 3 个元素之后剩下了 two 和 four。list1.removeAll(list2) 语句会从 list1 中将 list1 和 list2 中相同的元素删除，即删除 two 元素。最后输出结果如下：

list1 集合中的元素数量：3
Iist2 集合中的元素数量：3
remove() 方法之后 list2 集合中的元素数量：2
list2 集合中的元素如下：
two、four、
removeAH() 方法之后 list1 集合中的元素数量：2
list1 集合中的元素如下：
one、 three、

注意：retainAll() 方法的作用与 removeAll() 方法相反，即保留两个集合中相同的元素，其他全部删除。

三、Java Collection类：sort()升序排序、reverse()降序排序、copy()复制、fill()填充

Collections 类提供了许多操作集合的静态方法，借助这些静态方法可以实现集合元素的排序、填充和复制等操作。下面介绍 Collections 类中操作集合的常用方法。

1.正向排序

使用 Collections 类的静态方法 sort() 可以对集合中的元素进行升序排序。这要求列表中的所有元素都必须实现 Comparable 接口，而且所有元素都必须是使用指定比较器可相互比较的。sort() 方法主要有如下两种重载形式。

1. void sort(List list)：根据元素的自然顺序对集合中的元素进行升序排序。
2. void sort(List list,Comparator comparator)：按 comparator 参数指定的排序方式对集合中的元素进行排序。

例 1

编写一个程序，对用户输入的 5 个商品价格进行排序后输出。这里要求使用 Collections 类中 sort() 方法按从低到局的顺序对其进行排序，最后将排序后的成绩输出。具体实现代码如下：

1.	import java.util.ArrayList;
2.	import java.util.Collections;
3.	import java.util.List;
4.	import java.util.Scanner;
5.	public class Test10
6.	{
7.	    public static void main(String[] args)
8.	    {
9.	        Scanner input=new Scanner(System.in);
10.	        List prices=new ArrayList();
11.	        for(int i=0;i<5;i++)
12.	        {
13.	            System.out.println("请输入第 "+(i+1)+" 个商品的价格：");
14.	            int p=input.nextInt();
15.	            prices.add(Integer.valueOf(p));    //将录入的价格保存到List集合中
16.	        }
17.	        Collections.sort(prices);    //调用sort()方法对集合进行排序
18.	        System.out.println("价格从低到高的排列为：");
19.	        for(int i=0;i<prices.size();i++)
20.	        {
21.	            System.out.print(prices.get(i)+"\t");
22.	        }
23.	    }
24.	}

如上述代码，循环录入 5 个价格，并将每个价格都存储到已定义好的 List 集合 prices 中，然后使用 Collections 类的 sort() 方法对该集合元素进行升序排序。最后使用 for 循环遍历 users 集合，输出该集合中的元素。该程序的执行结果如下所示。

请输入第 1 个商品的价格：
85
请输入第 2 个商品的价格：
48
请输入第 3 个商品的价格：
66
请输入第 4 个商品的价格：
80
请输入第 5 个商品的价格：
18
价格从低到高的排列为：
18    48    66    80    85

2.逆向排序

与 sort() 方法的作用相反，调用 reverse() 静态方法可以对指定集合元素进行逆向排序。

该方法的定义如下：

void reverse(List list)    //对集合中的元素进行反转排序

例 2

循环录入 5 个商品的名称，并按录入时间的先后顺序进行降序排序，即后录入的先输出。下面编写程序，使用 Collections 类的 reverse() 方法对保存到 List 集合中的 5 个商品名称进行反转排序，并输出排序后的商品信息。具体的实现代码如下：

1.	import java.util.ArrayList;
2.	import java.util.Coliections;
3.	import java.util.List;
4.	import java.util.Scanner;
5.	public class Test11
6.	{
7.	    public static void main(String[] args)
8.	    {
9.	        Scanner input=new Scanner(System.in);
10.	        List students=new ArrayList();
11.	        System.out.println("******** 商品信息 ********");
12.	        for(int i=0;i<5;i++)
13.	        {
14.	            System.out.println("请输入第 "+(i+1)+" 个商品的名称：");
15.	            String name=input.next();
16.	            students.add(name);    //将录入的商品名称存到List集合中
17.	        }
18.	        Collections.reverse(students);    //调用reverse()方法对集合元素进行反转排序
19.	        System.out.println("按录入时间的先后顺序进行降序排列为：");
20.	        for(int i=0;i<5;i++)
21.	        {
22.	            System.out.print(students.get(i)+"\t");
23.	        }
24.	    }
25.	}

如上述代码，首先循环录入 5 个商品的名称，并将这些名称保存到 List 集合中，然后调用 Collections 类中的 reverse() 方法对该集合元素进行反转排序。最后使用 for 循环将排序后的集合元素输出。执行该程序，输出结果如下所示。

******** 商品信息 ********
请输入第 1 个商品的名称：
果粒橙
请输入第 2 个商品的名称：
冰红茶
请输入第 3 个商品的名称：
矿泉水
请输入第 4 个商品的名称：
软面包
请输入第 5 个商品的名称：
巧克力
按录入时间的先后顺序进行降序排列为：
巧克力    软面包    矿泉水    冰红茶    果粒橙   

3.复制

Collections 类的 copy() 静态方法用于将指定集合中的所有元素复制到另一个集合中。执行 copy() 方法后，目标集合中每个已复制元素的索引将等同于源集合中该元素的索引。

copy() 方法的语法格式如下：

void copy(List <? super T> dest,List<? extends T> src)

其中，dest 表示目标集合对象，src 表示源集合对象。

注意：目标集合的长度至少和源集合的长度相同，如果目标集合的长度更长，则不影响目标集合中的其余元素。如果目标集合长度不够而无法包含整个源集合元素，程序将抛出 IndexOutOfBoundsException 异常。

例 3

在一个集合中保存了 5 个商品名称，现在要使用 Collections 类中的 copy() 方法将其中的 3 个替换掉。具体实现的代码如下：

1.	public class Test12
2.	{
3.	    public static void main(String[] args)
4.	    {
5.	        Scanner input=new Scanner(System.in);
6.	        List srcList=new ArrayList();
7.	        List destList=new ArrayList();
8.	        destList.add("苏打水");
9.	        destList.add("木糖醇");
10.	        destList.add("方便面");
11.	        destList.add("火腿肠");
12.	        destList.add("冰红茶");
13.	        System.out.println("原有商品如下：");
14.	        for(int i=0;i<destList.size();i++)
15.	        {
16.	            System.out.println(destList.get(i));
17.	        }
18.	        System.out.println("输入替换的商品名称：");
19.	        for(int i=0;i<3;i++)
20.	        {
21.	            System.out.println("第 "+(i+1)+" 个商品：");
22.	            String name=input.next();
23.	            srcList.add(name);
24.	        }
25.	        //调用copy()方法将当前商品信息复制到原有商品信息集合中
26.	        Collections.copy(destList,srcList);
27.	        System.out.println("当前商品有：");
28.	        for(int i=0;i<destList.size();i++)
29.	        {
30.	            System.out.print(destList.get(i)+"\t");
31.	        }
32.	    }
33.	}

如上述代码，首先创建了两个 List 对象 srcList 和 destList，并向 destList 集合中添加了 5 个元素，向 srcList 集合中添加了 3 个元素，然后调用 Collections 类中 copy() 方法将 srcList 集合中的全部元素复制到 destList 集合中。由于 destList 集合中含有 5 个元素，故最后两个元素不会被覆盖。运行该程序，具体的执行结果如下所示。

原有商品如下：
苏打水
木糖醇
方便面
火腿肠
冰红茶
输入替换的商品名称：
第 1 个商品：
燕麦片
第 2 个商品：
八宝粥
第 3 个商品：
软面包
当前商品有：
燕麦片    八宝粥   软面包    火腿肠    冰红茶

4.填充

Collections 类的 fill() 静态方法可以对指定集合的所有元素进行填充操作。fill() 方法的定义如下:

void fill(List<? super T> list,T obj)    //使用指定元素替换指定列表中的所有元素

其中，list 表示要替换的集合对象，obj 表示用来替换指定集合的元素值。

例 4

编写一个程序，要求用户输入 3 个商品名称，然后使用 Collections 类中的 fill() 方法对商品信息进行重置操作，即将所有名称都更改为“未填写”。具体的实现代码如下：

1.	import java.util.ArrayList;
2.	import java.util.Collections;
3.	import java.util.List;
4.	import java.util.Scanner;
5.	public class Test13
6.	{
7.	    public static void main(String[] args)
8.	    {
9.	        Scanner input=new Scanner(System.in);
10.	        List products=new ArrayList();
11.	        System.out.println("******** 商品信息 ********");
12.	        for(int i=0;i<3;i++)
13.	        {
14.	            System.out.println("请输入第 "+(i+1)+" 个商品的名称：");
15.	            String name=input.next();
16.	            products.add(name);    //将用户录入的商品名称保存到List集合中
17.	        }
18.	        System.out.println("重置商品信息，将所有名称都更改为'未填写'");
19.	        Collections.fill(products,"未填写");
20.	        System.out.println("重置后的商品信息为：");
21.	        for(int i=0;i<products.size();i++)
22.	        {
23.	            System.out.print(products.get(i)+"\t");
24.	        }
25.	    }
26.	}

如上述代码，首先循环录入 3 个商品名称，并将这些商品信息存储到 List 集合中，然后调用 Collections 类中的 fill() 方法将该集合中的所有元素值替换为“未填写”。最后使用 for 循环将替换后的集合元素输出。运行该程序，执行结果如下所示。

******** 商品信息 ********
请输入第 1 个商品的名称：
苏打水
请输入第 2 个商品的名称：
矿泉水
请输入第 3 个商品的名称：
冰红茶
重置商品信息，将所有名称都更改为'未填写'
重置后的商品信息为：
未填写    未填写    未填写    

四、Java List集合：ArrayList类、LinkList类、ArrayList类和LinkList类的区别

List 接口实现了 Collection 接口，它主要有两个实现类：ArrayList 类和 LinkedList 类。在 List 集合中允许出现重复元素。与 Set 集合不同的是，在 List 集合中的元素是有序的，可以根据索引位置来检索 List 集合中的元素，第一个添加到 List 集合中的元素的索引为 0，第二个为 1，依此类推。

1.ArrayList 类

ArrayList 类提供了快速的基于索引的成员访问方式，对尾部成员的增加和删除支持较好。使用 ArrayList 创建的集合，允许对集合中的元素进行快速的随机访问，不过，向 ArrayList 中插入与删除元素的速度相对较慢。该类的常用构造方法有如下两种重载形式。

• ArrayList()：构造一个初始容量为 10 的空列表。
• ArrayList(Collection<?extends E>c)：构造一个包含指定 Collection 的元素的列表，这些元素是按照该 Collection 的迭代器返回它们的顺序排列的。

ArrayList 类除了包含 Collection 接口中的所有方法之外，还包括 List 接口中提供的如表 1 所示的方法。  

例 1

使用 ArrayList 类向集合中添加三个商品信息，包括商品编号、名称和价格，然后遍历集合输出这些商品信息。(1) 创建一个商品类 Product，在该类中定义 3 个属性和 toString() 方法，分别实现 setter/getter 方法。代码的实现如下：

1.	public class Product
2.	{   
3.	    //商品类
4.	    private int id;    //商品编号
5.	    private String name;    //名称
6.	    private float price;    //价格
7.	    public Product(int id,String name,float price)
8.	    {
9.	        this.name=name;
10.	        this.id=id;
11.	        this.price=price;
12.	    }
13.	    //这里是上面3个属性的setter/getter方法，这里省略
14.	    public String toString()
15.	    {
16.	        return"商品编号："+id+"，名称:"+name+"，价格："+price;
17.	    }
18.	}

(2) 创建一个测试类，调用 Product 类的构造函数实例化三个对象，并将 Product 对象保存至 ArrayList 集合中。最后遍历该集合，输出商品信息。测试类的代码实现如下：

1.	import Java.util.ArrayList;
2.	import java.util.List;
3.	public class Test03
4.	{
5.	    public static void main(String[] args)
6.	    {
7.	        Product pd1=new Product(4,"木糖醇",10);
8.	        Product pd2=new Product(5,"洗发水",12);
9.	        Product pd3=new Product(3,"热水壶",49);
10.	        List list=new ArrayList();    //创建集合
11.	        list.add(pd1);
12.	        list.add(pd2);
13.	        list.add(pd3);
14.	        System.out.println("*************** 商品信息 ***************");
15.	        for(int i=0;i<list.size();i++)
16.	        {
17.	            //循环遍历集合，输出集合元素
18.	            Product product=(Product)list.get(i);
19.	            System.out.println(product);
20.	        }
21.	    }
22.	}