集合（Collection解析 Set List Map三大集合运用）

集合的概念:

         集合是包含多个对象的简单对象，所包含的对象称为元素。集合里面可以包含任意多个对象，数量可以变化；同时对对象的类型也没有限制，也就是说集合里面的所有对象的类型可以相同，也可以不同。

集合与数组的特点对比:

集合：数量不限、类型不限
数组：定长、类型单一

“集合框架”由一组用来操作对象的接口组成，不同接口描述不同类型的组

数据存储结构分类:

（1）顺序存储             （2）链式存储        （3）树形存储      （4）散列存储Hash    （5）Map映射存储

 

接口	实现	历史集合类
Set	HashSet
	TreeSet
List	ArrayList	Vector
	LinkedList	Stack
Map	HashMap	Hashtable
	TreeMap	Properties

集合框架中各接口的特点:

1：Collection接口               是一组允许重复的对象。

2：Set接口                            继承Collection，无序但不允许重复。

3：List接口                            继承Collection，有序但允许重复，并引入位置下标。

4：Map接口                          既不继承Set也不继承Collection，是键值对。

Collection接口：

    用于表示任何对象或元素组。想要尽可能以常规方式处理一组元素时，就使用这一接口。

用此接口必须要它的实现类，如

Collection<T> col=new HashSet<T>(0);

 

collection接口具有如下函数操作：

方法摘要
boolean	add(E e)            确保此 collection 包含指定的元素（可选操作）。
boolean	addAll(Collection<? extends E> c)            将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。
void	clear()            移除此 collection 中的所有元素（可选操作）。
boolean	contains(Object o)            如果此 collection 包含指定的元素，则返回 true。
boolean	containsAll(Collection<?> c)            如果此 collection 包含指定 collection 中的所有元素，则返回 true。
boolean	equals(Object o)            比较此 collection 与指定对象是否相等。
int	hashCode()            返回此 collection 的哈希码值。
boolean	isEmpty()            如果此 collection 不包含元素，则返回 true。
Iterator<E>	iterator()            返回在此 collection 的元素上进行迭代的迭代器。
boolean	remove(Object o)            从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。
boolean	removeAll(Collection<?> c)            移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。
boolean	retainAll(Collection<?> c)            仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。
int	size()            返回此 collection 中的元素数。
Object[]	toArray()            返回包含此 collection 中所有元素的数组。
<T> T[]	toArray(T[] a)            返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。

  

Set接口：

          按照定义，Set接口继承Collection接口，而且它不允许集合中存在重复项。所有原始方法都是Collection中现成的，没有引入新方法

 

HashSet接口

1.  
   <pre name="code" class="java">//可初定义容量大小为0
2.  
   //Set是接口，必须new它的实现类
3.  
   //HashSet是一组不
4.  
   Set<Object> set=new HashSet<Object>(0);
5.  
   Set<Object> set2=new HashSet<Object>(0);
6.  
   Person p1=new Person("张三",20);
7.  
   Person p2=new Person("李四",22);
8.  
   Person p3=new Person("王五",24);
9.  
   Person p4=new Person("Jack",30);
10.  
    Person p5=new Person("Tom",20);
11.  
    Person p6=new Person("Swite",13);
12.  
    Person p7=new Person("Pick",16);
13.  
    Person p8=new Person("钱七",32);
14.  
    //添加元素，集合容量会增加（JAVA类中有操作），返回型boolean
15.  
    //注意添加的是元素的地址，改变集合中的一个元素，另一集合的相同元素同样改变
16.  
    //添加顺序是根据Hash算法排序的，因此需要实现添加元素的hashCode和equals函数
17.  
    //不然按该元素的内存地址排序
18.  
    set.add(p1);set2.add(p1);
19.  
    System.out.println(set.add(p1));//返回FALSE，已加入元素不会重复添加
20.  
    set.add(p5);set2.add(p5);
21.  
    set.add(p6);set2.add(p6);
22.  
    set.add(p4);set2.add(p7);
