JAVA 类集

类集的概念是从JDK 1.2 之后正式完善的一套开发架构，其基本的作用就是完成了一个动态的对象数组，里面的数据元素可以动态的增加

类集提供了以下的几种接口：

单值操作接口：Collection、List、Set

 List 和 Set 是Collection  接口的子接口

一对值的操作接口：Map

排序的操作接口：SortedMap、SortedSet

输出的接口：Iterator、ListIterator、Enumetation

队列：Queue

 

所有的类集都保存在Java.util包中，此包是一个最重要的工具包

 

Collection 接口

 

Collection 接口是一个最重要的操作接口，其中规定了一个集合的基本操作方法，此接口下有两个子接口，这两个子接口又分别有首各自的特点，在使用上完全不一样

 

Collection 接口定义：

[java] view plain copy
 
 print?
  1. public interface Collection<E>  
  2.   
  3. extends Iterable<E>  



在JDK1.5之后，Collection接口使用了泛型技术，那么这样做的目的可以保证接口中的操作的内容更加安全，因为最早来讲为了保证 Collection接口中可以增加任意的对象内容，所以使用了Object 进行接收，但是因为其可以接收任意的内容，所以在使用中就有可能在一个集合中插入不同的对象，在取出的时候就有可能出现类转换异常，所以在实际的类集操作中一定要指明其具体的操作泛型类型。

 

Coolection 接口中定义了如下的方法

 

No. 方法 类型 描述
1 public boolean add(E a) 普通 向集合中增加元素
2 public bollean addAll(Collection<? extends E>c) 普通 向集合中加入一组数据，泛型指定了操作上限
3 public void clear() 普通 清空所有的内容
4 public boolean contains(Object 0) 普通 判断是否有指定的内容，查找
5 public boolean containsAll(Collection<?>c) 普通 查找一组数据是否存在
6 public boolean equals(Object o) 普通 对象比较
7 public in hashCode() 普通 返回hash 码
8 public bollean is Empty() 普通 判断集合的内容是否为空
9 public Iterator<E> interator() 普通 为iterator 实例化，迭代输出
10 public boolean remove(Object o) 普通 从集合中删除指定的对象
11 public boolean removeAll(Collection<?> c) 普通 从集合中删除一组对象
12 public boolean retainAll(Collection<?> c) 普通 从集合中保留指定的对象
13 public int size() 普通 取得集合的长度
14 public Object[] toArray() 普通 取得全部的内容，以数据集合的形式返回
15 public <T> T[] toArray(T[] a) 普通 取得全部的内容

 

 

从现化的开发中来看，在集合操作中已经很少去使用Collection 完成功能了，基本上都使用了其子接口：List、Set

 

List 接口

 

List 接口最大的特点是里面的内容都允许重复。但是，此接口比Collection 接口扩充了很多的方法

以下的方法是新增加的操作：

 

No. 方法 类型 描述
1 public void add(int index,E element) 普通 在指定的位置入加入元素
2 public bollean add All(int index x,Collection<? extends E> c) 普通 在指定位置增加一组元素
3 public E get(int index) 普通 通下索引位置可以取出每一个元素
4 public ListIterator<E> listIterator() 普通 为ListIterator 接口实例化
5 public E remove(int index) 普通 删除指定位置内容
6 public E set(int index ,E element) 普通 修改指定位置内容
7 public List<E> subList(int fromIndex,int toIndex) 普通 截取子集合

 

 

如果要想使用List 接口，则要通过其子类，常用的子类有如下几个：ArrayList、Vector、LinkedList

 

 

新的子类：ArrayList

 

ArrayList 是List 接口最常用的一个子类其定义如下：

[java] view plain copy
 
 print?
  1. public class ArrayList<E>  
  2.   
  3. extends AbstractList<E>  
  4.   
  5. implements List<E>,RandomAccess,Cloneable,Serializable  



 

使用ArrayList 的对象可以直接为List 接口实例化

 

完成增加数据的操作

 

 

[java] view plain copy
 
 print?
  1. package org.collectiondemo.listdemo;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.List;  
  5.   
  6. public class ArrayListAddDemo {  
  7.   
  8.     /** 
  9.      * @param args 
  10.      */  
  11.     public static void main(String[] args) {  
  12.         // TODO Auto-generated method stub  
  13.         List<String> alllist = new ArrayList<String>(); //为List 接口实例化  
  14.         alllist.add("Hello");  //增加元素，Collection接口定义  
  15.         alllist.add("MSDL");   //增加元素，Collection接口定义  
  16.         alllist.add(0,"World"); //增加元素，List接口定义  
  17.         alllist.add(0,"Temp");  //增加元素，List接口定义  
  18.         System.out.println(alllist);  
  19.     }  
  20.   
  21. }  

 

