java集合框架详解

这篇文章是复制的春哥的,觉得学的狠好!

转载请声明出处:http://blog.csdn.net/zhongkelee/article/details/46801449

综述

    Java集合就是一个容器。面向对象语言对事物的体现都是以对象的形式存在,所以为了方便对多个对象的操作,就对对象进行存储,集合就是存储对象最常用的一种方式。集合只用于存储对象集合长度是可变的集合可以存储不同类型的对象。如果往集合里存放基本数据类型,在存取过程中会有个自动装箱和拆箱。

    因为容器中数据结构不同,容器有很多种。不断地将共性功能向上抽取,形成了集合体系,称之为集合框架


    集合框架的顶层就称之为Collection接口。所有的集合类都位于java.util包下,查阅API可以得到如下体系结构。在使用一个体系时,原则:参阅顶层内容。建立底层对象


    集合和数组的区别:

  1:数组是固定长度的;集合可变长度的。

  2:数组可以存储基本数据类型,也可以存储引用数据类型;集合只能存储引用数据类型。

  3:数组存储的元素必须是同一个数据类型;集合存储的对象可以是不同数据类型。

Collection<E>接口

    Collection:单列集合

         |--List:有序(元素存入集合的顺序和取出的顺序一致),元素都有索引,允许重复元素。

         |--Set:无序(存入和取出顺序有可能不一致),不允许重复元素,必须保证元素的唯一性。

    java.util.Collection接口中的共性方法有:

    1.添加
       boolean add(Object obj):一次添加一个。
       boolean addAll(Collection c):将指定容器中的所有元素添加。

    2.删除
       void clear():将集合中的元素全删除,清空集合。
       boolean remove(Object o):删除集合中指定的对象。注意:删除成功,集合的长度会改变。
       boolean removeAll(Collection c):删除部分元素。部分元素和传入Collection一致。

    3.取交集
       boolean retainAll(Collection c):对当前集合中保留和指定集合中的相同的元素。
       如果两个集合元素相同,返回false;如果retainAll修改了当前集合,返回true。

    4.获取长度
       int size():集合中有几个元素。

    5.判断
       boolean isEmpty():集合中是否有元素。 
       boolean contains(Object o):集合中是否包含指定元素。
       boolean containsAll(Collection c)集合中是否包含指定的多个元素。

    6.将集合转成数组
       toArray()
       toArray([])

    下面的代码就是演示Collection中的基本功能。

[java] view plain copy
  1. package ustc.lichunchun.collection.demo;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.Collection;  
  5.   
  6. public class CollectionDemo {  
  7.     public static void main(String[] args) {  
  8.         Collection coll = new ArrayList();  
  9.         methodDemo(coll);  
  10.         System.out.println("------------------");  
  11.         methodAllDemo();  
  12.     }  
  13.     /* 
  14.      * 演示Collection中的基本功能。  
  15.      */  
  16.     public static void methodDemo(Collection coll){  
  17.           
  18.         //1.添加元素。  
  19.         coll.add("abc1");  
  20.         coll.add("abc2");  
  21.         coll.add("abc3");  
  22.           
  23.         //2.删除  
  24.         coll.remove("abc2");//移除和添加元素 --> 会改变集合的长度 --> 集合里面实际上存的是对象们的引用  
  25.           
  26.         //3.清除。  
  27.         coll.clear();  
  28.           
  29.         //4.判断包含。  
  30.         System.out.println("contains: "+coll.contains("abc1"));//底层实现判断用的是equals()  
  31.           
  32.         System.out.println(coll);  
  33.     }  
  34.       
  35.     /* 
  36.      * 演示带All的方法。 
  37.      */  
  38.     public static void methodAllDemo(){  
  39.           
  40.         //1.创建两个容器。  
  41.         Collection c1 = new ArrayList();  
  42.         Collection c2 = new ArrayList();  
  43.           
  44.         //2.添加元素。  
  45.         c1.add("abc1");  
  46.         c1.add("abc2");  
  47.         c1.add("abc3");  
  48.         c1.add("abc4");  
  49.           
  50.         c2.add("abc2");  
  51.         c2.add("abc3");  
  52.         c2.add("abc5");  
  53.           
  54.         //往c1中添加c2。  
  55.         c1.addAll(c2);  
  56.           
  57.         //判断c1中是否包含c2中的所有元素。  
  58.         boolean b = c1.containsAll(c2);  
  59.         System.out.println("b = "+b);  
  60.           
  61.         //从c1中删除c2。将c1中和c2相同的元素从c1中删除。  
  62.         c1.removeAll(c2);  
  63.           
  64.         //将c1中和c2不同的元素从c1中删除。保留c1中和c2相同的元素。  
  65.         c1.retainAll(c2);  
  66.         System.out.println(c1);  
  67.     }  
  68. }  

    疑问:Collection 接口中明明没有toString()声明,怎么可能有权利调用这个ArrayList类的"特有"方法? (虽然ArrayList类继承它父类有toString()复写的方法了,但这个是ArrayList子类特有的方法啊,不符合多态的解释呀?)

    下面这段解释截取自Google找到的答案

[java] view plain copy
  1.  楼主懂得思考,先表扬一下。下面将引用一段接口的说明,你可以看看:  
  2. 9.2 Interface Members  
  3. The members of an interface are:Those members declared in the interface.   
  4. Those members inherited from direct superinterfaces.   
  5. If an interface has no direct superinterfaces, then the interface implicitly declares a public abstract member method m with signature s, return type r, and throws clause t corresponding to each public instance method m with signature s, return type r, and throws clause t declared in Object, unless a method with the same signature, same return type, and a compatible throws clause is explicitly declared by the interface. It is a compile-time error if the interface explicitly declares such a method m in the case where m is declared to be final in Object.  
  6.     
  7. 大致意思如下:  
  8. 9.2 接口方法  
  9.   一个接口中的方法有:  
  10.   1).直接声明在接口中的成员方法;  
  11.   2).直接从父类接口中继承而来的方法;  
  12.   3).如果一个接口没有直接的父类接口(也就是其自身就是顶层接口),并且在其没有显示声明相关方法时,那该接口则会根据Object中所有的public的实例方法进行一一映射(比如toString,Hashcode等)。当然如果此接口显示去声明一个与Object签名相同并且带有final修饰的方法时,则会有编译期错误。  
  13.     
  14. 所以:由超类声明,子类来new。调用的最终是子类中定义的方法,如果子类没有,则调用子类的父类方法。这存在一种向上追溯的过程。说明是完全正确的。  
  15.     
  16. 完全赞同!  
  17. 这里做一点补充。  
  18. 根据这一条说明,在List list=new ArrayList()之后,在list当中将可以调用object当中所有声明public的方法,而调用的方法实体是来自ArrayList的。而之所以没有list不可以调用,clone()与finalize()方法,只是因为它们是protected的。  
  19. 学习了。  
  20. 不过很好奇,33楼的大哥,这条如此原版的声明出自哪个参考书籍呢?学java就该看这种资料啊。  

    7.取出集合元素。
        Iterator iterator():获取集合中元素上迭代功能的迭代器对象。

Iterator<E>接口

    java.util.Iterator接口是一个对 collection 进行迭代的迭代器,作用是取出集合中的元素

    Iterator iterator():获取集合中元素上迭代功能的迭代器对象。

    迭代:取出元素的一种方式。有没有啊?有!取一个。还有没有啊?有!取一个。还有没有啊?没有。算了。

    迭代器:具备着迭代功能的对象。迭代器对象不需要new。直接通过 iterator()方法获取即可。

    迭代器是取出Collection集合中元素的公共方法。


    每一个集合都有自己的数据结构,都有特定的取出自己内部元素的方式。为了便于操作所有的容器,取出元素,将容器内部的取出方式按照一个统一的规则向外提供,这个规则就是Iterator接口

    也就说,只要通过该接口就可以取出Collection集合中的元素,至于每一个具体的容器依据自己的数据结构,如何实现的具体取出细节,这个不用关心,这样就降低了取出元素和具体集合的耦合性

    Iterator it = coll.iterator();//获取容器中的迭代器对象,至于这个对象是是什么不重要。这对象肯定符合一个规则Iterator接口。

[java] view plain copy
  1. package ustc.lichunchun.collection.demo;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.Collection;  
  5. import java.util.Iterator;  
  6.   
  7. public class IteratorDemo {  
  8.   
  9.     public static void main(String[] args) {  
  10.           
  11.         //1.创建集合。  
  12.         Collection coll = new ArrayList();  
  13.           
  14.         coll.add("abc1");  
  15.         coll.add("abc2");  
  16.         coll.add("abc3");  
  17.           
  18.         //方式一:获取该容器的迭代器。  
  19.         Iterator it = coll.iterator();  
  20.         while(it.hasNext()){  
  21.             System.out.println(it.next());  
  22.         }  
  23.           
  24.         //方式二:直接for+alt+/,选择第三个。  
  25.         for (Iterator it = coll.iterator(); it.hasNext();) {  
  26.             System.out.println(it.next());  
  27.         }  
  28.           
  29.         System.out.println(it.next());//abc1  
  30.         System.out.println(it.next());//abc2  
  31.         System.out.println(it.next());//abc3  
  32.         System.out.println(it.next());//java.util.NoSuchElementException   
  33.     }  
  34. }  
     为了降低容器的数据结构和取出容器元素的方法之间的耦合性,把访问、取出容器元素的容器的内部类进行共性抽取,即各种容器的相应内部类都实现了Iterator接口,实现了hasNext()、next()、remove()方法。例如如下截取自ArrayList类的iterator()方法的底层实现代码
