黑马程序员----List,Set集合的基本概念和迭代器

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

1.集合基本概念

Collection定义了集合框架的共性功能。
(1)添加
    add(e);
    addAll(collection);
(2)删除
    remove(e);
    removeAll(collection);
    clear();
(3)判断。
    contains(e);
    isEmpty();
(4)获取
    iterator();
    size();
(5)获取交集。
    retainAll();
(6)集合变数组。
    toArray();

注意：add方法的参数类型是Object。以便于接收任意类型对象。集合中存储的都是对象的引用(地址)

[java]  view plain copy

1. public static void base_method()  
2. {  
3.         //创建一个集合容器。使用Collection接口的子类。ArrayList  
4.         ArrayList al = new ArrayList();  
5.     //添加元素。  
6.         al.add("java01");//add(Object obj);  
7.         al.add("java02");  
8.         al.add("java03");  
9.         al.add("java04");  
10.         //删除元素。  
11.         //al.remove("java02");  
12.         //al.clear();//清空集合。  
13.     //判断元素。  
14.         System.out.println("java03是否存在:"+al.contains("java03"));  
15.         System.out.println("集合是否为空？"+al.isEmpty());  
16.     //获取个数。集合长度。  
17.         System.out.println("size:"+al.size());  
18. }  

2.迭代器

什么是迭代器呢？
其实就是集合的取出元素的方式。迭代器是取出方式，会直接访问集合中的元素。所以将迭代器通过内部类的形式来进行描述。通过容器的iterator()方法获取该内部类的对象。

[java]  view plain copy

1. public static void method_get()  
2. {  
3.         ArrayList al = new ArrayList();  
4.   
5.         //1，添加元素。  
6.         al.add("java01");//add(Object obj);  
7.         al.add("java02");  
8.         al.add("java03");  
9.         al.add("java04");  
10.         /* 
11.         Iterator it = al.iterator();//获取迭代器，用于取出集合中的元素。 
12.  
13.         while(it.hasNext()) 
14.         { 
15.             System.out.println(it.next()); 
16.         } 
17.         */  
18.         //老外的写法，循环结束后it就消失了  
19.         for(Iterator it = al.iterator(); it.hasNext() ; )  
20.         {  
21.             System.out.println(it.next());  
22.         }  
23. }  

3.List集合

Collection
    |--List:元素是有序的，元素可以重复。因为该集合体系有索引。
        |--ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。
        |--LinkedList:底层使用的链表数据结构。特点：增删速度很快，查询稍慢。线程不同步。
        |--Vector:底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低。
  |--Set：元素是无序，元素不可以重复。、

List：
    特有方法。凡是可以操作角标的方法都是该体系特有的方法。
增
    add(index,element);
    addAll(index,Collection);
删
    remove(index);
改
    set(index,element);
查
    get(index):
    subList(from,to); //截取一个子集合
    listIterator();List的迭代器
    int indexOf(obj):获取指定元素的位置。

[java]  view plain copy

1. public static void method()  
2.     {  
3.           
4.         ArrayList al = new ArrayList();  
5.   
6.         //添加元素  
7.         al.add("java01");  
8.         al.add("java02");  
9.         al.add("java03");         
10.         //在指定位置添加元素。  
11.         al.add(1,"java09");  
12.         //删除指定位置的元素。  
13.         //al.remove(2);  
14.         //修改元素。  
15.         //al.set(2,"java007");  
16.         //通过角标获取元素。  
17.         System.out.println("get(1):"+al.get(1));  
18.         //获取所有元素。  
19.         for(int x=0; x<al.size(); x++)//通过角标遍历  
20.         {  
21.             System.out.println("al("+x+")="+al.get(x));  
22.         }  
23.   
24.         Iterator it = al.iterator();  
25.     while(it.hasNext())  
26.         {  
27.             sop("next:"+it.next());  
28.         }  
29. }  

4.ListIterator

List集合特有的迭代器。ListIterator是Iterator的子接口。
使用原因：在迭代时，不可以通过集合对象的方法操作集合中的元素。因为会发生ConcurrentModificationException异常。所以，在迭代器时，只能用迭代器的放过操作元素，可是Iterator方法是有限的，只能对元素进行判断，取出，删除的操作，如果想要其他的操作如添加，修改等，就需要使用其子接口，ListIterator。该接口只能通过List集合的listIterator方法获取。

5.LinkList