通过代码运行可以发现此程序是没有数组长度限制的

 

完成删除数据的操作

 

 

[java] view plain copy
 
 print?
  1. package org.collectiondemo.listdemo;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.List;  
  5.   
  6. public class ArrayListDeleteDemo {  
  7.   
  8.     /** 
  9.      * @param args 
  10.      */  
  11.     public static void main(String[] args) {  
  12.         // TODO Auto-generated method stub  
  13.         List<String> alllist = new ArrayList<String>();  
  14.         alllist.add("Hello");  //增加元素，Collection接口定义  
  15.         alllist.add("MSDL");   //增加元素，Collection接口定义  
  16.         alllist.add(0,"World"); //增加元素，List接口定义  
  17.         alllist.add(0,"Temp");  //增加元素，List接口定义  
  18.         alllist.remove("World"); //删除第一个位置的元素，List接口宝义  
  19.         alllist.remove(0);//删除第一个位置的元素，List 接口定义  
  20.         System.out.println(alllist);  
  21.     }  
  22.   
  23. }  



 

 

完成输出数据的操作

在List 接口中提供了一个get(int index) 方法，此方法可以根据索引位置取出数据

 

 

[java] view plain copy
 
 print?
  1. package org.collectiondemo.listdemo;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.List;  
  5.   
  6. public class ArrayListPrintDemo {  
  7.   
  8.     /** 
  9.      * @param args 
  10.      */  
  11.     public static void main(String[] args) {  
  12.         // TODO Auto-generated method stub  
  13.         List<String> alllist = new ArrayList<String>();  
  14.         alllist.add("Hello");  //增加元素，Collection接口定义  
  15.         alllist.add("MSDL");   //增加元素，Collection接口定义  
  16.         alllist.add(0,"World"); //增加元素，List接口定义  
  17.         alllist.add(0,"Temp");  //增加元素，List接口定义  
  18.         for (int i=0;i<alllist.size();i++){  // 循环输出  
  19.             System.out.println(alllist.get(i)); //输出内容  
  20.         }  
  21.     }  
  22.   
  23. }  



 

在Collection 接口中实际 上也规定了两个可以将集合变为对象数组的操作

 

[java] view plain copy
 
 print?
  1. package org.collectiondemo.listdemo;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.Collection;  
  5.   
  6. public class ArrayListPrintDemo01 {  
  7.   
  8.     /** 
  9.      * @param args 
  10.      */  
  11.     public static void main(String[] args) {  
  12.         // TODO Auto-generated method stub  
  13.         Collection <String> alllist = new ArrayList<String>();  
  14.         alllist.add("Hello");  //增加元素，Collection接口定义  
  15.         alllist.add("MSDL");   //增加元素，Collection接口定义  
  16.         Object obj[] = alllist.toArray();  
  17.         for (int i=0;i<obj.length;i++){  // 循环输出  
  18.             System.out.println(obj[i]); //输出内容  
  19.         }  
  20.     }  
  21.   
  22. }  

 

 

 

[java] view plain copy
 
 print?
  1. package org.collectiondemo.listdemo;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.Collection;  
  5.   
  6. public class ArrayListPrintDemo02 {  
  7.   
  8.     /** 
  9.      * @param args 
  10.      */  
  11.     public static void main(String[] args) {  
  12.         // TODO Auto-generated method stub  
  13.         Collection <String> alllist = new ArrayList<String>();  
  14.         alllist.add("Hello");  //增加元素，Collection接口定义  
  15.         alllist.add("MSDL");   //增加元素，Collection接口定义  
  16.         String obj[] = alllist.toArray(new String[]{});  
  17.         for (int i=0;i<obj.length;i++){  // 循环输出  
  18.             String str = obj[i];  
  19.             System.out.println(str); //输出内容  
  20.         }  
  21.     }  
  22.   
  23. }  

 

 

集合的其他操作方法

判断元素是否存在

List 接口中定义的subList()方法

 

 