[java] view plain copy
  1. public Iterator<E> iterator() {  
  2.         return new Itr();//取出ArrayList容器中元素的迭代器功能,返回的是一个Itr()迭代器对象,也就是实现Iterator接口的内部类对象。  
  3.     }  
  4.   
  5.     /** 
  6.      * An optimized version of AbstractList.Itr 
  7.      */  
  8.     private class Itr implements Iterator<E> {//-->ArrayList容器的内部类,实现了Iterator迭代接口(迭代器),里面有hasNext()、next()、remove()方法。  
  9.         int cursor;       // index of next element to return  
  10.         int lastRet = -1// index of last element returned; -1 if no such  
  11.         int expectedModCount = modCount;  
  12.   
  13.         public boolean hasNext() {  
  14.             return cursor != size;  
  15.         }  
  16.       
  17.         @SuppressWarnings("unchecked")  
  18.         public E next() {  
  19.             checkForComodification();  
  20.             int i = cursor;  
  21.             if (i >= size)  
  22.                 throw new NoSuchElementException();  
  23.             Object[] elementData = ArrayList.this.elementData;  
  24.             if (i >= elementData.length)  
  25.                 throw new ConcurrentModificationException();  
  26.             cursor = i + 1;  
  27.             return (E) elementData[lastRet = i];  
  28.         }  
  29.   
  30.         public void remove() {  
  31.             if (lastRet < 0)  
  32.                 throw new IllegalStateException();  
  33.             checkForComodification();  
  34.   
  35.             try {  
  36.                 ArrayList.this.remove(lastRet);  
  37.                 cursor = lastRet;  
  38.                 lastRet = -1;  
  39.                 expectedModCount = modCount;  
  40.             } catch (IndexOutOfBoundsException ex) {  
  41.                 throw new ConcurrentModificationException();  
  42.             }  
  43.         }  
  44.   
  45.         @Override  
  46.         @SuppressWarnings("unchecked")  
  47.         public void forEachRemaining(Consumer<? super E> consumer) {  
  48.             Objects.requireNonNull(consumer);  
  49.             final int size = ArrayList.this.size;  
  50.             int i = cursor;  
  51.             if (i >= size) {  
  52.                 return;  
  53.             }  
  54.             final Object[] elementData = ArrayList.this.elementData;  
  55.             if (i >= elementData.length) {  
  56.                 throw new ConcurrentModificationException();  
  57.             }  
  58.             while (i != size && modCount == expectedModCount) {  
  59.                 consumer.accept((E) elementData[i++]);  
  60.             }  
  61.             // update once at end of iteration to reduce heap write traffic  
  62.             cursor = i;  
  63.             lastRet = i - 1;  
  64.             checkForComodification();  
  65.         }  
  66.   
  67.         final void checkForComodification() {  
  68.             if (modCount != expectedModCount)  
  69.                 throw new ConcurrentModificationException();  
  70.         }  
  71.     }  
List<E>接口

   List本身是Collection接口的子接口,具备了Collection的所有方法。List集合的具体子类:子类之所以区分是因为内部的数据结构(存储数据的方式)不同。

   List:有序(元素存入集合顺序和取出一致),元素都有索引,允许重复元素-->自定义元素类型都要复写equals方法
        |--Vector:底层的数据结构是数组。数组是可变长度的。线程同步的。增删和查询都巨慢!
        |--ArrayList:底层的也是数组结构,也是长度可变的。线程不同步的,替代了Vector。增删速度不快。查询速度很快。(因为在内存中是连续空间)
        |--LinkedList:底层的数据结构是链表,线程不同步的。增删速度很快。查询速度较慢。(因为在内存中需要一个个查询、判断地址来寻找下一元素)

    可变长度数组的原理
    不断new新数组并将原数组元素复制到新数组。即当元素超出数组长度,会产生一个新数组,将原数组的数据复制到新数组中,再将新的元素添加到新数组中。

    ArrayList:是按照原数组的50%延长。构造一个初始容量为 10 的空列表。

    Vector:是按照原数组的100%延长。

    首先学习List体系特有的共性方法,查阅方法发现List的特有方法都有索引(角标),这是该集合最大的特点。也就是说,List的特有方法都是围绕索引(角标)定义的。

    List集合支持对元素的增、删、改、查

    1.添加(增):
        add(index, element):在指定的索引位插入元素。
        addAll(index, collection):在指定的索引位插入一堆元素。

    2.删除(删):
        remove(index):删除指定索引位的元素。 返回被删的元素。

    3.获取(查):
        element get(index):通过索引获取指定元素。
        int indexOf(element):获取指定元素第一次出现的索引位,如果该元素不存在返回—1;所以,通过—1,可以判断一个元素是否存在。
        int lastIndexOf(element) :反向索引指定元素的位置。
        List subList(start,end) :获取子列表。

    4.修改(改):
        element set(index, newElement):对指定索引位进行元素的修改。

    下面的代码演示了List的特有方法:

[java] view plain copy
  1. package ustc.lichunchun.list.demo;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.Iterator;  
  5. import java.util.List;  
  6.   
  7. public class ListDemo {  
  8.   
  9.     public static void main(String[] args) {  
  10.         List list = new ArrayList();  
  11.         methodDemo(list);  
  12.     }  
  13.     /* 
  14.      * 演示List特有的方法。 
  15.      */  
  16.     public static void methodDemo(List list){  
  17.         //1.常规添加元素。  
  18.         list.add("abc1");  
  19.         list.add("abc2");  
  20.         list.add("abc3");  
  21.           
  22.         //2.插入元素。  
  23.         list.add(1,"hehe");  
  24.           
  25.         //3.删除。  
  26.         list.remove(1);  
  27.         list.remove(1);  
  28.           
  29.         //4.获取。  
  30.         System.out.println(list.get(3));// java.lang.IndexOutOfBoundsException  
  31.         System.out.println(list.get(1));  
  32.         System.out.println(list.indexOf("abc3"));  
  33.           
  34.         //5.修改。  
  35.         list.set(1,"keke");  
  36.           
  37.         System.out.println(list);  
  38.           
  39.         //6.取出集合中所有的元素。  
  40.         for (Iterator it = list.iterator(); it.hasNext();) {  
  41.             System.out.println("iterator: "+it.next());  
  42.         }  
  43.           
  44.         //7.List集合特有的取出方式。遍历。  
  45.         for (int i = 0; i < list.size(); i++) {  
  46.             System.out.println("get: "+list.get(i));  
  47.         }  
  48.     }  
  49. }  
    5.获取所有元素:
    ListIterator listIterator():list集合特有的迭代器。

    在进行list列表元素迭代的时候,如果想要在迭代过程中,想要对元素进行操作的时候,比如满足条件添加新元素。会发生ConcurrentModificationException并发修改异常。

    导致的原因是:集合引用和迭代器引用在同时操作元素,通过集合获取到对应的迭代器后,在迭代中,进行集合引用的元素添加,迭代器并不知道,所以会出现异常情况。

    如何解决呢?既然是在迭代中对元素进行操作,找迭代器的方法最为合适。可是Iterator中只有hasNext,next,remove方法。通过查阅的它的子接口,ListIterator,发现该列表迭代器接口具备了对元素的增、删、改、查的动作。

    ListIterator是List集合特有的迭代器。

    ListIterator it = list.listIterator; //取代Iterator it = list.iterator;


[java] view plain copy
  1. package ustc.lichunchun.list.demo;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.List;  
  5. import java.util.ListIterator;  
  6.   
  7. public class ListIteratorDemo {  
  8.   
  9.     public static void main(String[] args) {  
  10.           
  11.         List list = new ArrayList();  
  12.           
  13.         list.add("abc1");  
  14.         list.add("abc2");  
  15.         list.add("abc3");  
  16.         list.add("abc4");  
  17.           
  18.         //需求:在遍历的过程中,如果遍历到abc2,添加一个元素haha  
  19.         for (Iterator it = list.iterator(); it.hasNext();) {  
  20.             Object obj = it.next();//java.util.ConcurrentModificationException   
  21.             if(obj.equals("abc2")){  
  22.                 list.add("haha");  
  23.             }  
  24.         }  
  25.         //上述代码出现的问题:  
  26.         //迭代器it在操作容器元素,迭代过程中使用了集合对象list同时对元素进行操作。  
  27.         //产生迭代结果的不确定性,引发了并发修改异常。  
  28.         //解决思想:在迭代过程中,想要执行一些操作,使用迭代器的方法就可以了。  
  29.   
  30.         //使用List集合特有的迭代器:ListIterator,通过List集合的方法listIterator()获取该列表迭代器对象。  
  31.         //ListIterator可以实现在迭代过程中的增删改查,还可以逆向遍历。(底层使用了List集合的角标)  
  32.         //总结:在迭代过程中想要对列表List元素进行操作的时候,就要使用列表迭代器ListIterator.  
  33.           
  34.         for (ListIterator it = list.listIterator(); it.hasNext();) {  
  35.             Object obj = it.next();  
  36.             if(obj.equals("abc2")){  
  37.                 it.add("haha");  
  38.             }  
  39.         }  
  40.         System.out.println(list);//[abc1, abc2, haha, abc3, abc4]  
  41.     }  
  42. }  