23.  
    set.add(p2);set2.add(p8);
24.  
    set.add(p3);
25.  
    //在set2中元素全部加入,有添加的元素，返回true
26.  
    set.addAll(set2);
27.  
    //将集合的所有元素清空
28.  
    set.clear();
29.  
    //判断集合中有无此元素，有则返回true,
30.  
    set.contains(p1);
31.  
    //判断集合set2中的元素是否在set集合中都有,返回boolean值
32.  
    set.containsAll(set2);
33.  
    //判断参数对象与此对象的相等性
34.  
    set.equals(p1);//false(即使集合中只有p1，也不会相等，因为是不同对象)
35.  
    //若俩个集合中的元素相等，则俩个集合相等，
36.  
    set.equals(set2);//false
37.  
    //判断集合是否是空
38.  
    set.isEmpty();
39.  
    //获得集合元素的个数
40.  
    set.size();
41.  
    //移除集合的某一个元素,返回boolean值，没有则返回false
42.  
    set.remove(p1);
43.  
    //移除既在参数集合中存在，又在此集合中存在的元素，取差集,返回值boolean值
44.  
    set.removeAll(set2);
45.  
    //移除不存在参数集合中的本集合元素，取交集，返回值boolean值
46.  
    set.retainAll(set2);
47.  
    //返回集合的迭代器，以便搜索集合的元素
48.  
    //因为HashSet是按哈希值存储，不便直接定位
49.  
    Iterator<Object> it =set.iterator();
50.  
    while(it.hasNext()){
51.  
    //依次输出集合的每一个元素的toString()
52.  
    System.out.println(it.next());
53.  
    }

TreeSet

是一组能够排序的的集合，但是要注意：

1：被添加的元素必须实现comparator接口

2：覆盖其中的compareTo函数

3：后添加的元素会调动自身的compareTo函数，与集合中已有元素进行比较（集合按从小到大排序），一般会将其强转成相同类比较（除非自己写时准许）

4：java中有14类实现了comparator接口，分别是：

             1、BigDecimal,BigInteger,Byte,Double,Float,Integer,Long,Short按数字大小排序
             2、Character 按Unicode值的数字大小排序
             3、CollationKey 按语言环境敏感的字符串排序
             4、Date 按年代排序
             5、File 按系统特定的路径名的全限定字符的Unicode值排序
             6、ObjectStreamField 按名字中字符的Unicode值排序
             7、String 按字符串中字符Unicode值排序

5：当集合元素不实现comparator接口是，需要在new集合时添加自定义的比较器，

1.  
   public class TreeSetDome {
2.  
    
3.  
   public static void main(String[] args) {
4.  
   <span style="color:#ff0000;">//TreeSet具有set接口的所有函数（上面的函数）</span>
5.  
   //在new时可以加入指定的比较器
6.  
   TreeSet<Object> set=new TreeSet<Object>(new MyComp());
7.  
   Person p1=new Person("张三",20);
8.  
   //TreeSet具有其他函数
9.  
   //返回此 set 中大于等于给定元素的最小元素；如果不存在这样的元素，则返回 null
10.  
    set.ceiling(p1);
11.  
    //返回对此 set 中的元素进行排序的比较器；如果此 set 使用其元素的自然顺序，则返回 null。
12.  
    set.floor(p1);
13.  
    //返回此 set 中严格大于给定元素的最小元素；如果不存在这样的元素，则返回 null。
14.  
    set.comparator();
15.  
    //返回此 set 中当前第一个（最低）元素。
16.  
    set.first();
17.  
    //返回此 set 中当前最后一个（最高）元素。
18.  
    set.last();
19.  
    //返回此 set 中小于等于给定元素的最大元素；如果不存在这样的元素，则返回 null。
20.  
    set.higher(p1);
21.  
    //返回此 set 中严格小于给定元素的最大元素；如果不存在这样的元素，则返回 null。
22.  
    set.lower(p1);
23.  
    //获取并移除第一个（最低）元素；如果此 set 为空，则返回 null。
24.  
    set.pollFirst();
25.  
    //获取并移除最后一个（最高）元素；如果此 set 为空，则返回 null。
26.  
    set.pollLast();
27.  
     
28.  
    }
29.  
     
30.  
     
31.  
    }