[java] view plain copy
 
 print?
  1. package org.collectiondemo.listdemo;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.List;  
  5.   
  6. public class ArrayListOtherDemo {  
  7.   
  8.     /** 
  9.      * @param args 
  10.      */  
  11.     public static void main(String[] args) {  
  12.         // TODO Auto-generated method stub  
  13.         List<String> alllist = new ArrayList<String>(); //为List 接口实例化  
  14.         alllist.add("Hello");  //增加元素，Collection接口定义  
  15.         alllist.add("MSDL");   //增加元素，Collection接口定义  
  16.         alllist.add(0,"World"); //增加元素，List接口定义  
  17.         alllist.add(0,"Temp");  //增加元素，List接口定义  
  18.         System.out.println(alllist.contains("World"));  
  19.         System.out.println(alllist.subList(2, 3));  
  20.     }  
  21.   
  22. }  

 

 

 

旧的子类：Vector

 

Vector 类是一个元老级的操作类，在JDK1.0推出的时候就有了，ArrayList 类是在JDK1.2之后才定义的新操作类，但是因为考虑到一部份人已经习惯于使用Vector类，所以，Java的开发者在定义类集的时候又让Vector类多实现了一个List接口，所以此类可以直接为List接口实例化

 

 

[java] view plain copy
 
 print?
  1. package org.collectiondemo.listdemo;  
  2.   
  3.   
  4. import java.util.List;  
  5. import java.util.Vector;  
  6.   
  7. public class VectorAddDemo {  
  8.   
  9.     /** 
  10.      * @param args 
  11.      */  
  12.     public static void main(String[] args) {  
  13.         // TODO Auto-generated method stub  
  14.         List<String> alllist = new Vector<String>(); //为List 接口实例化  
  15.         alllist.add("Hello");  //增加元素，Collection接口定义  
  16.         alllist.add("MSDL");   //增加元素，Collection接口定义  
  17.         alllist.add(0,"World"); //增加元素，List接口定义  
  18.         alllist.add(0,"Temp");  //增加元素，List接口定义  
  19.         System.out.println(alllist);  
  20.     }  
  21.   
  22. }  

 

 

当然，需要说明的是，在Vector类因为是一个比较老的类，所以里面也定义了自己的增加数据的操作，例如：public void addElement(E obj)，那么现在此就去的操作跟List中是完全一样的。

 

ArrayList 与 Vector 的区别

 

ArrayList 类和Vector类都是List 接口的子类

 

 

No 区别点 ArrayList Vector
1 推出时间 是在JDK1.2之后推出的，属于新的类 是在JDK1.0时推出的，属于旧的操作类
2 操作 ArrayList 采用异步的处理操作 Vecotr采用同步的处理操作
3 性能 ArrayList 性能高 Vector 性能相对较低
4 安全 非线程安全的操作 线程安全
5 输出 Iterator、ListIterator、foreach Iterator、ListIterator、foreach、Enumeration

 

 

LinkedList 和 Queue 接口

 

LinedList 完成的是一个链表的操作，可以方便的找到表头之类的基本操作。

此类定义如下：

 

[java] view plain copy
 
 print?
  1. public class LinkedList<E>  
  2.   
  3. extends AbstractSequentialList<E>  
  4.   
  5. implements List<E>,Deque<E>,Cloneable,Serializable  



此类提供的方法就是链表操作方法

 

 

[java] view plain copy
 
 print?
  1. package org.collectiondemo.listdemo;  
  2.   
  3. import java.util.LinkedList;  
  4.   
  5. public class LinkedDemo01 {  
  6.   
  7.     /** 
  8.      * @param args 
  9.      */  
  10.     public static void main(String[] args) {  
  11.         // TODO Auto-generated method stub  
  12.         LinkedList<String> link = new LinkedList<String>();  
  13.         link.add("A");  
  14.         link.add("B");  
  15.         link.add("C");  
  16.         link.addFirst("X");  
  17.         link.addLast("Y");  
  18.           
  19.         System.out.println(link);  
  20.           
  21.         for (int i = 0;i<link.size();i++){  
  22.             System.out.println(link.get(i));  
  23.         }  
  24.     }  
  25.   
  26. }  

 

 

取出表头的操作

 

 