ArrayList<E>类

    接下来先讨论List接口的第一个重要子类:java.util.ArrayList<E>类,我这里先抛开泛型不说,本篇后面有专门阐述。但要注意,由于还没有使用泛型,利用Iterator的next()方法取出的元素必须向下转型,才可使用子类特有方法。针对ArrayList类,我们最需要注意的是,ArrayList的contains方法底层使用的equals方法判别的,所以自定义元素类型中必须复写Object的equals方法

    针对这个问题,我们来讲几个小练习。

    练习1: 往ArrayList中存储自定义对象。Person(name, age)

    思路:
    1.描述Person。
    2.定义容器对象。
    3.将多个Person对象,存储到集合中。
    4.取出Person对象。-->注意自定义对象复写toString方法,直接打印p才有意义。

[java] view plain copy
  1. package ustc.lichunchun.list.test;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.Iterator;  
  5. import java.util.List;  
  6.   
  7. import ustc.lichunchun.domian.Person;  
  8.   
  9. public class ArrayListTest {  
  10.   
  11.     public static void main(String[] args) {  
  12.           
  13.         //1.创建ArrayList集合对象。  
  14.         List list = new ArrayList();  
  15.           
  16.         //2.添加Person类型的对象。  
  17.         Person p1 = new Person("lisi1"21);  
  18.         Person p2 = new Person("lisi2"22);  
  19.           
  20.         list.add(p1);//add(Object obj)  
  21.         list.add(p2);  
  22.         list.add(new Person("lisi3"23));  
  23.           
  24.         //3.取出元素。  
  25.         for (Iterator it = list.iterator(); it.hasNext();) {  
  26.             //it.next():取出的元素都是Object类型的。需要用到具体对象内容时,需要向下转型。  
  27.             Person p = (Person)it.next();  
  28.             System.out.println(p.getName()+":"+p.getAge());//如果不向下转型,Object类对象没有getName、getAge方法。  
  29.         }  
  30.     }  
  31. }  
    练习2:定义功能,去除ArrayList集合中的重复元素。

    思路:
    1.最后唯一性的元素也很多,可以先定义一个容器用于存储这些唯一性的元素。
    2.对原有容器进行元素的获取,并到临时容器中去判断是否存在。容器本身就有这功能,判断元素是否存在。
        -->contains()底层原理就是使用的equals(),而且这里用的是String类复写的的equals
    3.存在就不存储,不存在就存储。
    4.遍历完原容器后,临时容器中存储的就是唯一性的元素。

[java] view plain copy
  1. package ustc.lichunchun.list.test;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.Iterator;  
  5. import java.util.List;  
  6. import java.util.ListIterator;  
  7.   
  8. public class ArrayListTest2 {  
  9.   
  10.     public static void main(String[] args) {  
  11.         /* 
  12.          * 练习2:定义功能,去除ArrayList集合中的重复元素。 
  13.          */  
  14.         List list = new ArrayList();  
  15.         list.add("abc1");  
  16.         list.add("abc4");  
  17.         list.add("abc2");  
  18.         list.add("abc1");  
  19.         list.add("abc4");  
  20.         list.add("abc4");  
  21.         list.add("abc2");  
  22.         list.add("abc1");  
  23.         list.add("abc4");  
  24.         list.add("abc2");  
  25.           
  26.         System.out.println(list);//[abc1, abc4, abc2, abc1, abc4, abc4, abc2, abc1, abc4, abc2]  
  27.         singleElement2(list);  
  28.         System.out.println(list);//[abc1, abc4, abc2]  
  29.     }  
  30.       
  31.     /* 
  32.      * 取出重复元素方式一。 
  33.      * 定义功能,取出重复元素。因为List带有角标,比较容易进行for循环。 
  34.      */  
  35.     public static void singleElement(List list){  
  36.         for (int x = 0; x < list.size()-1; x++){  
  37.             Object obj = list.get(x);  
  38.             for(int y = x+1; y < list.size(); y++){  
  39.                 if (obj.equals(list.get(y))){  
  40.                     list.remove(y--);//记住:remove、add等方法,会改变原数组长度!注意角标变化。  
  41.                 }  
  42.             }  
  43.         }  
  44.     }  
  45.       
  46.     /* 
  47.      * 取出重复元素方式二。 
  48.      * 思路: 
  49.      * 1.最后唯一性的元素也很多,可以先定义一个容器用于存储这些唯一性的元素。 
  50.      * 2.对原有容器进行元素的获取,并到临时容器中去判断是否存在。容器本身就有这功能,判断元素是否存在。 
  51.      * 3.存在就不存储,不存在就存储。 
  52.      * 4.遍历完原容器后,临时容器中存储的就是唯一性的元素。 
  53.      */  
  54.     public static void singleElement2(List list){  
  55.         //1.定义一个临时容器  
  56.         List temp = new ArrayList();  
  57.           
  58.         //2.遍历原容器  
  59.         for (Iterator it = list.iterator(); it.hasNext();) {  
  60.             Object obj = (Object) it.next();  
  61.               
  62.             //3.在临时容器中判断遍历到的元素是否存在  
  63.             if(!temp.contains(obj))//contains()底层原理就是使用的equals(),而且这里用的是String类复写的equals。  
  64.                 //如果不存在,就存储到临时容器中  
  65.                 temp.add(obj);  
  66.         }  
  67.         //将原容器清空  
  68.         list.clear();  
  69.         //将临时容器中的元素都存储到原容器中  
  70.         list.addAll(temp);  
  71.     }  
  72. }  
    练习3:ArrayList取出重复的自定义元素。

    记住:往集合里面存储自定义元素,该元素所属类一定要覆盖equals、toString方法!

[java] view plain copy
  1. package ustc.lichunchun.domian;  
  2.   
  3. public class Person{  
  4.     private String name;  
  5.     private int age;  
  6.     public Person() {  
  7.         super();  
  8.     }  
  9.     public Person(String name, int age) {  
  10.         super();  
  11.         this.name = name;  
  12.         this.age = age;  
  13.     }  
  14.     public String getName() {  
  15.         return name;  
  16.     }  
  17.     public void setName(String name) {  
  18.         this.name = name;  
  19.     }  
  20.     public int getAge() {  
  21.         return age;  
  22.     }  
  23.     public void setAge(int age) {  
  24.         this.age = age;  
  25.     }  
  26.     @Override  
  27.     public String toString() {  
  28.         return "Person [name=" + name + ", age=" + age + "]";  
  29.     }  
  30.     /* 
  31.      * 建立Person类自己的判断对象是否相同的依据,必须要覆盖Object类中的equals方法。 
  32.      */  
  33.     public boolean equals(Object obj) {  
  34.         //为了提高效率,如果比较的对象是同一个,直接返回true即可。  
  35.         if(this == obj)  
  36.             return true;  
  37.           
  38.         if(!(obj instanceof Person))  
  39.                 throw new ClassCastException("类型错误");  
  40.         Person p = (Person)obj;  
  41.           
  42.         return this.name.equals(p.name) && this.age==p.age;  
  43.     }  
  44.     /*@Override 
  45.     public boolean equals(Object obj) { 
  46.         if (this == obj) 
  47.             return true; 
  48.         if (obj == null) 
  49.             return false; 
  50.         if (getClass() != obj.getClass()) 
  51.             return false; 
  52.         Person other = (Person) obj; 
  53.         if (age != other.age) 
  54.             return false; 
  55.         if (name == null) { 
  56.             if (other.name != null) 
  57.                 return false; 
  58.         } else if (!name.equals(other.name)) 
  59.             return false; 
  60.         return true; 
  61.     }*/  
  62. }  

     contains()方法底层调用的是容器中元素对象的equals()方法!这里如果Person类自身不定义equals方法,就使用Object的equals方法,比较的就仅仅是地址了。

[java] view plain copy
  1. package ustc.lichunchun.list.test;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.Iterator;  
  5. import java.util.List;  
  6.   
  7. import ustc.lichunchun.domian.Person;  
  8.   
  9. public class ArrayListTest3 {  
  10.   
  11.     public static void main(String[] args) {  
  12.         /* 
  13.          * 练习3:ArrayList取出重复的自定义元素。 
  14.          *  
  15.          * 记住:往集合里面存储自定义元素,该元素所属类一定要覆盖equals、toString方法! 
  16.          */  
  17.         List list = new ArrayList();  
  18.         Person p = new Person("li",19);  
  19.         list.add(p);  
  20.         list.add(p);//存储了一个地址相同的对象。在equals方法中直接先this==obj即可。  
  21.         list.add(new Person("li",20));  
  22.         list.add(new Person("li",23));  
  23.         list.add(new Person("li",26));  
  24.         list.add(new Person("li",23));  
  25.         list.add(new Person("li",26));  
  26.         list.add(new Person("li",20));  
  27.           
  28.         System.out.println(list);  
  29.         singleElement(list);  
  30.         System.out.println(list);  
  31.     }  
  32.     public static void singleElement(List list){  
  33.         List temp = new ArrayList();  
  34.         for (Iterator it = list.iterator(); it.hasNext();) {  
  35.             Object obj = (Object) it.next();  
  36.             if(!temp.contains(obj))// --> contains()方法底层调用的是容器中元素对象的equals()方法!  
  37.                 //这里如果Person类自身不定义equals方法,就使用Object的equals方法,比较的就仅仅是地址了。  
  38.                 temp.add(obj);  
  39.         }  
  40.         list.clear();  
  41.         list.addAll(temp);  
  42.     }  
  43. }  
