集合－有时候被称为容器， 就像一手牌（牌的结合），一个邮箱（邮件的集合），或者一个电话簿（姓名和电话对应的关系图）

集合框架核心接口图

   

 

·         Collection对集合核心接口的说明，所有的集合都实现了Collection这个接口，java没有类直接实现了Collection这个接口而是通过更加具体的子接口，比如Set and List

·         Set 不能放重复元素添加重复的元素将毫无用处

·         List 有顺序的集合，可以存放重复的元素

·         Queue 先进先出的集合FIFO (first-in-first-out)

·         Map 用键值对的关系来存储数据，键值不能重复，一个键只能对应一个值

·         SortedSet, SortedMap分别是Set和map的排序版本

Collection 接口：集合框架中的最顶的接口，集合中最抽象的一个接口

·         需要注意的方法：addAll

boolean addAll(Collection c) 将另外一个集合中的所有元素添加到这个集合中，

而如果用add（）方法则是把集合C按照一个元素添加进去。

Set 接口：不能放重复的元素的集合。在java中有三种主要的实现

 HashSet, TreeSet, and LinkedHashSet

·         HashSet效率最高，但是不能保证集合里面的元素是按顺序读取的

·         TreeSet 通过所存储的元素的值对元素进行排序，比HashSet慢

·         LinkedHashSet 通过集合里面的元素插入的时候的顺序进行排序

Eg1

import java.util.*;

public class TestSet {

    public static void main(String args[]) {

        Set s = new HashSet();

        String test[]={"java", "FindDups" ,"i" ,"came", "i", "saw", "i", "left"};

        String a;

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

       

        a=test[i];

            if (!s.add(a))

                System.out.println("Duplicate: " + a);

        System.out.println(s.size()+" distinct words: "+s);

    }

}

}

需要注意的一点是代码中一直引用的是 (Set)这个接口而不是具体的实现类(HashSet).这样做的好处就是给你的程序带来了很好的适应性。上面的例子中的输出是没有经过排序的，如果你希望进行排序，仅仅把hashset的实现换成treeset就好了

Eg2假设你想知道在一串字符中那些只是出现了一次，那些有重复，并且只是在最后打印结果

可以通过两个set来实现

import java.util.*;

public class FindDups2 {

    public static void main(String args[]) {

        Set<String> uniques = new HashSet<String>();

        Set<String> dups = new HashSet<String>();

 

        for (String a : args)

            if (!uniques.add(a))

                dups.add(a);

 

        //Destructive set-difference

        uniques.removeAll(dups);

        System.out.println("Unique words:    " + uniques);

        System.out.println("Duplicate words: " + dups);

    }

}

Eg3 去掉重复的元素

Monster m=new Monster(i);

       List c=new ArrayList();

       c.add(m);

       c.add(m);

      

       HashSet noDups = new HashSet(c);

       Iterator it=noDups.iterator();

       while(it.hasNext()){

           Monster mon=(Monster)it.next();

           System.out.println();

           System.out.println("new"+mon.toString());

       }

 

List接口是一个有顺序的集合，可以有重复的元素

·         List接口有两种比较常用的实现ArrayList 和LinkedList

如果两个List 以相同的顺序存储相同的元素那这两个list就是equal的

Queue 接口，先进先出的集合FIFO (first-in-first-out)

import java.util.*;

public class Countdown {

    public static void main(String[] args)

            throws InterruptedException {

        int time = Integer.parseInt(args[0]);

        Queue<Integer> queue = new LinkedList<Integer>();

        for (int i = time; i >= 0; i--)

            queue.add(i);

        while(!queue.isEmpty()) {

            System.out.println(queue.remove());

            Thread.sleep(1000);

        }

    }

}

Map 接口用键值对的关系来存储数据，键值不能重复，一个键只能对应一个值Map 的实现类: HashMap , TreeMap , and LinkedHashMap 和set类似

 Map的基本方法： (put, get, containsKey, containsValue, size, and isEmpty)

Eg1 输入 java Freq if it is to be it is up to me to delegate

输出 8 distinct words:

{to=3, delegate=1, be=1, it=2, up=1, if=1, me=1, is=2}

 

import java.util.*;

public class Freq {