[java] view plain copy
 
 print?
  1. package org.collectiondemo.listdemo;  
  2.   
  3. import java.util.LinkedList;  
  4.   
  5. public class LinkedListDemo02 {  
  6.   
  7.     /** 
  8.      * @param args 
  9.      */  
  10.     public static void main(String[] args) {  
  11.         // TODO Auto-generated method stub  
  12.         LinkedList<String> link = new LinkedList<String>();  
  13.         link.add("A");  
  14.         link.add("B");  
  15.         link.add("C");  
  16.         link.addFirst("X");  
  17.         link.addLast("Y");  
  18.           
  19.         System.out.println(link);  
  20.           
  21.         for (int i = 0;i<link.size();i++){  
  22.             System.out.print(link.element()); //取出表头  
  23.         }  
  24.           
  25.         System.out.println(link);  
  26.           
  27.           
  28.         for (int i = 0;i<link.size();i++){  
  29.             System.out.print(link.poll()); //取出表头，同时删除表头  
  30.         }         
  31.           
  32.         System.out.println(link);         
  33.     }  
  34.   
  35. }  

 



Set 接口

 

Set 接口也是Collection的子接口，最大的特点是里面没有任何的重复元素，在Set 接口中有以下的两个子类是最常用的子类

TreeSet ：有序存放

HashSet： 散列存放

Set 接口本身并没有对Collection接口做任何的扩充，是安全一样

 

HashSet 散列存放

 

 

[java] view plain copy
 
 print?
  1. package org.collectiondemo.listdemo;  
  2.   
  3. import java.util.HashSet;  
  4. import java.util.Set;  
  5.   
  6. public class HashSetAddDemo {  
  7.   
  8.     /** 
  9.      * @param args 
  10.      */  
  11.     public static void main(String[] args) {  
  12.         // TODO Auto-generated method stub  
  13.         Set<String> allSet = new HashSet<String>();  
  14.         allSet.add("A"); //增加重复元素  
  15.         allSet.add("A"); //增加重复元素  
  16.         allSet.add("B"); //增加  
  17.         allSet.add("C"); //增加  
  18.         allSet.add("D"); //增加重复元素  
  19.         allSet.add("D"); //增加重复元素  
  20.         System.out.println(allSet);  
  21.     }  
  22.   
  23. }  

 

 

 

TreeSet  有序存放

 

TreeSet 是可以进行排序的操作接口

 

 

[java] view plain copy
 
 print?
  1. package org.collectiondemo.listdemo;  
  2.   
  3. import java.util.TreeSet;  
  4. import java.util.Set;  
  5.   
  6. public class HashSetAddDemo {  
  7.   
  8.     /** 
  9.      * @param args 
  10.      */  
  11.     public static void main(String[] args) {  
  12.         // TODO Auto-generated method stub  
  13.         Set<String> allSet = new TreeSet<String>();  
  14.         allSet.add("A"); //增加重复元素  
  15.         allSet.add("A"); //增加重复元素  
  16.         allSet.add("B"); //增加  
  17.         allSet.add("C"); //增加  
  18.         allSet.add("D"); //增加重复元素  
  19.         allSet.add("D"); //增加重复元素  
  20.         System.out.println(allSet);  
  21.     }  
  22.   
  23. }  

 

 

关于排序的说明

 

在之前的操作中使用的是String类的对象向集合中加入，如果现在自定义了一个类

 

 

[java] view plain copy
 
 print?
  1. package org.collectiondemo.listdemo;  
  2.   
  3. public class Person implements Comparable<Person> {  
  4.   
  5.     private String name;  
  6.     private int age;  
  7.       
  8.     public Person(String name,int age){  
  9.         this.name = name;  
  10.         this.age = age;  
  11.     }  
  12.       
  13.     public String toString(){  
  14.         return "姓名："+this.name+" 年龄："+this.age;  
  15.     }  
  16.   
  17.     public boolean equals(Object obj){  
  18.         if (this == obj){  
  19.             return true;  
  20.         }  
  21.           
  22.         if (!(obj instanceof Person)){  
  23.             return false;  
  24.         }  
  25.           
  26.         Person per = (Person)obj;  
  27.           
  28.         if (this.name.equals(per.name) && this.age == per.age){  
  29.             return true;  
  30.         }else{  
  31.             return false;  
  32.         }  
  33.     }  
  34.       
  35.     public int hashCode(){ //这个方法的返回值都是通过一个公式计算的  
  36.                 // 此时的公式：名字的hashCode * age  
  37.                 return this.name.hashCode() * this.age;  
  38.     }  
  39.   
  40.     @Override  
  41.     public int compareTo(Person per) {  
  42.         // TODO Auto-generated method stub  
  43.         if (this.age < per.age){  
  44.             return -1;  
  45.         }else if (this.age > per.age){  
  46.             return 1;  
  47.         }else{  
  48.             return this.name.compareTo(per.name); //比较name  
  49.         }  
  50.               
  51.     }  
  52. }  

 

 

 