LinkedList<E>类

    java.util.LinkedList<E>类是List接口的链表实现,可以利用LinkedList实现堆栈、队列结构。它的特有方法有如下这些:    

    addFirst();
    addLast();
    在jdk1.6以后:
    offerFirst();
    offerLast();

    getFirst():获取链表中的第一个元素。如果链表为空,抛出NoSuchElementException;
    getLast();
    在jdk1.6以后:
    peekFirst();获取链表中的第一个元素。如果链表为空,返回null。
    peekLast();

    removeFirst():获取链表中的第一个元素,但是会删除链表中的第一个元素。如果链表为空,抛出NoSuchElementException
    removeLast();
    在jdk1.6以后:
    pollFirst();获取链表中的第一个元素,但是会删除链表中的第一个元素。如果链表为空,返回null。
    pollLast();

[java] view plain copy
  1. package ustc.lichunchun.list.linkedlist;  
  2.   
  3. import java.util.LinkedList;  
  4.   
  5. public class LinkedListDemo {  
  6.   
  7.     public static void main(String[] args) {  
  8.         //1.创建一个链表对象。  
  9.         LinkedList link = new LinkedList();  
  10.           
  11.         //演示xxxFirst()、xxxLast()方法。  
  12.           
  13.         //2.添加方法。  
  14.         link.addFirst("abc1");  
  15.         link.addFirst("abc2");  
  16.         link.addFirst("abc3");  
  17.           
  18.         //3.获取元素。  
  19.         System.out.println(link.getFirst());//abc3  
  20.         System.out.println(link.getFirst());//abc3  
  21.           
  22.         //4.删除元素。  
  23.         System.out.println(link.removeFirst());//abc3  
  24.         System.out.println(link.removeFirst());//abc2  
  25.           
  26.         //5.取出link中所有元素。  
  27.         while(!link.isEmpty())  
  28.             System.out.println(link.removeLast());//removeFirst()  
  29.         link.contains("abc3");//false  
  30.     }  
  31. }  
    练习:请通过LInkedList实现一个堆栈,或者队列数据结构。

    堆栈:先进后出。First In Last Out FILO。

    队列:先进先出。First In First Out   FIFO。

    队列结构代码如下:

[java] view plain copy
  1. package ustc.lichunchun.list.linkedlist;  
  2.   
  3. import java.util.LinkedList;  
  4.   
  5. /* 
  6.  * 描述一个队列数据结构。内部使用的是LinkedList。 
  7.  */  
  8. public class MyQueue {  
  9.     private LinkedList link;  
  10.   
  11.     MyQueue() {  
  12.         link = new LinkedList();  
  13.     }  
  14.   
  15.     /** 
  16.      * 添加元素的方法。 
  17.      */  
  18.     public void myAdd(Object obj) {  
  19.         // 内部使用的是LinkedList的方法。  
  20.         link.addFirst(obj);  
  21.     }  
  22.   
  23.     /** 
  24.      * 获取队列元素的方法。 
  25.      */  
  26.     public Object myGet() {  
  27.         return link.removeLast();  
  28.     }  
  29.   
  30.     /** 
  31.      * 集合中是否有元素的方法。 
  32.      */  
  33.     public boolean isNull() {  
  34.         return link.isEmpty();  
  35.     }  
  36. }  

    堆栈结构代码如下:

[java] view plain copy
  1. package ustc.lichunchun.list.linkedlist;  
  2.   
  3. import java.util.LinkedList;  
  4.   
  5. /* 
  6.  *  实现一个堆栈结构。内部使用的是LinkedList。 
  7.  */  
  8. public class MyStack {  
  9.     private LinkedList link;  
  10.   
  11.     MyStack() {  
  12.         link = new LinkedList();  
  13.     }  
  14.   
  15.     public void myAdd(Object obj) {  
  16.         link.addFirst(obj);  
  17.     }  
  18.   
  19.     public Object myGet() {  
  20.         return link.removeFirst();  
  21.     }  
  22.   
  23.     public boolean isNull() {  
  24.         return link.isEmpty();  
  25.     }  
  26. }  

    测试:

[java] view plain copy
  1. package ustc.lichunchun.list.linkedlist;  
  2.   
  3. import java.util.LinkedList;  
  4.   
  5. public class LinkedListTest {  
  6.   
  7.     public static void main(String[] args) {  
  8.         /* 
  9.          * 练习:请通过LInkedList实现一个堆栈,或者队列数据结构。 
  10.          * 堆栈:先进后出。First In Last Out      FILO. 
  11.          * 队列:先进先出。First In First Out  FIFO. 
  12.          */  
  13.           
  14.         //1.创建自定义的队列对象。  
  15.         MyQueue queue = new MyQueue();  
  16.           
  17.         //2.添加元素。  
  18.         queue.myAdd("abc1");  
  19.         queue.myAdd("abc2");  
  20.         queue.myAdd("abc3");  
  21.         queue.myAdd("abc4");  
  22.           
  23.         //3.获取所有元素。先进先出。  
  24.         while(!queue.isNull())  
  25.             System.out.println(queue.myGet());  
  26.         System.out.println("--------------------------");  
  27.           
  28.         //1.创建自定义的堆栈对象。  
  29.         MyStack stack = new MyStack();  
  30.           
  31.         //2.添加元素。  
  32.         stack.myAdd("def5");  
  33.         stack.myAdd("def6");  
  34.         stack.myAdd("def7");  
  35.         stack.myAdd("def8");  
  36.           
  37.         //3.获取所有元素。先进后出。  
  38.         while(!stack.isNull())  
  39.             System.out.println(stack.myGet());  
  40.     }  
  41. }  

练习1:带猜数字游戏的用户登录注册案例--集合版

需求分析:

[java] view plain copy
  1. 需求:用户登录注册案例。  
  2.   
  3. 按照如下的操作,可以让我们更符号面向对象思想  
  4.     A:有哪些类呢?  
  5.     B:每个类有哪些东西呢?  
  6.     C:类与类之间的关系是什么呢?  
  7.       
  8. 分析:  
  9.     A:有哪些类呢?  
  10.         用户类  
  11.         测试类  
  12.     B:每个类有哪些东西呢?  
  13.         用户类:  
  14.             成员变量:用户名,密码  
  15.             构造方法:无参构造  
  16.             成员方法:getXxx()/setXxx()  
  17.                        登录,注册  
  18.                          
  19.             假如用户类的内容比较对,将来维护起来就比较麻烦,为了更清晰的分类,我们就把用户又划分成了两类  
  20.                 用户基本描述类  
  21.                     成员变量:用户名,密码  
  22.                     构造方法:无参构造  
  23.                     成员方法:getXxx()/setXxx()  
  24.                 用户操作类  
  25.                     登录,注册  
  26.         测试类:  
  27.             main方法。  
  28.     C:类与类之间的关系是什么呢?  
  29.         在测试类中创建用户操作类和用户基本描述类的对象,并使用其功能。  
  30.           
  31. 分包:  
  32.     A:功能划分  
  33.     B:模块划分  
  34.     C:先按模块划分,再按功能划分  
  35.       
  36. 今天我们选择按照功能划分:  
  37.     用户基本描述类包 ustc.lichunchun.pojo  
  38.     用户操作接口 ustc.lichunchun.dao  
  39.     用户操作类包 ustc.lichunchun.dao.impl  
  40.         本文中是集合实现,后续会有IO实现、GUI实现和数据库实现。  
  41.     用户测试类 ustc.lichunchun.test  
代码如下:

[java] view plain copy
  1. package ustc.lichunchun.pojo;  
  2. /** 
  3.  * 这是用户基本描述类 
  4.  *  
  5.  * @author 李春春 
  6.  * @version V1.0 
  7.  * 
  8.  */  
  9. public class User {  
  10.     // 用户名  
  11.     private String username;  
  12.     // 密码  
  13.     private String password;  
  14.   
  15.     public User() {  
  16.         super();  
  17.     }  
  18.   
  19.     public String getUsername() {  
  20.         return username;  
  21.     }  
  22.   
  23.     public void setUsername(String username) {  
  24.         this.username = username;  
  25.     }  
  26.   
  27.     public String getPassword() {  
  28.         return password;  
  29.     }  
  30.   
  31.     public void setPassword(String password) {  
  32.         this.password = password;  
  33.     }  
  34. }  
[java] view plain copy
  1. package ustc.lichunchun.dao;  
  2.   
  3. import ustc.lichunchun.pojo.User;  
  4. /** 
  5.  * 这时针对用户进行操作的接口 
  6.  *  
  7.  * @author 李春春 
  8.  * @version V1.0 
  9.  * 
  10.  */  
  11. public interface UserDao {  
  12.     /** 
  13.      * 这是用户登录功能 
  14.      *  
  15.      * @param username 
  16.      *            用户名 
  17.      * @param password 
  18.      *            密码 
  19.      * @return 返回登陆是否成功 
  20.      */  
  21.     public abstract boolean isLogin(String username, String password);  
  22.   
  23.     /** 
  24.      * 这是用户注册功能 
  25.      *  
  26.      * @param user 
  27.      *            要注册的用户信息 
  28.      */  
  29.     public abstract void regist(User user);  
  30. }  