32.  
    class MyComp implements Comparator<Object>{
33.  
     
34.  
    @Override
35.  
    public int compare(Object o1, Object o2) {
36.  
    //返回值为负整数，0，正整数（int型）
37.  
    //表示本对象比参数对象小，相等，大
38.  
    return 1;
39.  
    }
40.  
    }

List接口

List接口继承了Collection接口以定义一个允许重复项的有序集合。该接口不但能够对列表的一部分进行处理，还添加了面向位置的操作。面向位置的操作包括插入某个元素或Collection的功能，还包括获取、除去或更改元素的功能。在List中搜索元素可以从列表的头部或尾部开始，如果找到元素，还将报告元素所在的位置。

1）使用List（如ArrayList）时，不会自动调用hashCode()方法。因为在List中，重复了就重复了，不需判断，保证唯一性。

2）List中添加了下标index的功能，这样对List的修改可以利用set方法对指定位置的元素直接进行替换，不需要象Set那么复杂（要转换成数组才能修改，之后还要转换回去）。

3）Collection用Iterator迭代器，而List可以用ListIterator列表迭代器。前者只能next()，后者不但包含next()方法，还包含previous()方法。因此，如果要用List做类似书的翻页功能，不但可以向后翻，还可以向前翻。

1.  
   package cn.hncu.collection;
2.  
    
3.  
   import java.util.ArrayList;
4.  
   import java.util.Iterator;
5.  
   import java.util.ListIterator;
6.  
    
7.  
   public class ArrayListDome {
8.  
    
9.  
   public static void main(String[] args) {
10.  
    //List接口引入了下标,并且可以添加重复的元素
11.  
    ArrayList<Object> al1=new ArrayList<Object>(0);
12.  
    ArrayList<Object> al2=new ArrayList<Object>(0);
13.  
    Person p1=new Person("张三",20);
14.  
    Person p2=new Person("李四",22);
15.  
    Person p3=new Person("王五",24);
16.  
    Person p4=new Person("Jack",30);
17.  
    Person p5=new Person("Tom",20);
18.  
    Person p6=new Person("Swite",13);
19.  
    Person p7=new Person("Pick",16);
20.  
    Person p8=new Person("钱七",32);
21.  
    //添加时，根据下标位置排序，无需实现元素的hashCode和equals方法
22.  
    //可以指定下标添加，但要注意，不能加入的下标大小比集合容量大，否则出异常
23.  
    al1.add(p1);
24.  
    al1.add(0,p2);
25.  
    al1.add(al1.size()-1,p3);
26.  
    al1.add(p4);
27.  
    al1.add(p5);
28.  
    al1.add(0,p6);
29.  
    al2.add(p2);
30.  
    al2.add(p4);
31.  
    al2.add(p6);
32.  
    al2.add(p8);
33.  
     
34.  
    //可以添加其他集合的指定位置
35.  
    al1.addAll(0, al2);
36.  
    //返回此列表中指定位置上的元素。
37.  
    al1.get(0);
38.  
    //返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。
39.  
    al1.indexOf(p1);
40.  
    //返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。
41.  
    al1.lastIndexOf(p1);
42.  
    //移除此列表中指定位置上的元素。
43.  
    al1.remove(0);
44.  
    //用指定的元素替代此列表中指定位置上的元素。
45.  
    al1.set(0, p2);
46.  
    //按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组。
47.  
    al1.toArray();
48.  
    //按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。
49.  
    Person[] a = new Person[0];
50.  
    a=al1.toArray(a);
51.  
    //将此 ArrayList 实例的容量调整为列表的当前大小。
52.  
    al1.trimToSize();
53.  
    //返回列表中索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素组成一个新的集合列表。
54.  
    al1.subList(0, 1);
55.  
     
56.  
     
57.  
     
58.  
    //返回此 ArrayList 实例的浅表副本。只是复制了指针，俩个集合共用元素
59.  
    ArrayList<Object> po=(ArrayList<Object>) al1.clone();
60.  
    ((Person)al1.get(0)).age=10000;
61.  
    ((Person)al2.get(0)).age=-300;
62.  
    for (int i = 0; i < po.size(); i++) {
63.  
    System.out.println(po.get(i));
64.  
    }
65.  
    //返回列表的迭代器
66.  
    ListIterator it=al1.listIterator();
67.  
    while(it.hasNext()){
68.  
    System.out.println(it.next());//当前的下一个
69.  
    System.out.println(it.previous());//当前的上一个
70.  
    }
71.  
     
72.  
    }
73.  
     
74.  
    }

