Java基础--集合框架只List

凌风博客原创作品。转载请注明出处：http://blog.youkuaiyun.com/q549130180/article/details/45313433

Collection

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


List:
特有方法，凡是可以操作角标的方法都是该体系特有的方法。


增
add(index,element);
add(index,Collection);


删
remove(index);


改
set(index,element);


查
get(index);
subList(from,to);
listIterator();




List集合特有的迭代器，ListIterator是Iterator的子接口。


在迭代时，不可以通过集合对象的方法操作集合中的元素
因为会发生ConcurrentModificationException异常


所以，在迭代器时，只能用迭代器的放过操作元素，可是Iterator方法时有限的，
只能对元素进行判断，取出，删除的操作
如果想要其他的操作如添加，修改等，就需要使用其子接口，ListIterator

该接口只能通过List集合的listIterator方法获取

[java]  view plain copy

1. import java.util.*;  
2.   
3.   
4. class ListDemo2   
5. {  
6.     public static void main(String[] args)   
7.     {  
8.         //演示列表迭代器  
9.   
10.         ArrayList al = new ArrayList();  
11.           
12.         al.add("java01");    
13.         al.add("java02");  
14.         al.add("java03");  
15.           
16.         sop(al);  
17.   
18.         ListIterator li = al.listIterator();  
19.   
20.         //sop("hasPrevious():"+li.hasPrevious());  
21.   
22.         Iterator it = al.iterator();  
23.   
24.         while (it.hasNext())  
25.         {  
26.             Object obj = li.next();  
27.             if (obj.equals("java02"))  
28.             {  
29.                 //li.add("java0009");  
30.                 li.set("java006");  
31.             }  
32.         }  
33.   
34.         while (li.hasPrevious())  
35.         {  
36.             sop("pre:"+li.previous());  
37.         }  
38.         //sop("hasNext():"+li.hasNext());  
39.         //sop("hasPrevious():"+li.hasPrevious());  
40.   
41.         sop(sl);  
42.         /* 
43.         //在迭代过程中，准备添加或者删除元素 
44.         Iterator it = al.iterator(); 
45.         while (it.hasNext()) 
46.         { 
47.             Object obj = it.next(); 
48.             if (obj.equals("java02")) 
49.             { 
50.                 al.add("java008"); 
51.                 //it.remove();//将java02的引用从集合中删除了 
52.             } 
53.             sop("obj"+obj); 
54.         } 
55.         */  
56.   
57.     }  
58.   
59.     public static void method()  
60.     {  
61.         ArrayList al = new ArrayList();  
62.           
63.         al.add("java01");    
64.         al.add("java02");  
65.         al.add("java03");  
66.   
67.         sop("原集合是："+al);  
68.   
69.         //在指定位置添加元素  
70.         al.add(1,"java09");  
71.   
72.         //删除指定位置的元素。  
73.         //al.remove(2);  
74.   
75.         //修改元素  
76.         //al.set(2,"java007");  
77.   
78.         //通过角标获取元素。  
79.         sop("get(1)"+al.get(1));  
80.   
81.         sop(al);  
82.   
83.         //获取所有元素  
84.         for (int x = 0;x< al.size() ;x++ )  
85.         {  
86.             System.out.println("al("+x+")="+al.get(x));  
87.         }  
88.   
89.         Iterator it = al.iterator();  
90.         while (it.hasNext())  
91.         {  
92.             sop("next:"+it.next());  
93.         }  
94.   
95.   
96.         //通过indexOf获取对象的位置  
97.         sop("index="+al.indexOf("java02"));  
98.   
99.   
100.         //获取子列表，1到3  
101.         List sub = al.subList(1,3);  
102.   
103.         sop("sub="+sub);  
104.     }  
105.   
106.   
107.     public static void sop(Object obj)  
108.     {  
109.         System.out.println(obj);  
110.     }  
111. }  

枚举就是Vector特有的取出方式
发现枚举和迭代器很像
其实枚举和迭代时一样的


因为枚举的名称以及方法的名称都过长
所以被迭代器取代了
枚举郁郁而终