[java] view plain copy
  1. package ustc.lichunchun.dao.impl;  
  2.   
  3. import java.util.ArrayList;  
  4.   
  5. import ustc.lichunchun.dao.UserDao;  
  6. import ustc.lichunchun.pojo.User;  
  7. /** 
  8.  * 这是用户操作的具体实现类(集合版) 
  9.  *  
  10.  * @author 李春春 
  11.  * @version V1.0 
  12.  * 
  13.  */  
  14. public class UserDaoImpl implements UserDao {  
  15.     //为了让多个方法能够使用同一个集合,就把集合定义为成员变量。  
  16.     //为了不让外人看到,用private  
  17.     //为了让多个对象共享同一个成员变量,用static  
  18.     private static ArrayList<User> array = new ArrayList<User>();  
  19.     @Override  
  20.     public boolean isLogin(String username, String password) {  
  21.         //遍历集合,获取每一个用户,并判断用户的用户名和密码是否和传递过来的匹配  
  22.         boolean flag = false;  
  23.           
  24.         for(User u : array){  
  25.             if(u.getUsername().equalsIgnoreCase(username) && u.getPassword().equalsIgnoreCase(password)){  
  26.                 flag = true;  
  27.                 break;  
  28.             }  
  29.         }  
  30.           
  31.         return flag;  
  32.     }  
  33.   
  34.     @Override  
  35.     public void regist(User user) {  
  36.         //把用户信息存入集合  
  37.         array.add(user);  
  38.     }  
  39. }  
[java] view plain copy
  1. package ustc.lichunchun.test;  
  2.   
  3. import java.util.Scanner;  
  4.   
  5. import ustc.lichunchun.dao.UserDao;  
  6. import ustc.lichunchun.dao.impl.UserDaoImpl;  
  7. import ustc.lichunchun.game.GuessNumber;  
  8. import ustc.lichunchun.pojo.User;  
  9.   
  10. /** 
  11.  * 用户测试类 
  12.  *  
  13.  * @author 李春春 
  14.  * @version V1.0 
  15.  *  
  16.  * 新增加了两个小问题: 
  17.  * A.多个对象共享同一个成员变量,用静态 
  18.  * B.循环里面如果有switch,并且在switch里面有break,那么结束的不是循环,而是switch语句 
  19.  * 
  20.  */  
  21. public class UserTest {  
  22.   
  23.     public static void main(String[] args) {  
  24.         //为了能够回来  
  25.         while (true) {  
  26.             // 欢迎界面,给出选择项  
  27.             System.out.println("--------------欢迎光临--------------");  
  28.             System.out.println("1 登陆");  
  29.             System.out.println("2 注册");  
  30.             System.out.println("3 退出");  
  31.             System.out.println("请输入你的选择:");  
  32.             //键盘录入选择,根据选择做不同的操作  
  33.             Scanner sc = new Scanner(System.in);  
  34.             //为了后面的录入信息的方便,所有的数据录入全部用字符串接收  
  35.             String choiceString = sc.nextLine();  
  36.             //switch语句的多个地方要使用,我就定义到外面  
  37.             UserDao ud = new UserDaoImpl();//多态  
  38.             //经过简单的思考,我选择了switch  
  39.             switch (choiceString) {  
  40.             case "1":  
  41.                 //登陆界面,请输入用户名和密码  
  42.                 System.out.println("--------------登录界面--------------");  
  43.                 System.out.println("请输入用户名:");  
  44.                 String username = sc.nextLine();  
  45.                 System.out.println("请输入密码:");  
  46.                 String password = sc.nextLine();  
  47.                 //调用登录功能  
  48.                 boolean flag = ud.isLogin(username, password);  
  49.                 if (flag) {  
  50.                     System.out.println("登陆成功,可以开始玩游戏了");  
  51.                     System.out.println("你玩么?y/n");  
  52.                     while(true){  
  53.                         String resultString = sc.nextLine();  
  54.                         if(resultString.equalsIgnoreCase("y")){  
  55.                             GuessNumber.start();  
  56.                             System.out.println("你还玩么?y/n");  
  57.                         }else{  
  58.                             break;  
  59.                         }  
  60.                     }  
  61.                     System.out.println("谢谢使用,欢迎下次再来");  
  62.                     System.exit(0);  
  63.                     //break;这里写break,结束的是switch  
  64.                 } else {  
  65.                     System.out.println("用户名或者密码有误,登录失败");  
  66.                 }  
  67.                 break;  
  68.   
  69.             case "2":  
  70.                 //注册界面,请输入用户名和密码  
  71.                 System.out.println("--------------注册界面--------------");  
  72.                 System.out.println("请输入用户名:");  
  73.                 String newUserName = sc.nextLine();  
  74.                 System.out.println("请输入密码:");  
  75.                 String newPassword = sc.nextLine();  
  76.                 //把用户名和密码封装到一个对象中  
  77.                 User user = new User();  
  78.                 user.setUsername(newUserName);  
  79.                 user.setPassword(newPassword);  
  80.                 //调用注册功能  
  81.                 ud.regist(user);  
  82.                 System.out.println("注册成功");  
  83.                 break;  
  84.             case "3":  
  85.             default:  
  86.                 System.out.println("谢谢使用,欢迎下次再来");  
  87.                 System.exit(0);  
  88.             }  
  89.         }  
  90.     }  
  91. }  
其中的猜数字游戏代码为:

[java] view plain copy
  1. package ustc.lichunchun.game;  
  2.   
  3. import java.util.Scanner;  
  4.   
  5. /** 
  6.  * 这是猜数字小游戏 
  7.  *  
  8.  * @author 李春春 
  9.  * 
  10.  */  
  11. public class GuessNumber {  
  12.     private GuessNumber() {  
  13.     }  
  14.   
  15.     public static void start() {  
  16.         int num = (int) (Math.random() * 100) + 1;  
  17.         int count = 0;  
  18.         while (true) {  
  19.             System.out.println("请输入数据(1-100):");  
  20.             Scanner sc = new Scanner(System.in);  
  21.             int guessNum = sc.nextInt();  
  22.             count++;  
  23.             if (guessNum > num) {  
  24.                 System.out.println("你猜的数据" + guessNum + "大了");  
  25.             } else if (guessNum < num) {  
  26.                 System.out.println("你猜的数据" + guessNum + "小了");  
  27.             } else {  
  28.                 System.out.println("恭喜你," + count + "次就猜中了");  
  29.                 break;  
  30.             }  
  31.         }  
  32.     }  
  33. }  
程序运行结果如下:

练习2:控制台购物管理系统。

这个练习的程序代码较长,我上传到资源里,有兴趣的读者可以下载下来瞅一眼。

详见:http://download.csdn.net/detail/zhongkelee/8981865

程序运行截图:

Set<E>接口

     java.util.Set<E>接口,一个不包含重复元素的 collection。更确切地讲,set 不包含满足e1.equals(e2) 的元素对e1 和e2,并且最多包含一个 null 元素。
    Set:不允许重复元素。和Collection的方法相同。Set集合取出方法只有一个:迭代器。
        |--HashSet:底层数据结构是哈希表(散列表)。无序,比数组查询的效率高。线程不同步的。
                 -->根据哈希冲突的特点,为了保证哈希表中元素的唯一性,
                      该容器中存储元素所属类应该复写Object类的hashCode、equals方法。
                |--LinkedhashSet有序,HashSet的子类。
        |--TreeSet:底层数据结构是二叉树。可以对Set集合的元素按照指定规则进行排序。线程不同步的。
                -->add方法新添加元素必须可以同容器已有元素进行比较,
                     所以元素所属类应该实现Comparable接口的compareTo方法,以完成排序。
             或者添加Comparator比较器,实现compare方法。

    代码示例:

[java] view plain copy
  1. package ustc.lichunchun.set.demo;  
  2.   
  3. import java.util.HashSet;  
  4. import java.util.Iterator;  
  5. import java.util.Set;  
  6.   
  7. public class HashSetDemo {  
  8.   
  9.     public static void main(String[] args) {  
  10.           
  11.         //1.创建一个Set容器对象。  
  12.         Set set = new HashSet();  
  13.           
  14.         //Set set = new LinkedHashSet();如果改成LinkedHashSet,可以实现有序。  
  15.           
  16.         //2.添加元素。  
  17.         set.add("haha");  
  18.         set.add("nba");  
  19.         set.add("abc");  
  20.         set.add("nba");  
  21.         set.add("heihei");  
  22.           
  23.         //3.只能用迭代器取出。  
  24.         for (Iterator it = set.iterator(); it.hasNext();) {  
  25.             System.out.println(it.next());  
  26.         }  
  27.     }  
  28. }  
HashSet<E>类

    java.util.HashSet<E>类实现Set 接口,由哈希表(实际上是一个HashMap 实例)支持。它不保证 set 的迭代顺序;特别是它不保证该顺序恒久不变。此类允许使用null 元素。

    堆内存的底层实现就是一种哈希表结构,需要通过哈希算法来计算对象在该结构中存储的地址。这个方法每个对象都具备,叫做hashCode()方法,隶属于java.lang.Objecct类。hashCode本身调用的是wondows系统本地的算法,也可以自己定义。

    哈希表的原理
    1.对对象元素中的关键字(对象中的特有数据),进行哈希算法的运算,并得出一个具体的算法值,这个值称为哈希值。
    2.哈希值就是这个元素的位置。
    3.如果哈希值出现冲突,再次判断这个关键字对应的对象是否相同。
       如果对象相同,就不存储,因为元素重复。如果对象不同,就存储,在原来对象的哈希值基础 +1顺延。
    4.存储哈希值的结构,我们称为哈希表。
    5.既然哈希表是根据哈希值存储的,为了提高效率,最好保证对象的关键字是唯一的。
       这样可以尽量少的判断关键字对应的对象是否相同,提高了哈希表的操作效率。

    哈希表的特点
    1.不允许存储重复元素,因为会发生查找的不确定性。
    2.不保证存入和取出的顺序一致,即不保证有序。
    3.比数组查询的效率高。

    哈希冲突
    当哈希算法算出的两个元素的值相同时,称为哈希冲突。冲突后,需要对元素进行进一步的判断。判断的是元素的内容,equals。如果不同,还要继续计算新的位置,比如地址链接法,相当于挂一个链表扩展下来。

    如何保证哈希表中元素的唯一性
    元素必须覆盖hashCode和equals方法。
    覆盖hashCode方法是为了根据元素自身的特点确定哈希值。
    覆盖equals方法,是为了解决哈希值的冲突。

    如何实现有序
    LinkedHashSet类,可以实现有序。

    废话不所说,下面我来举一个例子演示。

    练习:往HashSet中存储学生对象(姓名,年龄)。同姓名、同年龄视为同一个人,不存。

    思路:

    1.描述学生。
    2.定义容器。
    3.将学生对象存储到容器中。

