java集合框架1

所有集合类都位于java.util包下。集合中只能保存对象（保存对象的引用变量）。（数组既可以保存基本类型的数据也可以保存对象）。

当我们把一个对象放入集合中后，系统会把所有集合元素都当成Object类的实例进行处理。从JDK1.5以后，这种状态得到了改进：可以使用泛型来限制集合里元素的类型，并让集合记住所有集合元素的类型（参见具体泛型的内容）。

Java的集合类主要由两个接口派生而出：Collection和Map，Collection和Map是Java集合框架的根接口，这两个接口又包含了一些接口或实现类。

Set和List接口是Collection接口派生的两个子接口，Queue是Java提供的队列实现，类似于List。

Map实现类用于保存具有映射关系的数据（key-value）。

Set、List和Map可以看做集合的三大类。

List集合是有序集合，集合中的元素可以重复，访问集合中的元素可以根据元素的索引来访问。

Set集合是无序集合，集合中的元素不可以重复，访问集合中的元素只能根据元素本身来访问（也是集合里元素不允许重复的原因）。

Map集合中保存Key-value对形式的元素，访问时只能根据每项元素的key来访问其value。

对于Set、List和Map三种集合，最常用的实现类分别是HashSet、ArrayList和HashMap三个实现类。

Collection接口是List、Set和Queue接口的父接口，同时可以操作这三个接口。

Collection接口定义操作集合元素的具体方法大家可以参考API文档，Collection 是任何对象组，元素各自独立，通常拥有相同的套用规则。

基本操：

增加元素add(Object obj); addAll(Collection c);

删除元素 remove(Object obj);removeAll(Collection c);

求交集 retainAll(Collection c);

删除元素 remove(Object obj);removeAll(Collection c);

求交集 retainAll(Collection c);

Set接口的三个具体类是：

HashSet--基于散列表的集，加进散列表的元素要实现hashCode()方法

LinkedHashSet--对集迭代时，按增加顺序返回元素

TreeSet--基于（平衡）树的数据结构

1. 继承结构java.lang.Object |_ java.util.AbstractCollection<E> |_ java.util.AbstractSet<E> |_ java.util.HashSet<E>2. 主要方法 add(Object) addAll(Collection) remove(object) removeAll(Collection) size() iterator() toArray() clear() isEmpty() contain(object) containAll(Collection)

Set集合中不允许出现相同的项，Set集合在用Add()方法添加一个新项时，首先会调用equals(Object o)来比较新项和已有的某项是否相等，而不是用==来判断相等性，所以对于字符串等已重写equals方法的类，是按值来比较相等性的

下面的程序创建了一个散列集来存储字符串，并且使用一个迭代器来遍历这个规则集中的元素：

public class Main{    public static void main(String args[]) {        Set<String> set = new HashSet<String>();        set.add("London");        set.add("Paris");        set.add("New York");        set.add("New York");        set.add("Beijing");        set.add("Guangzhou");        System.out.PRintln(set);                Iterator<String> iterator = set.iterator();        while(iterator.hasNext()) {            System.out.print(iterator.next().toUpperCase() + " ");        }    }}

注意：字符串没有按照顺序存储，因为散列集中的元素是没有特定的顺序的

当然也可以不使用迭代器，而用for-each循环来简化上面的迭代代码：

for(Object i: set)    System.out.print(i);

由于一个规则集是Collection的一个实例，所有定义在Collection中的方法都可以用在规则集上，下面的代码就是一个例子：