LinkedList:特有方法：
addFirst();//打印出来就是倒序的
addLast();//打印出来是正序的

getFirst();
getLast();
获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException

removeFirst();
removeLast();
获取元素，但是元素被删除。如果集合中没有元素，会出现NoSuchElementException

在JDK1.6出现了替代方法。
offerFirst();
offerLast();//添加元素

peekFirst();
peekLast();
获取元素，但不删除元素。如果集合中没有元素，会返回null。

pollFirst();
pollLast();
获取元素，但是元素被删除。如果集合中没有元素，会返回null。

6.LinkList练习，这个必须会

[java]  view plain copy

1. import java.util.*;  
2. class DuiLie  
3. {  
4.     private LinkedList link;  
5.     DuiLie()  
6.     {  
7.         link = new LinkedList();//创建的是链表对象  
8.     }  
9.     //添加元素  
10.     public void myAdd(Object obj)  
11.     {  
12.         link.addFirst(obj);//进去后是倒序的  
13.     }  
14.     //获取元素  
15.     public Object myGet()  
16.     {  
17.         return link.removeLast();//倒序打印，然后出来就是正序了  
18.     }  
19.     //判断是否为空  
20.     public boolean isNull()  
21.     {  
22.         return link.isEmpty();  
23.     }  
24.   
25. }  
26. class  LinkedListTest  
27. {  
28.     public static void main(String[] args)   
29.     {  
30.         DuiLie dl = new DuiLie();  
31.         dl.myAdd("java01");  
32.         dl.myAdd("java02");  
33.         dl.myAdd("java03");  
34.         dl.myAdd("java04");  
35.         while(!dl.isNull())//循环打印，打印完集合内就为空了  
36.         {  
37.             System.out.println(dl.myGet());  
38.         }  
39.     }  
40. }  

7.ArrayList练习

[java]  view plain copy

1. //目的是筛选，只存入单一的元素  
2. class ArrayListTest  
3. {  
4.         public static void main(String[] args)  
5.         {  
6.             ArrayList al = new ArrayList();  
7.             al.add("java01");     
8.             al.add("java02");  
9.             al.add("java01");  
10.             al.add("java02");  
11.             al.add("java01");  
12.             al.add("java03");  
13.             al = singleElement(al);  
14.         System.out.println(al);  
15.         }  
16.           
17.         public static ArrayList singleElement(ArrayList al)  
18.         {  
19.             //定义一个临时容器  
20.             ArrayList newAl = new ArrayList();  
21.             Iterator it = al.Iterator();  
22.             while(it.hasNext())  
23.             {  
24.                 Object obj = it.next();//变量临时存储  
25.                 if(!newAl.contains(obj))  
26.                         newAl.add(obj); //把newAl里没有的添加进去  
27.             }  
28.             return newAl;  
29.         }         
30. }  

8.ArrayList练习2

要求：将自定义对象作为元素存到ArrayList集合中，并去除重复元素。比如：存人对象。同姓名同年龄，视为同一个人。为重复元素。
最关键的一点：List集合判断元素是否相同，依据是元素的equals方法。因此要在Person类中重写该方法，要不然比较的就是地址值
要记住在List集合中remove、contains也好比较时都会调用equals

[java]  view plain copy

