黑马程序员--java基础之类集框架（一）

Collection--集合框架的父类接口

    List--元素是有序的，可以重复，因为给体系有索引；特有方法：凡是可以操作角标的方法都是List特有的

        ArrayList:底层使用的是数组结构。特点：查询速度快，增加删除慢，线程不同步，默认长度是10，超过10后新建一个长度为5的ArrayList

                   存储自定义的元素时需要复写equals方法；

        LinkedList:底层使用的是链表结构。特点：查询速度慢，增加删除快，线程不同步。有特有的方法，带first和last的方法

       Vector:  在1.0版本前使用的存储容器，在1.2以后几乎被ArrayList替代，该容器是线程同步的，效率不高。

                        特有方法：带element；有自己的迭代器Enumeration（相当于Iterator）称为枚举

    Set--元素无序，但不可以重复

       hashSet：数据结构式哈希表，线程是非同步的；

       TreeSet：底层使用的是二叉树结构，可以对Set中的元素进行排序；compareTo方法return 1 ，0 ，-1；

                            有两种排序方式：一：在自定义类中实现Comperable接口并复写其中的comparTo方法；用的是默认的排序方式

                                                        二：重新定义一个比较器实现Comparator接口并复写其中的compare方法，定义需要的比较方式；

练习一：增删改查

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

class CollectionTest{     public static void main(String [] args){         ArrayList al = new ArrayList();                    //集合的增删改查操作。         al.add("java01");//1、add方法的参数类型是Object，以便接收任意类型对象         al.add("java02");//2、集合里面存放的都是对象的引用地址         al.add("java03");         al.add("java04");                    ArrayList al1 = new ArrayList();         al1.add("java07");         al1.add("java08");         al1.add("java05");         al1.add("java06");                    sop(al);         sop(al.size());                        //al.retainAll(al1);取俩个集合中的交集，al中保留交集部分         sop(al);         sop(al1);         al.remove("java02");//al.clear();            sop(al.contains("java03"));//判断是否包含该对象         sop(al.isEmpty());//判断该集合是否为空                               Iterator it = al.iterator();迭代器，取元素         while(it.hasNext()){                        sop(it.next());                 }         for(Iterator it = al.iterator(); it.hasNext(); ){             sop(it.next());         }           }            public static void sop(Object obj){         System.out.println(obj);     } }

练习二：模拟一个队列或堆栈数据结构

       提示：利用LinkedList中特有的方法addFirst()和removeFirst()

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

class DuiLie{     private LinkedList link;     DuiLie(){         link = new LinkedList();     }     public void myAdd(Object obj){         link.addFirst(obj);     }     public Object myGet(){         return link.removeLast();     }     public boolean myIsEmpty(){         return link.isEmpty();     } } class CollectionTest{       public static void main(String [] args){         DuiLie c = new DuiLie();         c.myAdd("java01");         c.myAdd("java02");         c.myAdd("java03");         c.myAdd("java04");         System.out.println(c);         while(!c.myIsEmpty()){             System.out.println(c.myGet());         }               } }

练习三：将一个数组的重复元素删除

       提示：1、需要新建一个列表存储删除后的数组

                   2、用迭代器遍历元素，取出元素后判断新数组中是否还有该元素（用contains()方法），如果没有，添加

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

class CollectionTest{     public static ArrayList delElement(ArrayList al){         ArrayList al1 = new ArrayList();         Iterator it = al.iterator();         while(it.hasNext()){             Object obj = it.next();             if(!al1.contains(obj))                 al1.add(obj);         }         return al1;     }     public static void main(String [] args){         ArrayList al = new ArrayList();         al.add("java01");         al.add("java01");         al.add("java03");         al.add("java05");         al.add("java03");         al.add("java02");                  System.out.println(al);         System.out.println(delElement(al));         } }

练习四：练习二的升级版，要求删除列表中重复的对象而非数组

       提示:1、新建一个类1，定义属性。

                    注意：需要重新写equals方法，因为contains方法会自动调取Object类中的equals，此equals判断的是引用地址。

                             方法中先判断是否obj instanceof 类1，不是的话直接抛出false，是的话将obj向下转型成类1；

                            然后return this.name.equals(p.name) && this.age == p.age;

              2、再建一个类2，此类中定义删除重复元素的方法，和练习二相同

              3、主函数用iterator取元素时，it。next（）是引用的地址值，需要向下转型后调用具体的方法

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

class Person{     private String name;     private int age;     Person(String name, int age){         this.name = name;         this.age = age;     }     public boolean equals(Object obj){         if(!(obj instanceof Person))             return false;         Person p = (Person)obj;         return this.name.equals(p.name) && this.age == p.age;     }     public String getName(){         return name;            }     public int getAge(){         return age;     } }   class CollectionTest{     public static ArrayList delElement(ArrayList al){         ArrayList al1 = new ArrayList();         Iterator it = al.iterator();         while(it.hasNext()){             Object obj = it.next();             if(!al1.contains(obj))                 al1.add(obj);         }         return al1;     }     public static void main(String [] args){                ArrayList al = new ArrayList();         al.add(new Person("zhangsan01", 21));         al.add(new Person("zhangsan01", 21));         al.add(new Person("zhangsan02", 22));         al.add(new Person("zhangsan03", 23));         al.add(new Person("zhangsan03", 23));         al.add(new Person("zhangsan04", 24));                  ArrayList al1 = delElement(al);         Iterator it = al1.iterator();         while(it.hasNext()){             Person p = (Person)it.next();                       System.out.println(p.getName()+ "......" + p.getAge());         }           } }