[java] view plain copy
 
 print?
  1. package org.collectiondemo.listdemo;  
  2. import java.util.Set;  
  3. import java.util.TreeSet;  
  4.   
  5.   
  6.   
  7. public class TreeSetPersonDemo {  
  8.   
  9.     /** 
  10.      * @param args 
  11.      */  
  12.     public static void main(String[] args) {  
  13.         // TODO Auto-generated method stub  
  14.         Set<Person> setp = new TreeSet<Person>();  
  15.         setp.add(new Person("张三",20));  
  16.         setp.add(new Person("李四",20));  
  17.         setp.add(new Person("王五",20));  
  18.         setp.add(new Person("赵六",20));  
  19.         setp.add(new Person("孙七",20));  
  20.         setp.add(new Person("孙七",20));  
  21.         System.out.println(setp);  
  22.     }  
  23.   
  24. }  

 

 

关于重复元素的说明

 

如果将以上的程序替换成HashSet子类，则会发现存在了重复元素，那么现在覆写equals()方法。

而且如果要想完成对象重复元素的判断，还需要覆写Object类中的hashCode()方法

 

在程序中是通过Object 类中的hashCode()和euqals()方法来完成重复元素的验证

所以，一个完整的类必须覆写Object 类中的hashCode()和equals()方法就在这里。

 

集合输出

 

在Java 的类集中集合输出有以下四种方式：

Iterator

ListIterator

foreach

Enumeration

但是在讲解之前先给一个标准的开发模式：“只要是碰到集合的输出，使用Iterator 接口”

 

Iterator

 

Iterator 表示迭代接口。Iterator 接口中定义了如下的方法

 

 

No 方法 类型 描述
1 public boolean hasNext() 普通 将指针向下移动，判断是否还有内容
2 public E next() 普通 取出当前指针位置的内容
3 public void remove() 普通 删除当前指针位置的内容

 

 

如果要想为Iterator 接口实例化，则必须使用Collection接口的如下方法：

 

[java] view plain copy
 
 print?
  1. public Iterator<T> iterator()  

 

 

通过以下代码观察Iterator 的使用

 

 

[java] view plain copy
 
 print?
  1. package org.iteratordemo;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.List;  
  5. import java.util.ListIterator;  
  6.   
  7. public class ListIteratorDemo01 {  
  8.   
  9.     /** 
  10.      * @param args 
  11.      */  
  12.     public static void main(String[] args) {  
  13.         // TODO Auto-generated method stub  
  14.         List<String> allList = new ArrayList<String>();  
  15.         allList.add("A");  
  16.         allList.add("A");  
  17.         allList.add("B");  
  18.         allList.add("C");  
  19.         allList.add("D");  
  20.         ListIterator<String> listiter = allList.listIterator();  
  21.           
  22.         while (listiter.hasNext()){  
  23.             System.out.println(listiter.next());  
  24.         }  
  25.           
  26.         System.out.println(allList);  
  27.     }  
  28.   
  29. }  

 

 

但是在Iterator 接口中存在一个删除的方法，在使用此方法的时候一定要有注意

 

正确的删除：

 

 

[java] view plain copy
 
 print?
  1. package org.iteratordemo;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.List;  
  5. import java.util.ListIterator;  
  6.   
  7. public class ListIteratorDemo03 {  
  8.   
  9.     /** 
  10.      * @param args 
  11.      */  
  12.     public static void main(String[] args) {  
  13.         // TODO Auto-generated method stub  
  14.         List<String> allList = new ArrayList<String>();  
  15.         allList.add("A");  
  16.         allList.add("A");  
  17.         allList.add("B");  
  18.         allList.add("C");  
  19.         allList.add("D");  
  20.         ListIterator<String> listiter = allList.listIterator();  
  21.         listiter.add("E");  
  22.           
  23.           
  24.         while (listiter.hasNext()){  
  25.             String str = listiter.next(); //取出内容  
  26.             if ("D".equals(str)){  
  27.                 listiter.remove(); //删除元素，使用的是List 接口的删除  
  28.             }  
  29.             System.out.print(str+"、");  
  30.         }  
  31.           
  32.         System.out.println("");  
  33.           
  34.         while (listiter.hasPrevious()){  
  35.             System.out.print(listiter.previous()+"、");  
  36.         }  
  37.           
  38.   
  39.     }  
  40.   
  41. }  

 

 