[java]  view plain copy

1. class VectorDemo  
2. {  
3.     public static void main(String[] args)   
4.     {  
5.         Vector v = new Vector();  
6.   
7.         v.add("java01");  
8.         v.add("java02");  
9.         v.add("java03");  
10.         v.add("java04");  
11.         Enumeration en =v.elements();  
12.         while (en.hsaMoreElements())  
13.         {  
14.             System.out.println(en.nextElement());  
15.         }  
16.           
17.     }  
18. }  

LinkedList特有方法:
addFirst();
addLast();


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


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




在JDK1.6 出现了替代方法
offerFirst();
offerLast();


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


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

[java]  view plain copy

1. class LinkedListDemo3  
2. {  
3.     public static void main(String[] args)   
4.     {  
5.         LinkedList link = new LinkedList();  
6.   
7.         link.addLast("java01");  
8.         link.addLast("java02");  
9.         link.addLast("java03");  
10.         link.addLast("java04");  
11.   
12.         sop(link);  
13.   
14.         //sop(link.getFirst());  
15.         //sop(link.getLast);  
16.         //sop(link.removeFirst());  
17.           
18.         sop("size="+link.size());  
19.   
20.         //不使用迭代器遍历输出  
21.         while (!link.isEmpty())  
22.         {  
23.             sop(link.removeLast());  
24.         }  
25.   
26.     }  
27.   
28.   
29.     public static void sop(Object obj)  
30.     {  
31.         System.out.println(obj);  
32.     }  
33. }  

ArrayList练习


将自定义对象作为元素存到ArrayList集合中，并去除重复元素


比如：存人对象。同姓名同年龄，视为同一个人，为重复元素


思路：
1.对人描述，将数据封装进人对象。
2.定义容器，将人存入
3.取出

[java]  view plain copy

1. class Person  
2. {  
3.     Person(String name,int age)  
4.     {  
5.         this.name = name;  
6.         this.age = age;  
7.     }  
8.   
9.     public boolean equals(Object obj)  
10.     {  
11.         if (!(obj instanceof Person))  
12.         {  
13.             return false;  
14.         }  
15.         System.out.println(this.name+"..."+p.name);  
16.   
17.         return this.name.equals(p.name) && this.age ==p.age;  
18.     }  
19.   
20.     public String getName()  
21.     {  
22.         return name;  
23.     }  
24.   
25.     public int getAge()  
26.     {  
27.         return age;  
28.     }  
29. }  
30.   
31. class ArrayListTest4  
32. {  
33.     public static void sop(Object obj)  
34.     {  
35.         System.out.println(obj);  
36.     }  
37.   
38.     public static void main(String[] args)   
39.     {  
40.         ArrayList al = new ArrayList();  
41.   
42.         al.add(new Person("lisi01",30));  //al.add(Object obj);  //Object obj = new Person("lishi01",30);  赋给obj后，对象类型提升为Object  
43.         al.add(new Person("lisi02",31));  
44.         al.add(new Person("lisi02",31));  
45.         al.add(new Person("lisi03",32));  
46.         al.add(new Person("lisi04",34));  
47.         al.add(new Person("lisi04",34));  
48.   
49.         //al = singleElement(al);  
50.   
51.         sop("remove 03:"+al.remove(new Person("lisi03",32)));  
52.   
53.         Iterator it = al.iterator();  
54.         while (it.hasNext())  
55.         {  
56.             Person p = (Person)it.next();  
57.             sop(p.getName()+"...."+p.getAge());  
58.         }  
59.     }  
60.   
61.     public static ArrayList singleElement(ArrayList al)  
62.     {  
63.         //定义一个临时容器  
64.         ArrayList newAl = new ArrayList();  
65.   
66.         Iterator it = al.iterator();  
67.   
68.         while (it.hasNext())  
69.         {  
70.             Object obj = it.next();  
71.   
72.             if (!newAl.contains(obj))  
73.             {  
74.                 newAl.add(obj);  
75.             }  
76.         }  
77.         return newAl;  
78.     }  
79. }