[java] view plain copy
  1. package ustc.lichunchun.domian;  
  2.   
  3. public class Student {  
  4.     private String name;  
  5.     private int age;  
  6.     public Student() {  
  7.         super();  
  8.     }  
  9.     public Student(String name, int age) {  
  10.         super();  
  11.         this.name = name;  
  12.         this.age = age;  
  13.     }  
  14.     public String getName() {  
  15.         return name;  
  16.     }  
  17.     public void setName(String name) {  
  18.         this.name = name;  
  19.     }  
  20.     public int getAge() {  
  21.         return age;  
  22.     }  
  23.     public void setAge(int age) {  
  24.         this.age = age;  
  25.     }  
  26.     @Override  
  27.     public String toString() {  
  28.         return "Student [name=" + name + ", age=" + age + "]";  
  29.     }  
  30.     /* 
  31.     @Override 
  32.     public int hashCode() { 
  33.         final int prime = 31; 
  34.         int result = 1; 
  35.         result = prime * result + age; 
  36.         result = prime * result + ((name == null) ? 0 : name.hashCode()); 
  37.         return result; 
  38.     } 
  39.     @Override 
  40.     public boolean equals(Object obj) { 
  41.         if (this == obj) 
  42.             return true; 
  43.         if (obj == null) 
  44.             return false; 
  45.         if (getClass() != obj.getClass()) 
  46.             return false; 
  47.         Student other = (Student) obj; 
  48.         if (age != other.age) 
  49.             return false; 
  50.         if (name == null) { 
  51.             if (other.name != null) 
  52.                 return false; 
  53.         } else if (!name.equals(other.name)) 
  54.             return false; 
  55.         return true; 
  56.     } 
  57.     */  
  58.       
  59.      //覆盖hashCode方法。根据对象自身的特点定义哈希值。  
  60.     public int hashCode(){  
  61.         final int NUMBER = 31;  
  62.         return name.hashCode()+ age*NUMBER;  
  63.     }  
  64.       
  65.      //需要定义对象自身判断内容相同的依据。覆盖equals方法。  
  66.     public boolean equals(Object obj){  
  67.         if (this == obj)  
  68.             return true;  
  69.         if(!(obj instanceof Student))  
  70.             throw new ClassCastException(obj.getClass().getName()+"类型错误");  
  71.         Student stu = (Student)obj;  
  72.         return this.name.equals(stu.name) && this.age == stu.age;  
  73.     }  
  74. }  
[java] view plain copy
  1. package ustc.lichunchun.set.demo;  
  2.   
  3. import java.util.HashSet;  
  4. import java.util.Iterator;  
  5. import java.util.Set;  
  6.   
  7. import ustc.lichunchun.domian.Student;  
  8.   
  9. public class HashSetTest {  
  10.   
  11.     public static void main(String[] args) {  
  12.         /* 
  13.          * 练习:往HashSet中存储学生对象(姓名,年龄)。同姓名、同年龄视为同一个人,不存。 
  14.          * 1.描述学生。 
  15.          * 2.定义容器。 
  16.          * 3.将学生对象存储到容器中。 
  17.          *  
  18.          * 发现存储了同姓名、同年龄的学生是可以的。 
  19.          * 原因是每一次存储学生对象,都先调用hashCode()方法获取哈希值。 
  20.          * 但此时调用的是Object类中的hashCode。所以同姓名同年龄了,但因为是不同的对象,哈希值也不同。 
  21.          * 这就是同姓名同年龄存入的原因。 
  22.          *  
  23.          * 解决: 
  24.          * 需要根据学生对象自身的特点来定义哈希值。 
  25.          * 所以就需要覆盖hashCode方法。 
  26.          *  
  27.          * 发现,当hashCode返回值相同时,会调用equals方法比较两个对象是否相等。 
  28.          * 还是会出现同姓名同年龄的对象,因为子类没有复写equals方法, 
  29.          * 直接用Object类的equals方法仅仅比较了两个对象的地址值。 
  30.          * 这就是同姓名同年龄还会存入的原因。 
  31.          *  
  32.          * 解决: 
  33.          * 需要定义对象自身判断内容相同的依据。 
  34.          * 所以就需要覆盖equals方法。 
  35.          *  
  36.          * 效率问题: 
  37.          * 尽量减少哈希算法求得的哈希值的冲突。减少equals方法的调用。 
  38.          */  
  39.         //1.创建容器对象。  
  40.         Set set = new HashSet();  
  41.           
  42.         //2.存储学生对象。  
  43.         set.add(new Student("xiaoqiang",20));  
  44.         set.add(new Student("wangcai",27));  
  45.         set.add(new Student("xiaoming",22));  
  46.         set.add(new Student("xiaoqiang",20));  
  47.         set.add(new Student("daniu",24));  
  48.         set.add(new Student("xiaoming",22));  
  49.           
  50.         //3.获取所有学生。  
  51.         for (Iterator it = set.iterator(); it.hasNext();) {  
  52.             Student stu = (Student) it.next();  
  53.             System.out.println(stu.getName()+":"+stu.getAge());  
  54.         }  
  55.     }  
  56. }  
    ArrayList存储元素依赖的是equals方法。比如remove、contains底层判断用的都是equals方法。
    HashSet判断元素是否相同:依据的是hashCode和equals方法。如果哈希冲突(哈希值相同),再判断元素的equals方法。如果equals方法返回true,不存;返回false,存储!

TreeSet<E>类

    java.util.Set<E>类基于TreeMap的NavigableSet实现。使用元素的自然顺序(Comparable的compareTo方法)对元素进行排序,或者根据创建 set 时提供的自定义比较器(Comparator的compare方法)进行排序,具体取决于使用的构造方法。此实现为基本操作(add、remove和contains)提供受保证的 log(n) 时间开销。

    TreeSet:可以对元素排序。

    有序:存入和取出的顺序一致。--> List

    排序:升序or降序。--> TreeSet

    代码示例:

[java] view plain copy
  1. package ustc.lichunchun.set.demo;  
  2.   
  3. import java.util.Iterator;  
  4. import java.util.Set;  
  5. import java.util.TreeSet;  
  6.   
  7. import ustc.lichunchun.domian.Student;  
  8.   
  9. public class TreeSetDemo {  
  10.   
  11.     public static void main(String[] args) {  
  12.         Set set = new TreeSet();  
  13.           
  14.         set.add("abc");  
  15.         set.add("heihei");  
  16.         set.add("nba");  
  17.         set.add("haha");  
  18.         set.add("heihei");  
  19.           
  20.         for (Iterator it = set.iterator(); it.hasNext();) {  
  21.             System.out.println(it.next());  
  22.         }  
  23.     }  
  24. }  
    程序输出:


    那如果往TreeSet集合中存入的是自定义元素呢?

    TreeSet排序方式
    需要元素自身具备比较功能。所以元素需要实现Comparable接口覆盖compareTo方法。如果元素不具备比较性,在运行时会发生ClassCastException异常。

    TreeSet能够进行排序。但是自定义的Person类并没有给出排序的规则。即普通的自定义类不具备排序的功能,所以要实现Comparable接口,强制让元素具备比较性,复写compareTo方法。

    如何保证元素唯一性
    参考的就是比较方法(比如compareTo)的返回值是否是0。是0,就是重复元素,不存。

    注意:在进行比较时,如果判断元素不唯一,比如,同姓名同年龄,才视为同一个人。
    在判断时,需要分主要条件和次要条件,当主要条件相同时,再判断次要条件,按照次要条件排序。

    示例:往TreeSet集合存入上一节所描述的学生类对象。要求按照年龄进行排序