不正确的删除操作：

 

 

[java] view plain copy
 
 print?
  1. package org.iteratordemo;  
  2.   
  3. import java.util.ArrayList;  
  4. import java.util.List;  
  5. import java.util.ListIterator;  
  6.   
  7. public class ListIteratorDemo03 {  
  8.   
  9.     /** 
  10.      * @param args 
  11.      */  
  12.     public static void main(String[] args) {  
  13.         // TODO Auto-generated method stub  
  14.         List<String> allList = new ArrayList<String>();  
  15.         allList.add("A");  
  16.         allList.add("A");  
  17.         allList.add("B");  
  18.         allList.add("C");  
  19.         allList.add("D");  
  20.         ListIterator<String> listiter = allList.listIterator();  
  21.         listiter.add("E");  
  22.           
  23.           
  24.         while (listiter.hasNext()){  
  25.             String str = listiter.next();  
  26.             if ("D".equals(str)){  
  27.                 allList.remove(str);  
  28.             }  
  29.             System.out.print(str+"、");  
  30.         }  
  31.           
  32.         System.out.println("");  
  33.           
  34.         while (listiter.hasPrevious()){  
  35.             System.out.print(listiter.previous()+"、");  
  36.         }  
  37.           
  38.   
  39.     }  
  40.   
  41. }  

 

 

因为所谓的Iterator 实际上，只是将一个集合的内容交给了Iterator 输出而已，而如果直接使用了集合中的remove()方法，删除的话，则会存坏整个集合的内容，所以输出的时候会出现问题。

而在实际的开发中是很少使用Iterator 进行删除的操作，只是判断是否有值并且将值输出

 

ListIterator

 

ListIterator 是Iterator 接口的子接口。Iterator接口的最大特点，是能从前向后迭代输出，如果现在要想执行双向的输出，则只能使用ListIterator 接口，但是此接口使用时有一个要求，即：只能输出List接口的内容，因为要依靠如下的方法 

 

 

[java] view plain copy
 
 print?
  1. public ListIterator<E> listIterator()  

 

 

此接口的操作方法如下：

 

No. 方法 类型 描述
1 public void add(E e) 普通 增加数据
2 public boolean hasNext() 普通 从Iterator 继承而来
3 public E next() 普通 从Iterator 继承而来
4 public void remove() 普通 从Iterator 继承而来
5 public bollean hasPrevious() 普通 判断是否有前一个元素
6 public E previous() 普通 取出前一个元素
7 public void set(E e) 普通 修改元素内容

 

 

 

下面就使用ListIterator 接口进行双向的输出操作

 

 

