1. /*
   
2. Collection
   
3. |--List:元素是有序的，元素可以重复。因为该集合体系有索引。
   
4. |--ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。
   
5. |--LinkedList:底层使用的链表数据结构。特点：增删速度很快，查询稍慢。线程不同步。
   
6. |--Vector:底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低。
   
7. 
   
8. 
   
9. |--Set：元素是无序，元素不可以重复。、
   
10. 
    
11. 
    
12. List：
    
13. 特有方法。凡是可以操作角标的方法都是该体系特有的方法。
    
14. 
    
15. 增
    
16. add(index,element);
    
17. addAll(index,Collection);
    
18. 
    
19. 删
    
20. remove(index);
    
21. 
    
22. 改
    
23. set(index,element);
    
24. 查
    
25. get(index):
    
26. subList(from,to);
    
27. listIterator();
    
28. int indexOf(obj):获取指定元素的位置。
    
29. ListIterator listIterator();
    
30. 
    
31. 
    
32. 
    
33. 
    
34. 
    
35. List集合特有的迭代器。ListIterator是Iterator的子接口。
    
36. 
    
37. 在迭代时，不可以通过集合对象的方法操作集合中的元素。
    
38. 因为会发生ConcurrentModificationException异常。
    
39. 
    
40. 所以，在迭代器时，只能用迭代器的放过操作元素，可是Iterator方法是有限的，
    
41. 只能对元素进行判断，取出，删除的操作，
    
42. 如果想要其他的操作如添加，修改等，就需要使用其子接口，ListIterator。
    
43. 
    
44. 该接口只能通过List集合的listIterator方法获取。
    
45. 
    
46. */
    
47. 
    
48. 
    
49. import java.util.*;
    
50. class ListDemo
    
51. {
    
52. public static void sop(Object obj)
    
53. {
    
54. System.out.println(obj);
    
55. }
    
56. public static void method()
    
57. {
    
58. 
    
59. ArrayList al = new ArrayList();
    
60. 
    
61. //添加元素
    
62. al.add("java01");
    
63. al.add("java02");
    
64. al.add("java03");
    
65. 
    
66. sop("原集合是："+al);
    
67. //在指定位置添加元素。
    
68. al.add(1,"java09");
    
69. 
    
70. //删除指定位置的元素。
    
71. //al.remove(2);
    
72. 
    
73. //修改元素。
    
74. //al.set(2,"java007");
    
75. 
    
76. //通过角标获取元素。
    
77. sop("get(1):"+al.get(1));
    
78. 
    
79. sop(al);
    
80. 
    
81. //获取所有元素。
    
82. for(int x=0; x<al.size(); x++)
    
83. {
    
84. System.out.println("al("+x+")="+al.get(x));
    
85. }
    
86. 
    
87. Iterator it = al.iterator();
    
88. 
    
89. while(it.hasNext())
    
90. {
    
91. sop("next:"+it.next());
    
92. }
    
93. 
    
94. 
    
95. //通过indexOf获取对象的位置。
    
96. sop("index="+al.indexOf("java02"));
    
97. 
    
98. List sub = al.subList(1,3);
    
99. 
    
100. sop("sub="+sub);
     
101. }
     
102. 
     
103. 
     
104. public static void main(String[] args)
     
105. {
     
106. 
     
107. //演示列表迭代器。
     
108. ArrayList al = new ArrayList();
     
109. 
     
110. //添加元素
     
111. al.add("java01");
     
112. al.add("java02");
     
113. al.add("java03");
     
114. 
     
115. sop(al);
     
116. 
     
117. 
     
118. ListIterator li = al.listIterator();
     
119. 
     
120. 
     
121. //sop("hasPrevious():"+li.hasPrevious());
     
122. 
     
123. while(li.hasNext())
     
124. {
     
125. Object obj = li.next();
     
126. 
     
127. if(obj.equals("java02"))
     
128. //li.add("java009");
     
129. li.set("java006");
     
130. 
     
131. 
     
132. }
     
133. 
     
134. while(li.hasPrevious())
     
135. {
     
136. sop("pre::"+li.previous());
     
137. }
     
138. //sop("hasNext():"+li.hasNext());
     
139. //sop("hasPrevious():"+li.hasPrevious());
     
140. 
     
141. 
     
142. sop(al);
     
143. 
     
144. 
     
145. 
     
146. /*
     
147. //在迭代过程中，准备添加或者删除元素。
     
148. 
     
149. Iterator it = al.iterator();
     
150. 
     
151. while(it.hasNext())
     
152. {
     
153. Object obj = it.next();
     
154. 
     
155. if(obj.equals("java02"))
     
156. //al.add("java008");
     
157. it.remove();//将java02的引用从集合中删除了。
     
158. 
     
159. sop("obj="+obj);
     
160. 
     
161. 
     
162. }
     
163. sop(al);
     
164. */
     
165. 
     
166. 
     
167. 
     
168. }
     
169. }
     

复制代码

以上代码中为什么
while(li.hasNext())
{
Object obj = li.next();
while循环中 要用Object  别的可以吗 请举例 TKS

哎,技术分这么多...有点失水准的问题.
如果你学了泛型就会明白为什么用Object,第一是面向父类或接口编程,第二是因为专一类型会发生异常,因为你的集合里存的是字符,万一你硬把值赋给Person,就会出异常.你也可以这样String str=(String)li.next();

Object 是上帝，是所有对象的父类，所以可以代表所有对象的类型，
而编译器是不知道你集合里面存放对象的类型的，所以取出时只能用Object 代表任意类型。
使用泛型就不用Object  ，用回对象本类型就可以了

Iterator<E>是一个泛型类型的类，E next()方法返回的也是一个泛型类型，也就是说编译时期，编译器不并不能确定具体类型，
虽然说编译后会把泛型信息去掉，但实际的class文件中还会存泛型的信息，为了提高性能，编译器把class文件分为两部分，一部分是泛泛型信息，一部分是类的信息，
我想没有使用泛泛型时，为了提高代码的利用率，将Object作为形参，这样可以接收所有的类型的实参。