LickedList

如果要支持随机访问，而不必在除尾部的任何位置插入或除去元素，那么，ArrayList提供了可选的集合。(查找)

但如果要频繁的从列表的中间位置添加和除去元素，而只要顺序的访问列表元素，那么LinkedList实现更好（添加，删除）

1.  
   //构造空的
2.  
   LinkedList list=new LinkedList();
3.  
    
4.  
   Person p1=new Person("张三",20);
5.  
    
6.  
   <span style="color:#ff0000;">//链表也具有排序和下标功能,ArrayList的函数</span>
7.  
   //将指定元素插入此列表的开头。
8.  
   list.addFirst(p1);
9.  
   list.offerFirst(p1);
10.  
    //将指定元素添加到此列表的结尾。
11.  
    list.addLast(p1);
12.  
    list.offer(p1);
13.  
    list.offerLast(p1);
14.  
    // 获取但不移除此列表的头（第一个元素）。
15.  
    list.element();
16.  
    list.get(0);
17.  
    list.getFirst();
18.  
    list.peek();
19.  
    list.peekFirst();//没有返回空
20.  
    //获取并移除此列表的头（第一个元素）
21.  
    list.pop();
22.  
    list.pollFirst();//没有返回空
23.  
    list.remove(0);
24.  
    list.removeFirst();
25.  
    //移 不移除列表的尾而获得同头部;
26.  
    list.peekLast();
27.  
    list.getLast();
28.  
     
29.  
    list.pollLast();
30.  
    list.removeLast();
31.  
    //从此列表中移除第一次出现的指定元素（从头部到尾部遍历列表时）。
32.  
    list.removeFirstOccurrence(p1);
33.  
    //从此列表中移除最后一次出现的指定元素（从头部到尾部遍历列表时）。
34.  
    list.removeLastOccurrence(p1);

利用ArrayList和LinkedList做队列和栈

1.  
   ArrayList<Object> al=new ArrayList<Object>(0);
2.  
    
3.  
   public void push(Object obj){
4.  
   al.add(obj);
5.  
   }
6.  
   public Object pop(){
7.  
   if(!al.isEmpty())
8.  
   return al.remove(0);
9.  
   return null;
10.  
    }
11.  
     
12.  
    public boolean isEmpty(){
13.  
    return al.isEmpty();
14.  
    }

1.  
   ArrayList<Object> al=new ArrayList<Object>(0);
2.  
    
3.  
   public void push(Object obj){
4.  
   al.add(obj);
5.  
   }
6.  
   public Object pop(){
7.  
   if(!al.isEmpty())
8.  
   return al.remove(al.size()-1);
9.  
   return null;
10.  
    }
11.  
     
12.  
    public boolean isEmpty(){
13.  
    return al.isEmpty();
14.  
    }

1.  
   LinkedList<Object> lkl=new LinkedList<Object>();
2.  
    
3.  
   public void push(Object obj){
4.  
   lkl.add(obj);
5.  
   }
6.  
   public Object pop(){
7.  
   return lkl.poll();
8.  
   }
9.  
    