[java] view plain copy
  1. package ustc.lichunchun.domian;  
  2.   
  3. /* 
  4.  * 学生类本身继承自Object类,具备一些方法。 
  5.  * 我们想要学生类具备比较的方法,就应该在学生类的基础上进行功能的扩展。 
  6.  * 比较的功能已经在Comparable接口中定义下来了,学生类只需要实现Comparable接口即可。  
  7.  * 记住:需要对象具备比较性,只要让对象实现comparable接口即可。 
  8.  */  
  9. public class Student implements Comparable{  
  10.     private String name;  
  11.     private int age;  
  12.     public Student() {  
  13.         super();  
  14.     }  
  15.     public Student(String name, int age) {  
  16.         super();  
  17.         this.name = name;  
  18.         this.age = age;  
  19.     }  
  20.     public String getName() {  
  21.         return name;  
  22.     }  
  23.     public void setName(String name) {  
  24.         this.name = name;  
  25.     }  
  26.     public int getAge() {  
  27.         return age;  
  28.     }  
  29.     public void setAge(int age) {  
  30.         this.age = age;  
  31.     }  
  32.     @Override  
  33.     public String toString() {  
  34.         return "Student [name=" + name + ", age=" + age + "]";  
  35.     }  
  36.     /* 
  37.     @Override 
  38.     public int hashCode() { 
  39.         final int prime = 31; 
  40.         int result = 1; 
  41.         result = prime * result + age; 
  42.         result = prime * result + ((name == null) ? 0 : name.hashCode()); 
  43.         return result; 
  44.     } 
  45.     @Override 
  46.     public boolean equals(Object obj) { 
  47.         if (this == obj) 
  48.             return true; 
  49.         if (obj == null) 
  50.             return false; 
  51.         if (getClass() != obj.getClass()) 
  52.             return false; 
  53.         Student other = (Student) obj; 
  54.         if (age != other.age) 
  55.             return false; 
  56.         if (name == null) { 
  57.             if (other.name != null) 
  58.                 return false; 
  59.         } else if (!name.equals(other.name)) 
  60.             return false; 
  61.         return true; 
  62.     } 
  63.     */  
  64.       
  65.      //覆盖hashCode方法。根据对象自身的特点定义哈希值。  
  66.     public int hashCode(){  
  67.         final int NUMBER = 31;  
  68.         return name.hashCode()+ age*NUMBER;  
  69.     }  
  70.       
  71.      //需要定义对象自身判断内容相同的依据。覆盖equals方法。  
  72.     public boolean equals(Object obj){  
  73.         if (this == obj)  
  74.             return true;  
  75.         if(!(obj instanceof Student))  
  76.             throw new ClassCastException(obj.getClass().getName()+"类型错误");  
  77.         Student stu = (Student)obj;  
  78.         return this.name.equals(stu.name) && this.age == stu.age;  
  79.     }  
  80.       
  81.     //实现了comparable接口,学生就具备了比较功能。该功能是自然排序使用的方法。  
  82.     //自然排序就以年龄的升序排序为主。  
  83.     //既然是同姓名同年龄是同一个人,视为重复元素,要判断的要素就有两个。  
  84.     //既然是按照年龄进行排序。所以先判断年龄,再判断姓名。  
  85.     @Override  
  86.     public int compareTo(Object o) {  
  87.         Student stu = (Student)o;  
  88.         System.out.println(this.name+":"+this.age+"......"+stu.name+":"+stu.age);  
  89.         if(this.age > stu.age)  
  90.             return 1;  
  91.         if(this.age < stu.age)  
  92.             return -1;  
  93.         //return 0;//0表示重复元素,不存。  
  94.         return this.name.compareTo(stu.name);//进一步细化条件,只有姓名、年龄都一样,才是重复元素。  
  95.         /* 
  96.         主要条件: 
  97.         return this.age - stu.age; 
  98.         */  
  99.         /* 
  100.         主要条件+次要条件: 
  101.         int temp = this.age - stu.age; 
  102.         return temp==0?this.name.compareTo(stu.age):temp; 
  103.          */  
  104.     }  
  105. }  
[java] view plain copy
  1. package ustc.lichunchun.set.demo;  
  2.   
  3. import java.util.Iterator;  
  4. import java.util.Set;  
  5. import java.util.TreeSet;  
  6.   
  7. import ustc.lichunchun.domian.Student;  
  8.   
  9. public class TreeSetDemo {  
  10.   
  11.     public static void main(String[] args) {  
  12.         Set set = new TreeSet();  
  13.           
  14.         set.add(new Student("xiaoqiang",20));//java.lang.ClassCastException 类型转换异常  
  15.                                             //问题:因为学生要排序,就需要比较,而没有定义比较方法,无法完成排序。  
  16.                                             //解决:add方法中实现比较功能,使用的是Comparable接口的比较方法。  
  17.                                             //comparable接口抽取并定义规则,强行对实现它的每个类的对象进行整体排序,实现我的类就得实现我的compareTo方法,否则不能创建对象。  
  18.         set.add(new Student("daniu",24));  
  19.         set.add(new Student("xiaoming",22));  
  20.         set.add(new Student("huanhuan",22));//根据复写的compareTo方法,huanhuan和xiaoming两个对象属于重复元素(进一步细化条件之前,compareTo返回值为0即视为重复),又TreeSet容器不存重复元素,所以huanhuan没有存进去。  
  21.         set.add(new Student("tudou",18));  
  22.         set.add(new Student("dahuang",19));  
  23.           
  24.         /*set.add(new Student("lisi02", 22));   
  25.         set.add(new Student("lisi007", 20));   
  26.         set.add(new Student("lisi09", 19));   
  27.         set.add(new Student("lisi08", 19));   
  28.         set.add(new Student("lisi11", 40));   
  29.         set.add(new Student("lisi16", 30));   
  30.         set.add(new Student("lisi12", 36));   
  31.         set.add(new Student("lisi10", 29));   
  32.         set.add(new Student("lisi22", 90));  
  33.         */  
  34.         for (Iterator it = set.iterator(); it.hasNext();) {  
  35.             Student stu = (Student)it.next();  
  36.             System.out.println(stu.getName()+":"+stu.getAge());  
  37.         }  
  38.     }  
  39. }  
    如何实现有序
    保证二叉树只return一边,比如:

[java] view plain copy
  1. public int compareTo(Object o){  
  2.     if (this.age == o.age)  
  3.         return 0;//保证TreeSet不存入自定义的重复元素。  
  4.     return 1;//保证添加的元素都存入二叉树的右子树。  
  5. }  

    TreeSet二叉树建立过程
    TreeSet底层是二叉树结构,二叉树结构特点是可以排序。并且对二叉树的建立过程内部优化,以减少比较次数。例子中将已排序的xiaoming:22作为根节点,是基于折半的排序思想。xiaoqiang:20、xiaoming:22、daniu:24已经按照顺序存好,为了提高效率,在已排序的数组中去找一个新元素存放的位置,折半的方法最快。所以第四个进来的元素huanhuan:22会先和中间的xiaoming:22比较,然后确定往大的方向还是小的方向走。按照改进前的规则,huanhuan:22和xiaoming:22属重复元素,不存。tudou:18进来,再和已排序的中间元素xiaoming:22比较。比xiaoming:22小,往小的方向走,接着和xiaoqiang:20比较,比它小,tudou:18放在xiaoqiang:20左子树位置上。此时,已排序的依次为:tudou:18、xiaoqiang:20、xiaoming:22、daniu:24。中间元素为xiaoming:22。
dahuang:19先和xiaoming:22比,比它小;再和xiaoqiang:20比,比它小;接着和tudou:18比,比它大,放在tudou:18的右子树上。
建树完毕,TreeSet容器存入元素完毕。

    取出元素过程

    根节点的左子树<右子树,所以先遍历左子树,再根节点,最后右子树即可。

    所以上述往TreeSet集合存入Student类元素的建树、取元素过程的输出结果为:


    TreeSet第一种排序方式:需要元素具备比较功能。所以元素需要实现Comparable接口。覆盖compareTo方法。

    需求中也有这样一种情况,元素具备的比较功能不是所需要的,也就是说不想按照自然排序的方式,而是按照自定义的排序方式,对元素进行排序。而且,存储到TreeSet中的元素万一没有比较功能,该如何排序呢?

    这时,就只能使用第二种排序方式--是让集合具备比较功能,定义一个比较器。联想到集合的构造函数,去查API。

    TreeSet第二种排序方式:需要集合具备比较功能,定义一个比较器。所以要实现java.util.Comparator<T>接口覆盖compare方法。将Comparator接口的对象,作为参数传递给TreeSet集合的构造函数。

    示例:自定义一个比较器,用来对学生对象按照姓名进行排序

    实现Comparator自定义比较器的代码如下:

[java] view plain copy
  1. package ustc.lichunchun.comparator;  
  2.   
  3. import java.util.Comparator;  
  4.   
  5. import ustc.lichunchun.domian.Student;  
  6.   
  7. /** 
  8.  * 自定义一个比较器,用来对学生对象按照姓名进行排序。 
  9.  *  
  10.  * @author lichunchun 
  11.  */  
  12. public class ComparatorByName extends Object implements Comparator {  
  13.   
  14.     @Override  
  15.     public int compare(Object o1, Object o2) {  
  16.         Student s1 = (Student) o1;  
  17.         Student s2 = (Student) o2;  
  18.   
  19.         int temp = s1.getName().compareTo(s2.getName());  
  20.         return temp == 0 ? s1.getAge() - s2.getAge() : temp;  
  21.     }  
  22.       
  23.     //ComparatorByName类通过继承Object类,已经复写了Comparator接口的equals方法。  
  24.     //这里的equals方法是用来判断多个比较器是否相同。  
  25.     //如果程序中有多个比较器,这时实现Comparator的类就应该自己复写equals方法,来判断几个比较器之间是否相同。  
  26. }  
     此时,再往TreeSet集合中存入学生类对象时,主要在TreeSet的构造函数中加入比较器参数,即可完成自定义排序。