1. class Person//定义一个人的类  
2. {  
3.     private String name;  
4.     private int age;  
5.     Person(String name,int age)  
6.     {  
7.         this.name = name;  
8.         this.age = age;  
9.     }  
10.     public boolean equals(Object obj)//重写方法，改变比较方式Object obj = new Person(参数);  
11.     {  
12.         if(!(obj instanceof Person))//规定要传的是人对象  
13.             return false;  
14.     //这是个多态Object类型的引用是无法调用该类特有方法的，要转  
15.         Person p = (Person)obj;  
16.         return this.name.equals(p.name) && this.age == p.age;//调用contains下个元素会调用equals  
17.                                                          //然后把集合内的元素传进来，然后比较  
18.     }  
19.     public String getName()  
20.     {  
21.         return name;  
22.     }  
23.     public int getAge()  
24.     {  
25.         return age;  
26.     }  
27. }  
28. class ArrayListTest2   
29. {  
30.     public static void sop(Object obj)//简化输出语句书写  
31.     {  
32.         System.out.println(obj);  
33.     }  
34.     public static void main(String[] args)   
35.     {  
36.         ArrayList al = new ArrayList()//创建集合  
37.         al.add(new Person("lisi01",30));//al.add(Object obj);//Object obj = new Person("lisi01",30);  
38.         al.add(new Person("lisi02",32));  
39.         al.add(new Person("lisi02",32));  
40.         al.add(new Person("lisi04",35));  
41.         al.add(new Person("lisi03",33));  
42.       
43.       al = singleElement(al);//调用筛选方法  
44.         //sop("remove 03 :"+al.remove(new Person("lisi03",33)));//remove方法底层也是依赖于元素的equals方法。  
45.         Iterator it = al.iterator();  
46.       
47.         while(it.hasNext())  
48.         {  
49.             Person p = (Person)it.next();//转为Person类型  
50.             sop(p.getName()+"::"+p.getAge());  
51.         }  
52.     }  
53.   
54.     public static ArrayList singleElement(ArrayList al)  
55.     {  
56.         //定义一个临时容器。  
57.         ArrayList newAl = new ArrayList();  
58.       
59.         Iterator it = al.iterator();  
60.       
61.         while(it.hasNext())  
62.         {  
63.             Object obj = it.next();  
64.             if(!newAl.contains(obj))//去调用equals方法了  
65.                 newAl.add(obj);   
66.         }  
67.       return newAl;  
68.     }  
69. }  

9.HashSet

|--Set：元素是无序(存入和取出的顺序不一定一致)，元素不可以重复。、
    |--HashSet:底层数据结构是哈希表。是线程不安全的。不同步。
            HashSet是如何保证元素唯一性的呢？
            是通过元素的两个方法，hashCode和equals来完成。 如果元素的HashCode值相同，才会判断equals是否为true。 如果元素的hashcode值不同，不会调用equals。

            注意,对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。
  |--TreeSet
  Set集合的功能和Collection是一致的。

10.TreeSet

可以对Set集合中的元素进行排序。
要想按照存入的顺序取该集合中的元素呢？
要知道，该集合的大小判断取决于compareTo返回的结果，我如果直接返回1,那么后一个就会比前一个大，这不就行了么所以：底层数据结构是二叉树。保证元素唯一性的依据：compareTo方法return 0.

TreeSet排序的第一种方式：让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法。
也种方式也成为元素的自然顺序，或者叫做默认顺序。

[java]  view plain copy

1. //这就是一个具备比较性的学生类,第一种排序方式下的  
2. class Student implements Comparable//该接口强制让学生具备比较性。  
3. {  
4.     private String name;  
5.     private int age;  
6.   
7.     Student(String name,int age)  
8.     {  
9.         this.name = name;  
10.         this.age = age;  
11.     }  
12.     public int compareTo(Object obj)//覆盖接口的方法  
13.     {  
14.         if(!(obj instanceof Student))  
15.             throw new RuntimeException("不是学生对象");  
16.         //强制转换类型  
17.         Student s = (Student)obj;  
18.         if(this.age>s.age)  
19.             return 1;  
20.         if(this.age==s.age)//年龄相同就要比较姓名的自然顺序  
21.         {  
22.             return this.name.compareTo(s.name);//String类中的方法  
23.         }  
24.         return -1;  
25.     }  
26.   
27.     public String getName()  
28.     {  
29.         return name;  
30.     }  
31.     public int getAge()  
32.     {  
33.         return age;  
34.     }  
35. }  

11.TreeSet的第二种排序方式

当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。在集合初始化时，就有了比较方式。定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。
当两种排序都存在时，以比较器为主。定义一个类，实现Comparator接口，覆盖compare方法。

[java]  view plain copy

1. class MyCompare implements Comparator  
2. {  
3.     public int compare(Object o1,Object o2)  
4.     {  
5.         Student s1 = (Student)o1;  
6.         Student s2 = (Student)o2;  
7.   
8.         int num = s1.getName().compareTo(s2.getName()); //num 存储比较返回的值  
9.         if(num==0) //姓名相同就比较年龄  
10.         {  
11.   
12.             return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));//Integer同样具备比较性  
13.             /* 
14.             这种比较方式有些麻烦 
15.             if(s1.getAge()>s2.getAge()) 
16.                 return 1; 
17.             if(s1.getAge()==s2.getAge()) 
18.                 return 0; 
19.             return -1; 
20.             */  
21.         }     
22.         return num;//姓名不同就返回比较结果  
23.     }  
24. }