public class Main{    public static void main(String args[]) {        Set<String> set1 = new HashSet<String>();                set1.add("London");        set1.add("Paris");        set1.add("New York");        set1.add("San Francisco");        set1.add("Beijing");        set1.add("Guangzhou");                System.out.println(set1);        System.out.println(set1.size() + "elements in set1");                set1.remove("London");        System.out.println("/nset1 is " + set1);        System.out.println(set1.size() + " elements in set1");                Set<String> set2 = new HashSet<String>();        set2.add("London");        set2.add("Shanghai");        set2.add("Paris");                System.out.println("/nset2 is " + set2);        System.out.println(set2.size() + " elements in set2");                System.out.println("/nIs Taipei in set2? " + set2.contains("Taipei"));        set1.addAll(set2);        System.out.println("/nafter adding set2 to set1, set1 is " + set1);        set1.removeAll(set2);        System.out.println("After removing set2 from set1, set1 is " + set1);        set1.retainAll(set2);  //保留共有的元素        System.out.println("After removing common elements in set2 " + "from set1, set1 is " + set1);    }}

运行结果如下：

[San Francisco, New York, Guangzhou, Paris, Beijing, London]6elements in set1

set1 is [San Francisco, New York, Guangzhou, Paris, Beijing]5 elements in set1

set2 is [Shanghai, Paris, London]3 elements in set2

Is Taipei in set2? false

after adding set2 to set1, set1 is [San Francisco, New York, Guangzhou, Shanghai, Paris, Beijing, London]After removing set2 from set1, set1 is [San Francisco, New York, Guangzhou, Beijing]After removing common elements in set2 from set1, set1 is []

　　LinkedHashSet，顾名思义，就是在Hash的实现上添加了Linked的支持。对于LinkedHashSet，在每个节点上通过一个链表串联起来，这样，就可以保证确定的顺序。对于希望有常量复杂度的高效存取性能要求、同时又要求排序的情况下，可以直接使用LinkedHashSet。

　　LinkedHashSet用一个链表实现来扩展HashSet类，它支持对规则集内的元素的排序。HashSet中的元素是没有被排序的它实现了Set接口。存入Set的每个元素必须是唯一的，因为Set不保存重复元素。但是Set接口不保证维护元素的次序。Set与Collection有完全一样的接口Iterable，同时Set继承了Collection。LinkedHashSet具有HashSet的查询速度，且内部使用链表维护元素的顺序（插入的顺序），于是在使用迭代器遍历Set时，结果会按元素插入的次序显示。下面是一个测试程序:

public class Main{    public static void main(String args[]) {        Set<String> set = new LinkedHashSet<String>();        set.add("London");        set.add("Paris");        set.add("New York");        set.add("San Francisco");        set.add("Beijing");        set.add("New York");                System.out.println(set);        for(Object i: set)            System.out.print(i.toString().toLowerCase() + " ");    }}

如果不需要维护元素被插入的顺序，就应该使用HashSet，它会比LinkedHashSet更加的高效

继承结构:

java.lang.Object|_java.util.AbstractCollection<E>|_java.util.AbstractSet<E>|_java.util.TreeSet<E>类声明:publicclassTreeSet<E>extendsAbstractSet<E>implementsSortedSet<E>,Cloneable,java.io.Serializable //它实现了sortedSet，有排序的功能

TreeSet的主要性质

1、TreeSet中不能有重复的元素；

2、TreeSet具有排序功能；

3、TreeSet中的元素必须实现Comparable接口并重写compareTo()方法，TreeSet判断元素是否重复、以及确定元素的顺序靠的都是这个方法；

4、对于java类库中定义的类，TreeSet可以直接对其进行存储，如String，Integer等(因为这些类已经实现了Comparable接口)；

java常用类实现Comparable接口，并提供了比较大小的标准。实现Comparable接口的常用类：

• BigDecimal、BigIneger以及所有数值型对应包装类：按它们对应的数值的大小进行比较。

• Character：按字符的UNICODE值进行比较。

• Boolean：true对应的包装类实例大于false对应的包装类实例。

• String：按字符串中字符的UNICODE值进行比较。

• Date、Time：后面的时间、日期比前面的时间、日期大。

public class Main{    public static void main(String args[]) {        Set<String> set = new HashSet<String>();        set.add("London");        set.add("Paris");        set.add("New York");        set.add("San Francisco");        set.add("Beijing");        set.add("New York");                TreeSet<String> treeSet = new TreeSet<String>(set);        System.out.println("Sorted tree set: " + treeSet);                //下面的方法在SortedSet接口        System.out.println("first(): " + treeSet.first());  //返回第一个元素        System.out.println("last(): " + treeSet.last());  //返回最后一个元素        System.out.println("headSet(): " + treeSet.headSet("New York"));  //返回New York之前的所有元素        System.out.println("tailSet(): " + treeSet.tailSet("New York"));   //返回New York 及其之后的所有元素                //使用NavigableSet接口里面的方法        System.out.println("lower(/"p/"): " + treeSet.lower("P"));   //返回小于"P"的最大元素        System.out.println("higher(/"p/"): " + treeSet.higher("P"));   //返回大于"P"的最小元素        System.out.println("floor(/"p/"): " + treeSet.floor("P"));  //返回小于等于"P"的最大元素        System.out.println("ceiling(/"p/"): " + treeSet.ceiling("P"));  //返回大于等于"P"的最小元素        System.out.println("pollFirst(/"p/"): " + treeSet.pollFirst());   //删除第一个元素，并返回被删除的元素        System.out.println("pollLast(/"p/"): " + treeSet.pollLast());  //删除最后一个元素，并返回被删除的元素        System.out.println("New tree set: " + treeSet);    }}

运行结果如下：

Sorted tree set: [Beijing, London, New York, Paris, San Francisco]first(): Beijinglast(): San FranciscoheadSet(): [Beijing, London]tailSet(): [New York, Paris, San Francisco]lower("p"): New Yorkhigher("p"): Parisfloor("p"): New Yorkceiling("p"): ParispollFirst("p"): BeijingpollLast("p"): San FranciscoNew tree set: [London, New York, Paris]

有时希望将元素插入到一个树集合中，这些元素可能不是java.lang.Comparable的实例，这时可以定义一个比较容器来比较这些元素

Comparetor接口有两个方法：compare和equals

public int compare(Object element1, Object element2);

如果element1小于element2，就返回一个负值，如果大于就返回一个正值，若相等，则返回0；

public boolean equals(Objectelement);

如果指定对象也是一个比较器，并且与这个比较器具有相同的排序，则返回true

public class Main{    public static void main(String args[]) {        Person a[] = new Person[4];        a[0] = new Person("zhangsan", 11);        a[1] = new Person("lisi", 23);        a[2] = new Person("wangwu", 33);        a[3] = new Person("wuzhong", 26);        compareName cn = new compareName();        compareAge ca = new compareAge();        for(int i = 0; i < a.length; i++) a[i].print();        System.out.println();        System.out.println("sorting by age:");        Arrays.sort(a, ca);        for(int i = 0; i < a.length; i++) a[i].print();        System.out.println();        System.out.println("sorting by name:");        Arrays.sort(a, cn);        for(int i = 0; i < a.length; i++) a[i].print();    }}class Person {    public String name;    public int age;    Person(String n, int a) {        name = n;        age = a;    }    public void print() {        System.out.println("Name is " + name + ", Age is " + age);    }}class compareAge implements Comparator<Person> {    public int compare(Person p1, Person p2) {        if (p1.age > p2.age)  return -1;        else if (p1.age < p2.age) return 1;        else return 0;    }}class compareName implements Comparator<Person> {    public int compare(Person p1, Person p2) {        return p1.name.compareTo(p2.name);    }}

运行结果:

Name is zhangsan, Age is 11Name is lisi, Age is 23Name is wangwu, Age is 33Name is wuzhong, Age is 26

sorting by age:Name is wangwu, Age is 33Name is wuzhong, Age is 26Name is lisi, Age is 23Name is zhangsan, Age is 11

sorting by name:Name is lisi, Age is 23Name is wangwu, Age is 33Name is wuzhong, Age is 26Name is zhangsan, Age is 11