[java] view plain copy
  1. package ustc.lichunchun.set.demo;  
  2.   
  3. import java.util.Iterator;  
  4. import java.util.Set;  
  5. import java.util.TreeSet;  
  6.   
  7. import ustc.lichunchun.comparator.ComparatorByName;  
  8. import ustc.lichunchun.domian.Student;  
  9.   
  10. public class TreeSetDemo2 {  
  11.   
  12.     public static void main(String[] args) {  
  13.   
  14.         //初始化TreeSet集合明确一个比较器。  
  15.         Set set = new TreeSet(new ComparatorByName());  
  16.           
  17.         set.add(new Student("xiaoqiang",20));  
  18.         set.add(new Student("daniu",24));  
  19.         set.add(new Student("xiaoming",22));  
  20.         set.add(new Student("tudou",18));  
  21.         set.add(new Student("daming",19));  
  22.         set.add(new Student("dahuang",19));  
  23.           
  24.         for (Iterator it = set.iterator(); it.hasNext();) {  
  25.             Student stu = (Student)it.next();  
  26.             System.out.println(stu.getName()+":"+stu.getAge());  
  27.         }  
  28.     }  
  29. }  
    TreeSet集合排序有两种方式,Comparable和Comparator区别
    1.让元素自身具备比较性,需要元素对象实现Comparable接口,覆盖compareTo方法。
    2.让集合自身具备比较性,需要定义一个实现了Comparator接口的比较器,并覆盖compare方法,并将该类对象作为实际参数传递给TreeSet集合的构造函数。
    3.容器使用Comparator比较器接口对元素进行排序,只要实现比较器对象就可以。
            -->降低了比较方式和集合之间的耦合性-->自定义比较器的方式更为灵活。
       元素自身可以具备比较功能
            -->自然排序通常都作为元素的默认排序。
    4.Comparable接口的compareTo方法,一个参数;Comparator接口的compare方法,两个参数。

    List是数组或者链表结构,允许重复元素。
    HashSet是哈希表结构,查询速度快。
    TreeSet是二叉树数据结构。二叉树结构可以实现排序,一堆数据只要存入二叉树,自动完成排序。

    如果你坚持看完了本博文上面这部分内容,可以尝试自己动手做下面这6个小练习:

[java] view plain copy
  1. package ustc.lichunchun.test;  
  2.   
  3. import java.util.Comparator;  
  4. import java.util.Set;  
  5. import java.util.TreeSet;  
  6.   
  7. import ustc.lichunchun.comparator.ComparatorByLength;  
  8.   
  9. /* 
  10.  * 练习1:将Person对象存储到HashSet集合中,同姓名同年龄视为同一个人,不存。(复写Person类的hashCode、equals方法) 
  11.  *  
  12.  * 练习2:将Person对象存储到TreeSet集合中,同姓名同年龄视为同一个人,不存,姓名升序排序为自然排序。(实现Comparable接口,复写compareTo方法,姓名为主要条件、年龄为次要条件) 
  13.  *  
  14.  * 练习3:基于练习2,实现Person对象按照年龄升序排序。(实现Comparable接口,复写compareTo方法,年龄为主要条件) 
  15.  *  
  16.  * 练习4:对多个字符串(不重复)按照长度排序(由短到长)。(字符串中已复写Comparable接口,但是是按照字典顺序排序,无法使用。这里应该实现Comparator比较器,复写compare方法,创建对象实例传参给TreeSet构造函数) 
  17.  *  
  18.  * 练习5:对多个字符串(重复),按照长度排序。(不可以使用Set。数组、List都可以解决这个问题) 
  19.  *  
  20.  * 练习6:通过LinkedList,定义一个堆栈数据结构。(利用addFirst、removeLast实现队列,addFirst、removeFirst实现堆栈) 
  21.  */  
  22. public class Test1 {  
  23.   
  24.     public static void main(String[] args) {  
  25.         /* 
  26.         HashSet set = new HashSet(); 
  27.         TreeSet set = new TreeSet(); 
  28.         set.add(new Person("lisi",18)); 
  29.         set.add(new Person("wanger",18)); 
  30.         set.add(new Person("zengcen",10)); 
  31.         set.add(new Person("huanhuan",22)); 
  32.         set.add(new Person("wanger",18)); 
  33.         set.add(new Person("hehe",24)); 
  34.          
  35.         for (Iterator it = set.iterator(); it.hasNext();) { 
  36.             System.out.println(it.next()); 
  37.         } 
  38.         */  
  39.         sortStringByLength2();  
  40.     }  
  41.     /* 
  42.      * 练习4:对多个字符串(不重复)按照长度排序(由短到长)。 
  43.      * 思路: 
  44.      * 1.多个字符串,需要容器存储。 
  45.      * 2.选择哪个容器?字符串是对象,可以选择集合,而且不重复,选择set集合。 
  46.      * 3.还需要排序,可以选择TreeSet集合。 
  47.      */  
  48.     public static void sortStringByLength(){  
  49.         //Set set = new TreeSet();//自然排序的方式。  
  50.         Set set = new TreeSet(new ComparatorByLength());//按照字符串长度排序。  
  51.         set.add("haha");  
  52.         set.add("abc");  
  53.         set.add("zz");  
  54.         set.add("nba");  
  55.         set.add("xixixi");  
  56.         for (Object obj : set) {  
  57.             System.out.println(obj);  
  58.         }  
  59.     }  
  60.       
  61.     /* 
  62.      * 练习5:对多个字符串(重复),按照长度排序。 
  63.      * 1.能使用TreeSet吗?不能。 
  64.      * 2.可以存储到数组、List。这里先选择数组。后面会讲解List。 
  65.      */  
  66.     public static void sortStringByLength2(){  
  67.         String[] strs = {"nba","haha","abccc","zero","xixi","nba","abccc","cctv","zero"};  
  68.         //自然排序可以使用String类中的compareTo方法。  
  69.         //但是现在要的是长度排序,这就需要比较器。  
  70.         //定义一个按照长度排序的比较器对象。  
  71.         Comparator comp = new ComparatorByLength();  
  72.           
  73.         //排序就需要嵌套循环。位置置换。  
  74.         for(int x = 0; x < strs.length-1; x++){  
  75.             for(int y = x+1; y < strs.length; y++){  
  76.                 //if(strs[x].compareTo(strs[y] > 0)){//按照字典顺序  
  77.                 if(comp.compare(strs[x], strs[y]) > 0)//按照长度顺序  
  78.                     swap(strs,x,y);  
  79.             }  
  80.         }  
  81.         for(String s : strs){  
  82.             System.out.println(s);  
  83.         }  
  84.     }  
  85.     public static void swap(String[] strs, int x, int y){  
  86.         String temp = strs[x];  
  87.         strs[x] = strs[y];  
  88.         strs[y] = temp;  
  89.     }  
  90.       
  91. }  
     这其中的Person类,我已经帮你实现好了。微笑
[java] view plain copy
  1. package ustc.lichunchun.domian;  
  2.   
  3. public class Person implements Comparable{  
  4.     private String name;  
  5.     private int age;  
  6.     public Person() {  
  7.         super();  
  8.     }  
  9.     public Person(String name, int age) {  
  10.         super();  
  11.         this.name = name;  
  12.         this.age = age;  
  13.     }  
  14.     public String getName() {  
  15.         return name;  
  16.     }  
  17.     public void setName(String name) {  
  18.         this.name = name;  
  19.     }  
  20.     public int getAge() {  
  21.         return age;  
  22.     }  
  23.     public void setAge(int age) {  
  24.         this.age = age;  
  25.     }  
  26.     @Override  
  27.     public String toString() {  
  28.         return "Person [name=" + name + ", age=" + age + "]";  
  29.     }  
  30.     @Override  
  31.     public int hashCode() {  
  32.         final int prime = 31;  
  33.         int result = 1;  
  34.         result = prime * result + age;  
  35.         result = prime * result + ((name == null) ? 0 : name.hashCode());  
  36.         return result;  
  37.     }  
  38.     /* 
  39.      * 建立Person类自己的判断对象是否相同的依据,必须要覆盖Object类中的equals方法。 
  40.      */  
  41.     public boolean equals(Object obj) {  
  42.         //为了提高效率,如果比较的对象是同一个,直接返回true即可。  
  43.         if(this == obj)  
  44.             return true;  
  45.           
  46.         if(!(obj instanceof Person))  
  47.                 throw new ClassCastException("类型错误");  
  48.         Person p = (Person)obj;  
  49.           
  50.         return this.name.equals(p.name) && this.age==p.age;  
  51.     }  
  52.     /*@Override 
  53.     public boolean equals(Object obj) { 
  54.         if (this == obj) 
  55.             return true; 
  56.         if (obj == null) 
  57.             return false; 
  58.         if (getClass() != obj.getClass()) 
  59.             return false; 
  60.         Person other = (Person) obj; 
  61.         if (age != other.age) 
  62.             return false; 
  63.         if (name == null) { 
  64.             if (other.name != null) 
  65.                 return false; 
  66.         } else if (!name.equals(other.name)) 
  67.             return false; 
  68.         return true; 
  69.     }*/  
  70.       
  71.     /*@Override//按照姓名升序为自然排序 
  72.     public int compareTo(Object o) { 
  73.         Person p = (Person)o; 
  74.         int temp = this.getName().compareTo(p.getName()); 
  75.         return temp==0?this.getAge()-p.getAge():temp; 
  76.     }*/  
  77.     @Override//按照年龄升序为自然排序  
  78.     public int compareTo(Object o) {  
  79.         Person p = (Person)o;  
  80.         int temp = this.getAge()-p.getAge();  
  81.         return temp==0?this.getName().compareTo(p.getName()):temp;  
  82.     }  
  83. }  
     按照字符串长度排序的自定义比较器,我也帮你实现好了哦。得意
[java] view plain copy
  1. package ustc.lichunchun.comparator;  
  2.