6.1 集合框架的概述
6.1.1 引入集合框架
（1）数组长度固定不变，不能很好地适应元素动态变化的情况。若要存储大于50个狗狗的信息，则数组长度不足;若只存储20个狗狗的信息，则造成内存的空间浪费。
（2）课通过数组名.length获取数组的长度，却无法直接获取数组中真实的存储狗狗个数
（3）数组采用在内存中分配连续空间的存储方式，根据下标可以快速获取对应狗狗的信息，但根据狗狗信息查找效率低下，需要多次比较。在进行频繁插入，删除操作是同样效率低下。
6.1.2 Java集合框架包含的内容
Java集合框架为我们提供了一套性能优良，使用方便的接口和类，他们都位于java.util包中。Java集合框架包含的主要内容及彼此的关系如图：
集合框架是为表示和操作集合而规定的一种统一的标准体系结构。集合框架都包含三大块内容：对外接口、接口的实现和对集合运算的算法。
（1） 接口：表示框架中的抽象数据类型，在上图中虚线表示，如Collection、List、Set、Map、lterator。
（2） 实现：集合框架中接口的具体实现，在上图中实线表示，粗实线框表示最常用的实现，如ArrayList、LinkedList、HashMap、HashSet。
（3） 算法：在一个实现了某个集合操作的工具类Collection(注意不是Collection，类似于Arrays类)，他提供了对集合进行排序等多种算法实现。在使用Collection的时候可以查阅JDK帮助文档。
从上图看可以清楚地看出Java集合框架中的两大类接口：Collection和Map。其中Collection又有两个子接口：List和Set。所以通常说Java集合框架共有三大类接口：List、Set和Map。他们的共同点：都是几个几口，都可以同来存储很多对象。他们的区别如下：
（1） Collection接口存储一组不唯一(允许重复)、无序的对象。
（2） Set接口继承Collection接口，存储一组唯一(不允许重复)、无序对象
（3） List接口继承Collection接口，存储一组不唯一(允许重复)、有序(以元素插入的次序来放置元素，不会重新排列)的对象。
（4） Map接口存储一组成对的键-值对象，提供Key(键)到value(值)的映射。Map中的key不要求有序，不允许重复。Value同样不要求有序，但允许重复。
（5） Iterator接口是负责定义访问和遍历元素的接口。
在集合框架中，List可以理解为前面讲过的数组，元素的内容可以重复并且有序，Set可以理解为数学中的集合，里面数据不重复并且无序，Map也可以理解为数学中的集合，只是其中每个元素都有key和value两个对象组成。
6.2 List接口
实现List接口的常用类有ArrayList和LinkedList。他们都可以容纳所有类型的对象，包括null。允许重复，并且都保证元素的存储顺序。
ArrayList对数组进行了封装，实现了长度可变的数组，ArrayList存储数据的方式和数组相同，都是在内存中分配连续的空间，他的优点在于遍历元素和随机访问元素的效率比较高。
LinkedList采用链表存储方法。优点在于插入、删除元素是效率比较高。他提供了额外addFirst()、addLast()、removeFirst()和removeLast()等方法，可以在LinkedList的首部或尾部进行插入或删除操作。这些方法使得LinkedList可被用作堆载(stack)过着队列(queue)。
6.2.1 ArrayList集合类
元素个数不确定，要求获得存储元素的实际个数，按照存储顺你能虚获取并输出元素信息，可以通过List接口的实现类ArrayList实现该需求。
List接口中定义的各种常用方法
方法 |
方法作用 |
boolean add(Object obj) |
将指定对象obj新增至集合内，增加成功传回true，否则传回false |
boolean addAll(Collection c) |
将指定集合c内所有元素新增至集合内，增加成功传回true，否则传回false |
viod clear() |
将集合内所有元素清空 |
boolean isEmpty() |
检查集合内是否没有任何元素，如果是传回true，否则传回false |
Iterator iterator() |
将集合内的元素信息转存成Iterator对象 |
boolean remove(Object obj) |
将指定元素obj从集合内移除，成功移除传回true，否则传回false |
int size() |
将集合内的元素总数传回 |
Object[] toArray() |
将集合内的元素转存到数组后传回该数组 |
6.2.3 LinkedList集合类
LinkedList的一些特殊方法
方法 |
方法说明 |
void add(Object obj) |
将Obj插入列表中的一个元素前，该元素在下一次调用next()方法时被返回 |
boolean hasNext() |
如果存在下一个元素，则返回true，否则返回false |
boolean hasPrevious() |
如果存在前一个元素，则返回true，否则返回false |
Object next() |
返回下一个元素，如不存在，引发一个NoSuchElementException异常 |
int nextIndex() |
返回下一个元素的下表，如果不存在下一个元素，则返回列表的大小 |
Object previous() |
返回前一个元素，如不存在，引发一个NoSuchElementException异常 |
void remove() |
从列表中删除当前元素 |
void set(Object obj) |
将obj赋给当前元素。即上一次调用next()方法或previousfangfa后返回的元素 |
6.3 Map接口
Map没有继承Collection接口，映射（map）是一个存储关键字和值的关联，或者说是“关键字/值”对的对象，即给定一个关键字，可以得到它的值。关键字和值都是对象，关键字必须是唯一的，但值是可以被复制的。
映射接口定义了映射的特性和本质。支持映射的三大接口：
Map接口映射唯一关键字到值。关键字是以后用于检索值的对象。给定一个关键字和一个值，可以存储这个值到一个Map对象中。当这个值被存储以后，就可以使用它的关键字来检索它。Map.Entry接口使得可以操作映射的输入。而SortMap接口扩展了Map，它确保了各项关键字按升序排列。
Java转实现映射接口的类：
类名 |
类的描述 |
AbstractMap |
实现大多数的Map接口 |
HashMap |
将AbstractMap扩展到使用散列表 |
TreeMap |
将AbstractMap扩展到使用树 |
6.3.1 HashMap集合类
HashMap类使用散列表实现Map接口。HashMap是非同步的，并且允许null，即null value和null key。但是将HashMap视为Collection时（values（）方法可返回Collection），其迭代子操作时间开销和HashMap的容量成比例。因此，如果迭代操作的性能相当重要的话，不要将HashMap的初始化容量设得过高，或者load factor过低。
HashMap类的构造方法：
HashMap类的主要方法：
方法 |
方法说明 |
public void clear() |
删除映射中所有映射关系 |
public boolean containsKey(Object key) |
判断HashMap中是否包指定的键的映射关系，如果包含则返回true |
public boolean containsValue(Object value) |
判断HashMap中是否包指定的键值的映射关系 |
public V get(Object key) |
返回参数key键在该映射中所映射的值 |
public boolean isEmpty() |
判断HashMap中是否包含键-值映射关系，如果不包含则返回true |
public V put(K key, V value) |
在映射中放入指定值与指定键 |
public void putAll(Map m) |
将指定映射的所有映射关系复制到此映射中 |
public int size() |
返回映射中键-值映射关系的数目 |
public V remove(Object key) |
删除映射中存在该键的映射关系 |
* HashMap实现Map并扩展AbstractMap。同HashSet一样，HashMap也不保证它的元素的顺序。
* 在向HashMap中添加元素时，不但要将元素添加，还要为每个元素设置一个Hash码。Hash码不只可以为数字，同样它也可以为字符串。
* containsValue()方法注意equals的重写
6.4 迭代器Iterator
所有集合接口和类都没有提供相应的遍历方法，而是把遍历交给迭代器Iterator完成。Iterator为集合而生，专门实现集合的遍历。他隐藏了各种实现类的内部细节，提供了遍历集合的统一编程接口。
Collection接口的iterator()方法返回一个Iterator，然后通过Iterator接口的两个方法即可方便地实现遍历。
（1） boolean hasNext( ): 判断是否存在另一个可访问的元素。
（2） Object next(): 返回要访问的下一个元素。
6.4.1 使用Iterator遍历集合类
在集合的操作中支持以下几种方式：
Iterator
ListIterator
foreach输出
Enumeration输出
Iterator接口简介
集合输出的标准操作：
在使用集合输出的时候必须要形成以下的一个思路：只要是遇到集合输出的操作，就一定使用Iterator接口，因为这是最标准的办法。
Iterator接口的输出原理：
Iterator是专门的迭代输出接口，所谓的迭代输出就是将元素一个个进行判断，判断其是否有内容，如果有内容则把内容取出。
对于Iterator而言，因为本身是一个接口，所以要想实例化则必须依靠Collection接口完成。
Iterator<E>iterator()
实例如下：
[java]view plaincopy
1. import java.util.List ;
2. import java.util.ArrayList ;
3. import java.util.Iterator ;
4. public class IteratorDemo01{
5. public static void main(String args[]){
6. List<String> all= new ArrayList<String>() ; //
7. all.add("hello") ;
8. all.add("_") ;
9. all.add("world") ;
10. Iterator<String> iter = all.iterator() ; // 为Iterator接口实例化
11. while(iter.hasNext()){ // 判断是否有内容
12. System.out.println(iter.next()) ; // 输出内容
13. }
14. }
15. };
import java.util.List ;
import java.util.ArrayList ;
import java.util.Iterator ;
public class IteratorDemo01{
public static void main(String args[]){
List<String> all= new ArrayList<String>() ; //
all.add("hello") ;
all.add("_") ;
all.add("world") ;
Iterator<String> iter = all.iterator() ; // 为Iterator接口实例化
while(iter.hasNext()){ // 判断是否有内容
System.out.println(iter.next()) ; // 输出内容
}
}
};
以上的操作代码属于Iterator的标准做法。
在Iterator接口中提供了remove()方法，此方法的功能是删除当前的对象。
[java]view plaincopy
1. import java.util.List ;
2. import java.util.ArrayList ;
3. import java.util.Iterator ;
4. public class IteratorDemo02{
5. public static void main(String args[]){
6. List<String> all= new ArrayList<String>() ; //
7. all.add("hello") ;
8. all.add("_") ;
9. all.add("world") ;
10. Iterator<String> iter = all.iterator() ; // 为Iterator接口实例化
11. while(iter.hasNext()){ // 判断是否有内容
12. String str = iter.next() ;
13. if("_".equals(str)){
14. iter.remove() ; // 删除元素
15. }else{
16. System.out.println(str) ; // 输出内容
17. }
18. }
19. System.out.println("删除之后的集合：" + all) ;
20. }
21. };
import java.util.List ;
import java.util.ArrayList ;
import java.util.Iterator ;
public class IteratorDemo02{
public static void main(String args[]){
List<String> all= new ArrayList<String>() ; //
all.add("hello") ;
all.add("_") ;
all.add("world") ;
Iterator<String> iter = all.iterator() ; // 为Iterator接口实例化
while(iter.hasNext()){ // 判断是否有内容
String str = iter.next() ;
if("_".equals(str)){
iter.remove() ; // 删除元素
}else{
System.out.println(str) ; // 输出内容
}
}
System.out.println("删除之后的集合：" + all) ;
}
};
在实际中是很少调用删除操作的，因为其本身的功能就是输出内容。当然，对于删除操作也有如下一个注意点：
List接口本身存在删除方法：remove
如果在使用迭代输出的过程中使用了List中的remove()执行删除操作，则代码将出现问题。
[java]view plaincopy
1. import java.util.List ;
2. import java.util.ArrayList ;
3. import java.util.Iterator ;
4. public class IteratorDemo03{
5. public static void main(String args[]){
6. List<String> all= new ArrayList<String>() ; //
7. all.add("hello") ;
8. all.add("_") ;
9. all.add("world") ;
10. Iterator<String> iter = all.iterator() ; // 为Iterator接口实例化
11. while(iter.hasNext()){ // 判断是否有内容
12. String str = iter.next() ;
13. if("_".equals(str)){
14. all.remove(str) ; // 删除元素
15. }else{
16. System.out.println(str) ; // 输出内容
17. }
18. }
19. System.out.println("删除之后的集合：" + all) ;
20. }
21. };
import java.util.List ;
import java.util.ArrayList ;
import java.util.Iterator ;
public class IteratorDemo03{
public static void main(String args[]){
List<String> all= new ArrayList<String>() ; //
all.add("hello") ;
all.add("_") ;
all.add("world") ;
Iterator<String> iter = all.iterator() ; // 为Iterator接口实例化
while(iter.hasNext()){ // 判断是否有内容
String str = iter.next() ;
if("_".equals(str)){
all.remove(str) ; // 删除元素
}else{
System.out.println(str) ; // 输出内容
}
}
System.out.println("删除之后的集合：" + all) ;
}
};
在使用Itarator删除时，不要使用集合类中的remove()方法，而只能使用Iterator接口中的remove()方法。
ListIterator接口
Iterator接口的主要功能是由前向后单向输出，而此时如果想实现由后向前或者是由前向后的双向输出，则就必须使用Iterator的子接口ListIterator。
ListIterator接口的定义如下：
publicinterface ListIterator<E> extends Iterator<E>
虽然此接口可以进行双向输出，但是很遗憾的是Collection接口中并没有定义可以为此类实例化的操作，只有List接口中才存在了ListIterator接口的实例化操作。
实例如下：完成双向输出。
[java]view plaincopy
1. import java.util.ArrayList ;
2. import java.util.List ;
3. import java.util.ListIterator ;
4. public class ListIteratorDemo01{
5. public static void main(String argsp[]){
6. List<String> all = new ArrayList<String>() ;
7. all.add("hello") ;
8. all.add("_") ;
9. all.add("world") ;
10. ListIterator<String> iter = all.listIterator() ;
11. System.out.print("由前向后输出：") ;
12. while(iter.hasNext()){
13. String str = iter.next() ;
14. System.out.print(str + "、") ;
15. }
16. System.out.print("\n由后向前输出：") ;
17. while(iter.hasPrevious()){
18. String str = iter.previous() ;
19. System.out.print(str + "、") ;
20. }
21. }
22. };
import java.util.ArrayList ;
import java.util.List ;
import java.util.ListIterator ;
public class ListIteratorDemo01{
public static void main(String argsp[]){
List<String> all = new ArrayList<String>() ;
all.add("hello") ;
all.add("_") ;
all.add("world") ;
ListIterator<String> iter = all.listIterator() ;
System.out.print("由前向后输出：") ;
while(iter.hasNext()){
String str = iter.next() ;
System.out.print(str + "、") ;
}
System.out.print("\n由后向前输出：") ;
while(iter.hasPrevious()){
String str = iter.previous() ;
System.out.print(str + "、") ;
}
}
};
此时已经完成了双向输出操作。
但是，在使用此操作的时候一定要注意一点：一定要先进行由前向后输出，之后才能进行由后向前的输出。
使用ListIterator还可以进行增加以及替换元素。
add()
set()
[java]view plaincopy
1. import java.util.ArrayList ;
2. import java.util.List ;
3. import java.util.ListIterator ;
4. public class ListIteratorDemo02{
5. public static void main(String argsp[]){
6. List<String> all = new ArrayList<String>() ;
7. all.add("hello") ;
8. all.add("_") ;
9. all.add("world") ;
10. ListIterator<String> iter = all.listIterator() ;
11. System.out.print("由前向后输出：") ;
12. while(iter.hasNext()){
13. String str = iter.next() ;
14. System.out.print(str + "、") ;
15. iter.set("LIU - " + str) ; // 修改内容
16. }
17. System.out.print("\n由后向前输出：") ;
18. iter.add("LX");
19. while(iter.hasPrevious()){
20. String str = iter.previous() ;
21. System.out.print(str + "、") ;
22. }
23. }
24. };
import java.util.ArrayList ;
import java.util.List ;
import java.util.ListIterator ;
public class ListIteratorDemo02{
public static void main(String argsp[]){
List<String> all = new ArrayList<String>() ;
all.add("hello") ;
all.add("_") ;
all.add("world") ;
ListIterator<String> iter = all.listIterator() ;
System.out.print("由前向后输出：") ;
while(iter.hasNext()){
String str = iter.next() ;
System.out.print(str + "、") ;
iter.set("LIU - " + str) ; // 修改内容
}
System.out.print("\n由后向前输出：") ;
iter.add("LX");
while(iter.hasPrevious()){
String str = iter.previous() ;
System.out.print(str + "、") ;
}
}
};
总结：
1、Iterator接口的功能是从前向后输出，属于单向的输出。
2、Iterator的主要功能就是完成迭代输出操作的。
3、在使用Iterator的时候最好不要删除数据。
4、如果要想使用ListIterator则只能依靠List接口完成。
5、如果要进行由后向前的输出，则只能先进行由前到后的输出。
3、对于此接口中的增加以及修改操作，用的不是太多，了解即可。
6.5 泛型集合
使用泛型集合在创建集合对象是指定姐中元素的类型，在从集合中取出元素时无须进行类型强制转换，避免了ClassCastException异常。
Java中共有八个包装类:Bute、Short、Integer、Long、Float、Double、Boolean、Character。
6.1 集合框架的概述
6.1.1 引入集合框架
（1）数组长度固定不变，不能很好地适应元素动态变化的情况。若要存储大于50个狗狗的信息，则数组长度不足;若只存储20个狗狗的信息，则造成内存的空间浪费。
（2）课通过数组名.length获取数组的长度，却无法直接获取数组中真实的存储狗狗个数
（3）数组采用在内存中分配连续空间的存储方式，根据下标可以快速获取对应狗狗的信息，但根据狗狗信息查找效率低下，需要多次比较。在进行频繁插入，删除操作是同样效率低下。
6.1.2 Java集合框架包含的内容
Java集合框架为我们提供了一套性能优良，使用方便的接口和类，他们都位于java.util包中。Java集合框架包含的主要内容及彼此的关系如图：
集合框架是为表示和操作集合而规定的一种统一的标准体系结构。集合框架都包含三大块内容：对外接口、接口的实现和对集合运算的算法。
（1） 接口：表示框架中的抽象数据类型，在上图中虚线表示，如Collection、List、Set、Map、lterator。
（2） 实现：集合框架中接口的具体实现，在上图中实线表示，粗实线框表示最常用的实现，如ArrayList、LinkedList、HashMap、HashSet。
（3） 算法：在一个实现了某个集合操作的工具类Collection(注意不是Collection，类似于Arrays类)，他提供了对集合进行排序等多种算法实现。在使用Collection的时候可以查阅JDK帮助文档。
从上图看可以清楚地看出Java集合框架中的两大类接口：Collection和Map。其中Collection又有两个子接口：List和Set。所以通常说Java集合框架共有三大类接口：List、Set和Map。他们的共同点：都是几个几口，都可以同来存储很多对象。他们的区别如下：
（1） Collection接口存储一组不唯一(允许重复)、无序的对象。
（2） Set接口继承Collection接口，存储一组唯一(不允许重复)、无序对象
（3） List接口继承Collection接口，存储一组不唯一(允许重复)、有序(以元素插入的次序来放置元素，不会重新排列)的对象。
（4） Map接口存储一组成对的键-值对象，提供Key(键)到value(值)的映射。Map中的key不要求有序，不允许重复。Value同样不要求有序，但允许重复。
（5） Iterator接口是负责定义访问和遍历元素的接口。
在集合框架中，List可以理解为前面讲过的数组，元素的内容可以重复并且有序，Set可以理解为数学中的集合，里面数据不重复并且无序，Map也可以理解为数学中的集合，只是其中每个元素都有key和value两个对象组成。
6.2 List接口
实现List接口的常用类有ArrayList和LinkedList。他们都可以容纳所有类型的对象，包括null。允许重复，并且都保证元素的存储顺序。
ArrayList对数组进行了封装，实现了长度可变的数组，ArrayList存储数据的方式和数组相同，都是在内存中分配连续的空间，他的优点在于遍历元素和随机访问元素的效率比较高。
LinkedList采用链表存储方法。优点在于插入、删除元素是效率比较高。他提供了额外addFirst()、addLast()、removeFirst()和removeLast()等方法，可以在LinkedList的首部或尾部进行插入或删除操作。这些方法使得LinkedList可被用作堆载(stack)过着队列(queue)。
6.2.1 ArrayList集合类
元素个数不确定，要求获得存储元素的实际个数，按照存储顺你能虚获取并输出元素信息，可以通过List接口的实现类ArrayList实现该需求。
List接口中定义的各种常用方法
方法 |
方法作用 |
boolean add(Object obj) |
将指定对象obj新增至集合内，增加成功传回true，否则传回false |
boolean addAll(Collection c) |
将指定集合c内所有元素新增至集合内，增加成功传回true，否则传回false |
viod clear() |
将集合内所有元素清空 |
boolean isEmpty() |
检查集合内是否没有任何元素，如果是传回true，否则传回false |
Iterator iterator() |
将集合内的元素信息转存成Iterator对象 |
boolean remove(Object obj) |
将指定元素obj从集合内移除，成功移除传回true，否则传回false |
int size() |
将集合内的元素总数传回 |
Object[] toArray() |
将集合内的元素转存到数组后传回该数组 |
6.2.3 LinkedList集合类
LinkedList的一些特殊方法
方法 |
方法说明 |
void add(Object obj) |
将Obj插入列表中的一个元素前，该元素在下一次调用next()方法时被返回 |
boolean hasNext() |
如果存在下一个元素，则返回true，否则返回false |
boolean hasPrevious() |
如果存在前一个元素，则返回true，否则返回false |
Object next() |
返回下一个元素，如不存在，引发一个NoSuchElementException异常 |
int nextIndex() |
返回下一个元素的下表，如果不存在下一个元素，则返回列表的大小 |
Object previous() |
返回前一个元素，如不存在，引发一个NoSuchElementException异常 |
void remove() |
从列表中删除当前元素 |
void set(Object obj) |
将obj赋给当前元素。即上一次调用next()方法或previousfangfa后返回的元素 |
6.3 Map接口
Map没有继承Collection接口，映射（map）是一个存储关键字和值的关联，或者说是“关键字/值”对的对象，即给定一个关键字，可以得到它的值。关键字和值都是对象，关键字必须是唯一的，但值是可以被复制的。
映射接口定义了映射的特性和本质。支持映射的三大接口：
Map接口映射唯一关键字到值。关键字是以后用于检索值的对象。给定一个关键字和一个值，可以存储这个值到一个Map对象中。当这个值被存储以后，就可以使用它的关键字来检索它。Map.Entry接口使得可以操作映射的输入。而SortMap接口扩展了Map，它确保了各项关键字按升序排列。
Java转实现映射接口的类：
类名 |
类的描述 |
AbstractMap |
实现大多数的Map接口 |
HashMap |
将AbstractMap扩展到使用散列表 |
TreeMap |
将AbstractMap扩展到使用树 |
6.3.1 HashMap集合类
HashMap类使用散列表实现Map接口。HashMap是非同步的，并且允许null，即null value和null key。但是将HashMap视为Collection时（values（）方法可返回Collection），其迭代子操作时间开销和HashMap的容量成比例。因此，如果迭代操作的性能相当重要的话，不要将HashMap的初始化容量设得过高，或者load factor过低。
HashMap类的构造方法：
HashMap类的主要方法：
方法 |
方法说明 |
public void clear() |
删除映射中所有映射关系 |
public boolean containsKey(Object key) |
判断HashMap中是否包指定的键的映射关系，如果包含则返回true |
public boolean containsValue(Object value) |
判断HashMap中是否包指定的键值的映射关系 |
public V get(Object key) |
返回参数key键在该映射中所映射的值 |
public boolean isEmpty() |
判断HashMap中是否包含键-值映射关系，如果不包含则返回true |
public V put(K key, V value) |
在映射中放入指定值与指定键 |
public void putAll(Map m) |
将指定映射的所有映射关系复制到此映射中 |
public int size() |
返回映射中键-值映射关系的数目 |
public V remove(Object key) |
删除映射中存在该键的映射关系 |
* HashMap实现Map并扩展AbstractMap。同HashSet一样，HashMap也不保证它的元素的顺序。
* 在向HashMap中添加元素时，不但要将元素添加，还要为每个元素设置一个Hash码。Hash码不只可以为数字，同样它也可以为字符串。
* containsValue()方法注意equals的重写
6.4 迭代器Iterator
所有集合接口和类都没有提供相应的遍历方法，而是把遍历交给迭代器Iterator完成。Iterator为集合而生，专门实现集合的遍历。他隐藏了各种实现类的内部细节，提供了遍历集合的统一编程接口。
Collection接口的iterator()方法返回一个Iterator，然后通过Iterator接口的两个方法即可方便地实现遍历。
（1） boolean hasNext( ): 判断是否存在另一个可访问的元素。
（2） Object next(): 返回要访问的下一个元素。
6.4.1 使用Iterator遍历集合类
在集合的操作中支持以下几种方式：
Iterator
ListIterator
foreach输出
Enumeration输出
Iterator接口简介
集合输出的标准操作：
在使用集合输出的时候必须要形成以下的一个思路：只要是遇到集合输出的操作，就一定使用Iterator接口，因为这是最标准的办法。
Iterator接口的输出原理：
Iterator是专门的迭代输出接口，所谓的迭代输出就是将元素一个个进行判断，判断其是否有内容，如果有内容则把内容取出。
对于Iterator而言，因为本身是一个接口，所以要想实例化则必须依靠Collection接口完成。
Iterator<E>iterator()
实例如下：
[java]view plaincopy
1. import java.util.List ;
2. import java.util.ArrayList ;
3. import java.util.Iterator ;
4. public class IteratorDemo01{
5. public static void main(String args[]){
6. List<String> all= new ArrayList<String>() ; //
7. all.add("hello") ;
8. all.add("_") ;
9. all.add("world") ;
10. Iterator<String> iter = all.iterator() ; // 为Iterator接口实例化
11. while(iter.hasNext()){ // 判断是否有内容
12. System.out.println(iter.next()) ; // 输出内容
13. }
14. }
15. };
import java.util.List ;
import java.util.ArrayList ;
import java.util.Iterator ;
public class IteratorDemo01{
public static void main(String args[]){
List<String> all= new ArrayList<String>() ; //
all.add("hello") ;
all.add("_") ;
all.add("world") ;
Iterator<String> iter = all.iterator() ; // 为Iterator接口实例化
while(iter.hasNext()){ // 判断是否有内容
System.out.println(iter.next()) ; // 输出内容
}
}
};
以上的操作代码属于Iterator的标准做法。
在Iterator接口中提供了remove()方法，此方法的功能是删除当前的对象。
[java]view plaincopy
1. import java.util.List ;
2. import java.util.ArrayList ;
3. import java.util.Iterator ;
4. public class IteratorDemo02{
5. public static void main(String args[]){
6. List<String> all= new ArrayList<String>() ; //
7. all.add("hello") ;
8. all.add("_") ;
9. all.add("world") ;
10. Iterator<String> iter = all.iterator() ; // 为Iterator接口实例化
11. while(iter.hasNext()){ // 判断是否有内容
12. String str = iter.next() ;
13. if("_".equals(str)){
14. iter.remove() ; // 删除元素
15. }else{
16. System.out.println(str) ; // 输出内容
17. }
18. }
19. System.out.println("删除之后的集合：" + all) ;
20. }
21. };
import java.util.List ;
import java.util.ArrayList ;
import java.util.Iterator ;
public class IteratorDemo02{
public static void main(String args[]){
List<String> all= new ArrayList<String>() ; //
all.add("hello") ;
all.add("_") ;
all.add("world") ;
Iterator<String> iter = all.iterator() ; // 为Iterator接口实例化
while(iter.hasNext()){ // 判断是否有内容
String str = iter.next() ;
if("_".equals(str)){
iter.remove() ; // 删除元素
}else{
System.out.println(str) ; // 输出内容
}
}
System.out.println("删除之后的集合：" + all) ;
}
};
在实际中是很少调用删除操作的，因为其本身的功能就是输出内容。当然，对于删除操作也有如下一个注意点：
List接口本身存在删除方法：remove
如果在使用迭代输出的过程中使用了List中的remove()执行删除操作，则代码将出现问题。
[java]view plaincopy
1. import java.util.List ;
2. import java.util.ArrayList ;
3. import java.util.Iterator ;
4. public class IteratorDemo03{
5. public static void main(String args[]){
6. List<String> all= new ArrayList<String>() ; //
7. all.add("hello") ;
8. all.add("_") ;
9. all.add("world") ;
10. Iterator<String> iter = all.iterator() ; // 为Iterator接口实例化
11. while(iter.hasNext()){ // 判断是否有内容
12. String str = iter.next() ;
13. if("_".equals(str)){
14. all.remove(str) ; // 删除元素
15. }else{
16. System.out.println(str) ; // 输出内容
17. }
18. }
19. System.out.println("删除之后的集合：" + all) ;
20. }
21. };
import java.util.List ;
import java.util.ArrayList ;
import java.util.Iterator ;
public class IteratorDemo03{
public static void main(String args[]){
List<String> all= new ArrayList<String>() ; //
all.add("hello") ;
all.add("_") ;
all.add("world") ;
Iterator<String> iter = all.iterator() ; // 为Iterator接口实例化
while(iter.hasNext()){ // 判断是否有内容
String str = iter.next() ;
if("_".equals(str)){
all.remove(str) ; // 删除元素
}else{
System.out.println(str) ; // 输出内容
}
}
System.out.println("删除之后的集合：" + all) ;
}
};
在使用Itarator删除时，不要使用集合类中的remove()方法，而只能使用Iterator接口中的remove()方法。
ListIterator接口
Iterator接口的主要功能是由前向后单向输出，而此时如果想实现由后向前或者是由前向后的双向输出，则就必须使用Iterator的子接口ListIterator。
ListIterator接口的定义如下：
publicinterface ListIterator<E> extends Iterator<E>
虽然此接口可以进行双向输出，但是很遗憾的是Collection接口中并没有定义可以为此类实例化的操作，只有List接口中才存在了ListIterator接口的实例化操作。
实例如下：完成双向输出。
[java]view plaincopy
1. import java.util.ArrayList ;
2. import java.util.List ;
3. import java.util.ListIterator ;
4. public class ListIteratorDemo01{
5. public static void main(String argsp[]){
6. List<String> all = new ArrayList<String>() ;
7. all.add("hello") ;
8. all.add("_") ;
9. all.add("world") ;
10. ListIterator<String> iter = all.listIterator() ;
11. System.out.print("由前向后输出：") ;
12. while(iter.hasNext()){
13. String str = iter.next() ;
14. System.out.print(str + "、") ;
15. }
16. System.out.print("\n由后向前输出：") ;
17. while(iter.hasPrevious()){
18. String str = iter.previous() ;
19. System.out.print(str + "、") ;
20. }
21. }
22. };
import java.util.ArrayList ;
import java.util.List ;
import java.util.ListIterator ;
public class ListIteratorDemo01{
public static void main(String argsp[]){
List<String> all = new ArrayList<String>() ;
all.add("hello") ;
all.add("_") ;
all.add("world") ;
ListIterator<String> iter = all.listIterator() ;
System.out.print("由前向后输出：") ;
while(iter.hasNext()){
String str = iter.next() ;
System.out.print(str + "、") ;
}
System.out.print("\n由后向前输出：") ;
while(iter.hasPrevious()){
String str = iter.previous() ;
System.out.print(str + "、") ;
}
}
};
此时已经完成了双向输出操作。
但是，在使用此操作的时候一定要注意一点：一定要先进行由前向后输出，之后才能进行由后向前的输出。
使用ListIterator还可以进行增加以及替换元素。
add()
set()
[java]view plaincopy
1. import java.util.ArrayList ;
2. import java.util.List ;
3. import java.util.ListIterator ;
4. public class ListIteratorDemo02{
5. public static void main(String argsp[]){
6. List<String> all = new ArrayList<String>() ;
7. all.add("hello") ;
8. all.add("_") ;
9. all.add("world") ;
10. ListIterator<String> iter = all.listIterator() ;
11. System.out.print("由前向后输出：") ;
12. while(iter.hasNext()){
13. String str = iter.next() ;
14. System.out.print(str + "、") ;
15. iter.set("LIU - " + str) ; // 修改内容
16. }
17. System.out.print("\n由后向前输出：") ;
18. iter.add("LX");
19. while(iter.hasPrevious()){
20. String str = iter.previous() ;
21. System.out.print(str + "、") ;
22. }
23. }
24. };
import java.util.ArrayList ;
import java.util.List ;
import java.util.ListIterator ;
public class ListIteratorDemo02{
public static void main(String argsp[]){
List<String> all = new ArrayList<String>() ;
all.add("hello") ;
all.add("_") ;
all.add("world") ;
ListIterator<String> iter = all.listIterator() ;
System.out.print("由前向后输出：") ;
while(iter.hasNext()){
String str = iter.next() ;
System.out.print(str + "、") ;
iter.set("LIU - " + str) ; // 修改内容
}
System.out.print("\n由后向前输出：") ;
iter.add("LX");
while(iter.hasPrevious()){
String str = iter.previous() ;
System.out.print(str + "、") ;
}
}
};
总结：
1、Iterator接口的功能是从前向后输出，属于单向的输出。
2、Iterator的主要功能就是完成迭代输出操作的。
3、在使用Iterator的时候最好不要删除数据。
4、如果要想使用ListIterator则只能依靠List接口完成。
5、如果要进行由后向前的输出，则只能先进行由前到后的输出。
3、对于此接口中的增加以及修改操作，用的不是太多，了解即可。
6.5 泛型集合
使用泛型集合在创建集合对象是指定姐中元素的类型，在从集合中取出元素时无须进行类型强制转换，避免了ClassCastException异常。
Java中共有八个包装类:Bute、Short、Integer、Long、Float、Double、Boolean、Character。_