[java] view plain copy
 
 print?
    1. package org.iteratordemo;  
    2.   
    3. import java.util.ArrayList;  
    4. import java.util.List;  
    5. import java.util.ListIterator;  
    6.   
    7. public class ListIteratorDemo02 {  
    8.   
    9.     /** 
    10.      * @param args 
    11.      */  
    12.     public static void main(String[] args) {  
    13.         // TODO Auto-generated method stub  
    14.         List<String> allList = new ArrayList<String>();  
    15.         allList.add("A");  
    16.         allList.add("A");  
    17.         allList.add("B");  
    18.         allList.add("C");  
    19.         allList.add("D");  
    20.         ListIterator<String> listiter = allList.listIterator();  
    21. <pre name="code" class="java">      System.out.print("从前向后输出：");</pre>  while (listiter.hasNext()){System.out.print(listiter.next()+"、");}System.out.println("\n从后向后输出：");while (listiter.hasPrevious()){System.out.print(listiter.previous()+"、");}System.out.println(allList);}}<p></p>  
    22. <pre></pre>  
    23. <p></p>  
    24. <p><br>  
    25. </p>  
    26. <p>在使用Listerator 接口的时候还有一个特别大的特点，可以增加及修改数据</p>  
    27. <p><br>  
    28. </p>  
    29. <p></p><pre name="code" class="java">package org.iteratordemo;  
    30.   
    31. import java.util.ArrayList;  
    32. import java.util.List;  
    33. import java.util.ListIterator;  
    34.   
    35. public class ListIteratorDemo03 {  
    36.   
    37.     /** 
    38.      * @param args 
    39.      */  
    40.     public static void main(String[] args) {  
    41.         // TODO Auto-generated method stub  
    42.         List<String> allList = new ArrayList<String>();  
    43.         allList.add("A");  
    44.         allList.add("A");  
    45.         allList.add("B");  
    46.         allList.add("C");  
    47.         allList.add("D");  
    48.         ListIterator<String> listiter = allList.listIterator();  
    49.         listiter.add("E"); //增加数据  
    50.           
    51.           
    52.         while (listiter.hasNext()){  
    53.             String str = listiter.next();  
    54.   
    55.             listiter.set(str + "-- MSDL"); //修改数据  
    56.             System.out.print(str+"、");  
    57.         }  
    58.           
    59.         System.out.println("");  
    60.           
    61.         while (listiter.hasPrevious()){  
    62.             System.out.print(listiter.previous()+"、");  
    63.         }  
    64.           
    65.   
    66.     }  
    67.   
    68. }  
    69. </pre><span style="font-size:14px"><strong><br>  
    70. </strong></span><p></p>  
    71. <p><span style="font-size:14px"><strong>foreach</strong></span></p>  
    72. <p><br>  
    73. </p>  
    74. <p>在数组的输出上可以使用foreach 完成，那么对于集合也同样适用</p>  
    75. <p><br>  
    76. </p>  
    77. <p></p><pre name="code" class="java">package org.iteratordemo;  
    78.   
    79. import java.util.ArrayList;  
    80. import java.util.List;  
    81.   
    82. public class ForeachDemo {  
    83.   
    84.     /** 
    85.      * @param args 
    86.      */  
    87.     public static void main(String[] args) {  
    88.         // TODO Auto-generated method stub  
    89.         List<String> allList = new ArrayList<String>();  
    90.         allList.add("A");  
    91.         allList.add("A");  
    92.         allList.add("B");  
    93.         allList.add("C");  
    94.         allList.add("D");  
    95.         for (String str : allList){  
    96.             System.out.println(str);  
    97.         }  
    98.     }  
    99.   
    100. }</pre><br>  
    101. <p></p>  
    102. <p><span style="font-size:18px"><strong>废弃的接口：Enumeration</strong></span></p>  
    103. <p><span style="font-size:18px"><strong><br>  
    104. </strong></span></p>  
    105. <p>Enumeration 是一个古老的输出接口，支持此种输出的类只有Vector类</p>  
    106. <p>在Vector类中存在以下的方法：public Enumeration<E> elements()，通过此方法为Enumeration 接口进行实例化的操作</p>  
    107. <p>Enumeration 接口定义了如下的方法：</p>  
    108. <p>判断是否还有内容：boolean hasMoreElements()</p>  
    109. <p>取出内容：E nextElement()</p>  
    110. <p>可以发现此接口定义的方法功能与Iterator类似，而且单词比 Iterator 长很多，所以记得费劲，所以基本上不使用</p>  
    111. <p><br>  
    112. </p>  
    113. <p></p><pre name="code" class="java">package org.iteratordemo;  
    114.   
    115. import java.util.Enumeration;  
    116. import java.util.Vector;  
    117.   
    118. public class EnumerationDemo {  
    119.   
    120.     /** 
    121.      * @param args 
    122.      */  
    123.     public static void main(String[] args) {  
    124.         // TODO Auto-generated method stub  
    125.         Vector<String> allList = new Vector<String>();  
    126.         allList.add("A");  
    127.         allList.add("A");  
    128.         allList.add("B");  
    129.         allList.add("C");  
    130.         allList.add("D");  
    131.         Enumeration<String> enu = allList.elements();  
    132.         while(enu.hasMoreElements()){  
    133.             System.out.println(enu.nextElement());  
    134.         }  
    135.     }  
    136.   
    137. }</pre><p></p>  
    138. <p><br>  
    139. </p>  
    140. <p>当然，对于一些旧的操作类中现在依然支持Eumeration ，这一点在日后的<a href="http://lib.csdn.net/base/java" class="replace_word" title="Java 知识库" target="_blank" style="color:#df3434; font-weight:bold;">Java </a>Web 的开发中可以见到。所以掌握此接口也是很有必要的。<br>  
    141. <br>  
    142. </p>  
    143.      
posted @ 2016-12-09 20:50  天涯海角路  阅读(123)  评论(0)    收藏  举报