    public static void main(String args[]) {

        Map<String, Integer>  m =

            new HashMap<String, Integer>();

 

        // Initialize frequency table from command line

        for (String a : args) {

            Integer freq = m.get(a);

            m.put(a, (freq == null ? 1 : freq + 1));

        }

        System.out.println(m.size() + " distinct words:");

        System.out.println(m);

    }

}

 

Object Ordering 对象的顺序

一个 List l可以像下面那样去排序

Collections.sort(l);

如果List 包含String元素，会按照字幕的顺序进行排序。如果包含Date元素会按照日期的顺序进行排序。这是因为String 和 Date 都实现了Comparable这个接口。Comparable接口提供了类的顺序下面的表是总结了java的一些类实现了这个接口的顺序

 

import java.util.*;

public final class Name implements Comparable<Name> {

    private final String firstName, lastName;

   

    public Name(String firstName, String lastName) {

        if (firstName == null || lastName == null)

            throw new NullPointerException();

 

        this.firstName = firstName;

        this.lastName = lastName;

    }

    public String firstName() { return firstName; }

    public String lastName()  { return lastName;  }

    public boolean equals(Object o) {

        if (!(o instanceof Name))

            return false;

        Name n = (Name) o;

        return n.firstName.equals(firstName) &&

            n.lastName.equals(lastName);

    }

    public int hashCode() {

        return 31*firstName.hashCode() + lastName.hashCode();

    }

    public String toString() {

        return firstName + " " + lastName;

    }

    public int compareTo(Name n) {

        int lastCmp = lastName.compareTo(n.lastName);

        return (lastCmp != 0 ? lastCmp :

                firstName.compareTo(n.firstName));

    }

}

·   Name 这个对象是不能变的

·   在构造函数中坚持参数是否是null，这样保证了其他方法不会抛出空指针异常。

·   重新定义 hashCode 方法 (Equal objects must have equal hash codes.)

·   重新定义  equals方法返回false当比较的对象是null 或者是不相符的类型的时候

·   定义toString 方法让它返回能读懂的东西。

 

Comparators

当你想用另外一种方法去排序对象，或者已有的类没有实现Comparable这个接口的时候怎么办呢？

Interface Comparator 出现了，他封装了排序

假设你有一个类叫做 Employee

public class Employee implements Comparable<Employee> {

    public Name name()     { ... }

    public int number()    { ... }

    public Date hireDate() { ... }

       ...

}

假设这个类是通过名字进行排序的，你的老板突然想让你通过入职日期来进行排序

import java.util.*;

class EmpSort {

    static final Comparator<Employee> SENIORITY_ORDER =

                                 new Comparator<Employee>() {

        public int compare(Employee e1, Employee e2) {

            return e2.hireDate().compareTo(e1.hireDate());

        }

    };

 

    //Employee database

    static final Collection<Employee> employees = ... ;

 

    public static void main(String[] args) {

        List<Employee>e = new ArrayList<Employee>(employees);

        Collections.sort(e, SENIORITY_ORDER);

        System.out.println(e);

    }

}

需要注意的地方：compareTo方法一定要小心写，要考虑到需要比较的对象条件是相等的情况。例如如果两个相同日期入职的员工Jack和andy 那由于compareTo方法的问题只能有一个人存储到treeset里面

static final Comparator<Employee> SENIORITY_ORDER =

                               new Comparator<Employee>() {

   public int compare(Employee e1, Employee e2) {

      int dateCmp = e2.hireDate().compareTo(e1.hireDate());

      if (dateCmp != 0)

         return dateCmp;

      return (e1.number() < e2.number() ? -1 :

              (e1.number() == e2.number() ? 0 : 1));

   }

};

 

 

 

选择使用那种集合的时候需要考虑 首先是速度，那种最适合，序列化，线程，

·         Arrays 直接是由硬件实现的，速度最快 ArrayList,

·         Linked lists 时候插入和删除操作

·         Hash tables 键值

·         Trees

HashSet 最常用的set通过一个 hash table来实现

General-purpose Implementations
Interfaces	Implementations
	Hash table	Resizable array	Tree	Linked list	Hash table + Linked list
Set	HashSet		TreeSet		LinkedHashSet
List		ArrayList		LinkedList
Queue
Map	HashMap		TreeMap		LinkedHashMap