10.  
    public boolean isEmpty(){
11.  
    return lkl.isEmpty();
12.  
    }

1.  
   LinkedList<Object> lkl=new LinkedList<Object>();
2.  
    
3.  
   public void push(Object obj){
4.  
   lkl.add(obj);
5.  
   }
6.  
   public Object pop(){
7.  
   return lkl.pollLast();
8.  
   }
9.  
    
10.  
    public boolean isEmpty(){
11.  
    return lkl.isEmpty();
12.  
    }

Map集合

Map接口不是Collection接口的继承。而是从自己的用于维护键-值关联的接口层次结构入手。按定义，该接口描述了从不重复的键到值的映射。

可以把这个接口方法分成三组操作：改变、查询和提供可选视图。

改变操作允许从映射中添加和除去键-值对。键和值都可以为null。但是，不能把Map作为一个键或值添加给自身

1.  
   HashMap<String, Object> map=new HashMap<String, Object>(0);
2.  
   Person p1=new Person("张三",20);
3.  
   Person p2=new Person("李四",22);
4.  
   Person p3=new Person("王五",24);
5.  
   Person p4=new Person("Jack",30);
6.  
   Person p5=new Person("Tom",20);
7.  
   Person p6=new Person("Swite",13);
8.  
    
9.  
   //键-值添加，put函数
10.  
    map.put("1001", p1);
11.  
    map.put("1002", p2);
12.  
    map.put("1003", p3);
13.  
    map.put("1004", p4);
14.  
    map.put("1005", p5);
15.  
    map.put("1006", p6);
16.  
    //返回指定键所映射的值；如果对于该键来说，此映射不包含任何映射关系，则返回 null。
17.  
    map.get("1001");
18.  
    //从此映射中移除指定键的映射关系（如果存在）。
19.  
    map.remove("1001");
20.  
    //移除集合
21.  
    map.clear();
22.  
    //entry视图
23.  
    Set<Map.Entry<String, Object>> entry=map.entrySet();
24.  
    Iterator<Map.Entry<String, Object>> it=entry.iterator();
25.  
    while(it.hasNext()){
26.  
    Map.Entry<String, Object> en=it.next();
27.  
    System.out.println(en.getKey()+" "+en.getValue());
28.  
    }
29.  
    System.out.println("------------------");
30.  
    //key视图
31.  
    Set<String> keys=map.keySet();
32.  
    Iterator<String> it2=keys.iterator();
33.  
    while(it2.hasNext()){
34.  
    String str=it2.next();
35.  
    System.out.println(str+" "+map.get(str));
36.  
    }
37.  
    System.out.println("------------------");
38.  
    //values视图（不常用）
39.  
    Collection<Object> values=map.values();
40.  
    Iterator<Object> it3=values.iterator();
41.  
    while(it3.hasNext()){
42.  
    Object obj=it3.next();
43.  
    System.out.println(obj);
44.  
    }

TreeMap

与TreeSet一样，具有排序功能，且排序要求一样。

“集合框架”提供两种常规的Map实现：HashMap和TreeMap。和所有的具体实现一样，使用哪种实现取决于特定需要。

在Map中插入、删除和定位元素，HashMap是最好的选择。但如果要按顺序遍历键，那么TreeMap会更好。

使用HashMap要求添加的键类明确定义了hashCode()实现（助理解：Map.keySet返回的是键的Set集合，而Set集合对hashCode实现有限制，因此作为键的类也要遵守该限制）。有了TreeMap实现，添加到映射的元素一定是可排序的。

中文排序问题

比较函数对于英文字母与数字等ASCII码中的字符排序都没问题，但中文排序则明显不正确。这主要是Java中使用中文编码GB2312或GBK时，char型转换成int型的过程出现了比较大的偏差。这偏差是由compare方法导致的，因此我们可以自己实现Comparator接口。另外，国际化问题可用Collator类来解决。

java.text.Collator类，提供以与自然语言无关的方式来处理文本、日期、数字和消息的类和接口。