java类集整理collection map iterator listiterator list set enumeration

java类集整理collection map iterator listiterator list set enumeration

 

JAVA类集
1 、课程名称：JAVA类集 
类集的作用、Collection、Map、Iterator、ListIterator、List、Set、Enumeration、二叉树算法 
JAVA SE的最重要四块知识：面向对象、类集、JAVA IO、数据库编程 
2 、知识点 
2.1 、上次课程的主要知识点 
1 、IO操作 
 BufferedReader：一次性读取数据 
 PrintStream：打印流 
 字节流：InputStream、OutputStream 
 File类 
2 、对象序列化 
2.2 、本次预计讲解的知识点 
1 、类集的作用 
2 、单值集合：Collection、List、Set 
3 、二元偶集合：Map 
4 、输出：Iterator、ListIterator、Enumeration 
5 、类集的作用 
3 、具体内容 
3.1 、类集的作用 
类集：就是一个动态的对象数组。 
对象数组：可以保存一组对象，但是其本身有长度的限制。 
类集可以保存一组对象，但是此保存没有长度的限制。 
在JAVA中类集的操作都在java.util包中，本身也分为两种操作形式： 
1 、存放单值的类集，最大的接口是Collection，每次可以存放一个值。但是其下又分为两个子接口： 
 List接口：表示可以重复，插入的顺序即为输出顺序 
 Set接口：不能够有重复元素 
 List接口在实际中应用较为广泛 
主要操作方法： 
 添加一个对象： public   boolean  add(Object obj) 
 清空里面的所有内容： public   void  clear() ; 
 测试集合中是否包含指定元素： boolean  contains(Object o) 
 判断集合是否为空： public   boolean  isEmpty() 
 从集合中删除指定内容： public   boolean  remove(Object o) 
 取得集合中大小： public   int  size() 
 将集合变为对象数组： public  Object[] toArray() 
 将集合变为Iterator实例： public  Iterator < E >  iterator() 
对于整个Collection集合，只允许从前向后输出，没有从后向前输出的功能。 
讨论： 
 是使用Collection好，还是使用List或Set好呢？ 
2 、存放一对值的类型：Map集合 
value key 
 通过key可以找到value 
3 、Collection与Map的作用： 
 Collection主要用于数据输出上 
 Map主要用于数据查找上 
3.2 、List接口 
List为Collection的子接口，如果要想使用此接口，则必须通过其子类为其实例化，从运行效果中可以发现，在List中可以有重复的内容。 
List接口拥有比Collection接口中更多的方法，主要以下几个常用方法： 
 在指定位置上加入元素： public   void  add( int  index,Object obj) 
 返回指定位置的元素： public  Object get( int  ind) 
 返回ListIterator实例： public  ListIterator < E >  listIterator() 
3.2 . 1 、常用子类 
1 、 ArrayList：是一个新的类，是在JDK  1 .2推出之后才有的。本身属于异步处理。性能高，但是不属于线程的安全处理。只允许使用Iterator接口输出。 
2 、Vector：是一个旧的类，是在JDK  1 .0时推出的。本身属于同步处理。性能相对较低，但是属于线程安全的，因为使用了同步。可以使用Iterator或Enumeration（使用类本身）输出 
3.2 . 2 、Vector类 
Vetor也是经过发展之后不断改良，在最早就已经实现了动态数组的功能，之后之后又增加了List接口的实现，所以在整个代码之中对于Vector本身也有自己的一个特性： 
 增加元素： public   void  addElement(Object obj)，此功能与add()一样。 
 枚举输出： public  Enumeration < E >  elements() 
Vector类中还有一个堆栈的类 —— Stack，此类实现了先进后出的功能。 
Stack中主要有以下两个方法： 
 入栈： public  Object push(Object item) 
 出栈： public  Object pop() 
3.2 . 3 、使用List操作（ArrayList） 
例如：以下代码演示了ArrayList的作用 
import  java.util. *  ; 
public   class  ColDemo01 { 
public static void main(String args[]){ 
// Collection list = new ArrayList() ; 
List list = new ArrayList() ; 
list.add("A") ; 
list.add("A") ; 
list.add("A") ; 
list.add("B") ; 
list.add("C") ; 
System.out.println(list) ; 
} 
} ; 
例如：使用clear()方法清空里面的全部内容 
import  java.util. *  ; 
public   class  ColDemo02 { 
public static void main(String args[]){ 
// Collection list = new ArrayList() ; 
List list = new ArrayList() ; 
list.add("A") ; 
list.add("A") ; 
// 清空全部的内容 
list.clear() ; 
list.add("A") ; 
list.add("B") ; 
list.add("C") ; 
System.out.println(list) ; 
} 
} ; 
例如：测试contains()方法，查找指定内容 
import  java.util. *  ; 
public   class  ColDemo03 { 
public static void main(String args[]){ 
// Collection list = new ArrayList() ; 
List list = new ArrayList() ; 
list.add("A") ; 
list.add("B") ; 
list.add("C") ; 
System.out.println(list.contains("A")) ; 
System.out.println(list.contains("X")) ; 
} 
} ; 
例如：验证集合是否为空 
import  java.util. *  ; 
public   class  ColDemo04 { 
public static void main(String args[]){ 
// Collection list = new ArrayList() ; 
List list = new ArrayList() ; 
System.out.println(list.isEmpty()) ; 
list.add("A") ; 
list.add("B") ; 
list.add("C") ; 
System.out.println(list.isEmpty()) ; 
} 
} ; 
例如：以下代码演示了remove()作用 
import  java.util. *  ; 
public   class  ColDemo05 { 
public static void main(String args[]){ 
// Collection list = new ArrayList() ; 
List list = new ArrayList() ; 
list.add("A") ; 
list.add("B") ; 
list.add("C") ; 
list.remove("B") ; 
System.out.println(list) ; 
} 
} ; 
例如：将集合变为对象数组输出 
import  java.util. *  ; 
public   class  ColDemo06 { 
public static void main(String args[]){ 
// Collection list = new ArrayList() ; 
List list = new ArrayList() ; 
list.add("A") ; 
list.add("B") ; 
list.add("C") ; 
Object str[] = list.toArray() ; 
for(int i=0;i<list.size();i++){ 
String s = (String)str[i] ; 
System.out.println(s) ; 
} 
} 
} ; 
之前的所有代码在编译的时候都出现了以下的提示： 
注意： ColDemo01.java 使用了未经检查或不安全的操作。 
注意： 要了解详细信息，请使用  - Xlint:unchecked 重新编译。 
那么这样的错误提示，是因为在JDK  1 .5之后加入了泛型的操作。因为类集中本身是使用Object进行接收的，而且接收的时候牵扯到转型问题，那么如果不指定泛型的话，则里面肯定可以加入各种类型的数据，那么在转型会出现类型转换异常。如下代码所示： 
import  java.util. *  ; 
public   class  ColDemo10 { 
public static void main(String args[]){ 
// Collection list = new ArrayList() ; 
List list = new ArrayList() ; 
list.add("A") ; 
list.add(1) ; 
list.add('2') ; 
Iterator iter = list.iterator() ; 
while(iter.hasNext()){ 
String str = (String)iter.next() ; 
if("C".equals(str)){ 
// 使用了Iterator中的删除语法。 
iter.remove() ; 
} 
} 
System.out.println(list) ; 
} 
} ; 
那么此时，就可以加入泛型进行错误的回避，加入之后，集合中只能有一种类型，当然，在实际中集合中的数据也只有一种类型。 
import  java.util. *  ; 
public   class  ColDemo11 { 
public static void main(String args[]){ 
// Collection<String> list = new ArrayList<String>() ; 
List<String> list = new ArrayList<String>() ; 
list.add("A") ; 
list.add(1) ; 
list.add('2') ; 
Iterator<String> iter = list.iterator() ; 
while(iter.hasNext()){ 
String str = iter.next() ; 
System.out.println(str) ; 
} 
} 
} ; 
以上加入了泛型操作之后，在编译的时候以上代码就会出现错误提示： 
ColDemo11.java: 7 : 找不到符号 
符号： 方法 add( int ) 
位置： 接口 java.util.List < java.lang.String >  
 list.add( 1 ) ; 
  ^  
ColDemo11.java: 8 : 找不到符号 
符号： 方法 add( char ) 
位置： 接口 java.util.List < java.lang.String >  
 list.add( ' 2 ' ) ; 
  ^  
2  错误 
所以，此时，代码只能按如下样式编写： 
import  java.util. *  ; 
public   class  ColDemo11 { 
public static void main(String args[]){ 
// Collection<String> list = new ArrayList<String>() ; 
List<String> list = new ArrayList<String>() ; 
list.add("A") ; 
list.add("B") ; 
Iterator<String> iter = list.iterator() ; 
while(iter.hasNext()){ 
String str = iter.next() ; 
System.out.println(str) ; 
} 
} 
} ; 
例如：使用List进行由后向前的输出 
import  java.util. *  ; 
public   class  ColDemo12 { 
public static void main(String args[]){ 
List<String> list = new ArrayList<String>() ; 
list.add("A") ; 
list.add("B") ; 
list.add(1,"X") ; 
list.add(0,"H") ; 
list.add(2,"Y") ; 
for(int i=list.size()-1;i>=0;i--){ 
System.out.println(list.get(i)) ; 
} 
} 
} ; 
3.2 . 4 、使用List操作（Vector） 
例如：使用Vector完成以上的操作 
import  java.util. *  ; 
public   class  ColDemo14 { 
public static void main(String args[]){ 
List<String> list = new Vector<String>() ; 
list.add("A") ; 
list.add("B") ; 
list.add("C") ; 
list.add("D") ; 
list.add("E") ; 
Iterator<String> liter = list.iterator() ; 
while(liter.hasNext()){ 
System.out.print(liter.next()+"、") ; 
} 
} 
} ; 
可以发现，整个程序与之前没有任何的区别。 
3.2 . 5 、使用Stack操作 
例如：入栈和出栈 
import  java.util. *  ; 
public   class  ColDemo16 { 
public static void main(String args[]){ 
Stack<String> s = new Stack<String>() ; 
s.push("A") ; 
s.push("B") ; 
s.push("C") ; 
System.out.println(s.pop()) ; 
System.out.println(s.pop()) ; 
System.out.println(s.pop()) ; 
System.out.println(s.pop()) ; 
} 
} ; 
如果栈的内容已经空了，再继续出栈的话，则肯定出现以下的错误： 
Exception in thread  " main "  java.util.EmptyStackException 
3.3 、Set接口 
与List接口不同的是Set接口中本身不能有任何的重复元素。 
与List接口不同的是Set接口中并没有对Collection进行扩充，也就是说，Set只是比Collection接口增加了一个不能重复的功能。 
JAVA中通过类的HashCode和equals两个方法来确定是否是同一个对象。 
3.3 . 1 、常用子类（理解） 
1 、HashSet：是散列存放的，无序 
2 、TreeSet：是排序的，使用Comparable接口排序（二叉树排序），如果使用Comparable的时候里面的所有字段都要进行比较，否则如果有若干个字段相同，而其他字段没有比较的话，系统会认为是重复的内容，而去掉。 
 二叉树（Binary Tree），三种遍历方式： 
 前序遍历：根 - 左 - 右 
 中序遍历：左 - 根 - 右 
 后序遍历：左 - 右 - 根 
3.3 . 2 、使用Set操作（HashSet） 
例如：观察HashSet使用 
import  java.util. *  ; 
public   class  ColDemo17 { 
public static void main(String args[]){ 
Set<String> list = new HashSet<String>() ; 
list.add("A") ; 
list.add("A") ; 
list.add("B") ; 
list.add("C") ; 
list.add("D") ; 
list.add("E") ; 
Iterator<String> iter = list.iterator() ; 
while(iter.hasNext()){ 
System.out.println(iter.next()) ; 
} 
} 
} ; 
3.3 . 3 、使用Set操作（TreeSet） 
例如：观察TreeSet功能 
import  java.util. *  ; 
public   class  ColDemo18 { 
public static void main(String args[]){ 
Set<String> list = new TreeSet<String>() ; 
list.add("A") ; 
list.add("X") ; 
list.add("B") ; 
list.add("D") ; 
list.add("Q") ; 
list.add("Q") ; 
Iterator<String> iter = list.iterator() ; 
while(iter.hasNext()){ 
System.out.println(iter.next()) ; 
} 
} 
} ; 
那么，如果现在给定了一个类的若干对象，如果使用TreeSet存放是否可以？ 
import  java.util. *  ; 
class  Person { 
private String name ; 
private int age ; 
public Person(String name,int age){ 
this.name = name ; 
this.age = age ; 
} 
public String toString(){ 
return "姓名；" + this.name + "，年龄；" + this.age ; 
} 
} ; 
public   class  ColDemo19 { 
public static void main(String args[]){ 
Set<Person> list = new TreeSet<Person>() ; 
list.add(new Person("张三",30)) ; 
list.add(new Person("李四",31)) ; 
list.add(new Person("王五",32)) ; 
Iterator<Person> iter = list.iterator() ; 
while(iter.hasNext()){ 
System.out.println(iter.next()) ; 
} 
} 
} ; 
以上代码运行的时候出现了以下的错误： 
Exception in thread  " main "  java.lang.ClassCastException: Person 
类型转换异常，因为TreeSet本身是带排序功能的，如果现在要对一个对象进行排序，则必须指定对象的排序规则，排序规则通过比较器 —— Comparable完成。 
import  java.util. *  ; 
class  Person  implements  Comparable < Person > { 
private String name ; 
private int age ; 
public Person(String name,int age){ 
this.name = name ; 
this.age = age ; 
} 
public String toString(){ 
return "姓名；" + this.name + "，年龄；" + this.age ; 
} 
public int compareTo(Person per){ 
if(this.age>per.age){ 
return -1 ; 
}else if(this.age<per.age){ 
return 1 ; 
}else{ 
return 0 ; 
} 
} 
} ; 
public   class  ColDemo20 { 
public static void main(String args[]){ 
Set<Person> list = new TreeSet<Person>() ; 
list.add(new Person("张三",30)) ; 
list.add(new Person("李四",31)) ; 
list.add(new Person("王五",32)) ; 
Iterator<Person> iter = list.iterator() ; 
while(iter.hasNext()){ 
System.out.println(iter.next()) ; 
} 
} 
} ; 
观察TreeSet的问题： 
 题目：设计一个学生类，此类包含姓名、年龄、成绩，产生一个对象数组，要求按成绩由高到低排序、如果成绩相等，则按年龄由低到高排序。 
通过java.util.Arrays类可以排序。 public   static   void  sort(Object[] a) 
发现以上的操作可以对一个对象数组进行排序 
import  java.util. *  ; 
class  Student  implements  Comparable < Student > { 
private String name ; 
private int age ; 
private float score ; 
public Student(String name,int age,float score){ 
this.name = name ; 
this.age = age ; 
this.score = score ; 
} 
public String toString(){ 
return name + "\t\t" + age + "\t\t" + score ; 
} 
public int compareTo(Student stu){ 
if(this.score>stu.score){ 
return -1 ; 
}else if(this.score<stu.score){ 
return 1 ; 
}else{ 
if(this.age>stu.age){ 
return 1 ; 
}else if(this.age<stu.age){ 
return -1 ; 
}else{ 
return this.name.compareTo(stu.name) ; 
} 
} 
} 
} ; 
public   class  ColDemo34 { 
public static void main(String args[]){ 
Set<Student> s = new TreeSet<Student>() ; 
s.add(new Student("张三",20,90.0f)) ; 
s.add(new Student("李四",22,90.0f)) ; 
s.add(new Student("王五",20,99.0f)) ; 
s.add(new Student("赵六",20,70.0f)) ; 
s.add(new Student("孙七",22,100.0f)) ; 
s.add(new Student("赵九",22,100.0f)) ; 
Iterator<Student> iter = s.iterator() ; 
while(iter.hasNext()){ 
System.out.println(iter.next()) ; 
} 
} 
} ; 
3.3 . 4 、二叉树排序（理解） 
对于整个JAVA来说所有的排序操作都是以Comparable展开的，所以现在重点观察Comparable。 
以下代码全部使用String为例。 
例如：使用Comparable接收String对象 
public   class  ColDemo22 { 
public static void main(String args[]){ 
Comparable c = "abc" ; 
System.out.println(c) ; 
} 
} ; 
分析： 
1 、所有对象打印的时候调用的都是toString() 
2 、String类中已经覆写toString() 
3 、String是Object的子类。 
4 、如果直接打印Comparable接口对象，调用的是toString()方法，但是此时此对象是通过String实例化的，所以肯定使的是String中已经被覆写toString()方法。 
对于JAVA中可以使用以下的方式规定出二叉树的排序方式： 
class  BinaryTree { 
class Node{ 
// 具体的内容 
private Comparable data ; 
// 保存左子树 
private Node left ; 
// 保存右子树 
private Node right ; 
public void addNode(Node newNode){ 
// 要确定是放在左子树还是右子树 
if(newNode.data.compareTo(this.data)<0){ 
// 放在左子树 
if(this.left==null){ 
this.left = newNode ; 
}else{ 
this.left.addNode(newNode) ; 
} 
} 
if(newNode.data.compareTo(this.data)>0){ 
// 放在左子树 
if(this.right==null){ 
this.right = newNode ; 
}else{ 
this.right.addNode(newNode) ; 
} 
} 
} 
public void printNode(){ 
// 先输出左子树 
if(this.left!=null){ 
this.left.printNode() ; 
} 
// 输出根节点 
System.out.println(this.data) ; 
// 输出右子树 
if(this.right!=null){ 
this.right.printNode() ; 
} 
} 
}; 
// 确定根元素 
private Node root ; 
public void add(Comparable data){ 
Node newNode = new Node() ; 
newNode.data = data ; 
if(root==null){ 
// 第一个元素，设置成根元素 
root = newNode ; 
}else{ 
// 如果此语句没有执行的话，则必须确定好是放在左子树还是右子树 
root.addNode(newNode) ; 
} 
} 
public void print(){ 
this.root.printNode() ; 
} 
} ; 
public   class  ColDemo23 { 
public static void main(String args[]){ 
BinaryTree bt = new BinaryTree() ; 
bt.add("C") ; 
bt.add("X") ; 
bt.add("A") ; 
bt.add("S") ; 
bt.add("O") ; 
bt.print() ; 
} 
} ; 
3.4 、Iterator接口 
3.4 . 1 、接口的主要用处 
Iterator是一个迭代输出接口。 
Iterator接口定义： 
 判断下一个元素是否有内容： public   boolean  hasNext() 
 取出内容： public  Object next() ; 
 从集合中删除元素： public   void  remove() ; 
例如：使用Iterator输出Collection（List）中的内容 
import  java.util. *  ; 
public   class  ColDemo07 { 
public static void main(String args[]){ 
// Collection list = new ArrayList() ; 
List list = new ArrayList() ; 
list.add("A") ; 
list.add("B") ; 
list.add("C") ; 
Iterator iter = list.iterator() ; 
while(iter.hasNext()){ 
String str = (String)iter.next() ; 
System.out.println(str) ; 
} 
} 
} ; 
3.4 . 2 、删除元素的说明 
在List和Iterator上都有remove方法。 
在使用Iterator迭代输出的时候，不能修改List中的内容，如果一旦修改，则肯定会出现错误。 
例如：以下代码在迭代输出的时候使用了List中的remove方法。 
import  java.util. *  ; 
public   class  ColDemo08 { 
public static void main(String args[]){ 
// Collection list = new ArrayList() ; 
List list = new ArrayList() ; 
list.add("A") ; 
list.add("B") ; 
list.add("C") ; 
Iterator iter = list.iterator() ; 
while(iter.hasNext()){ 
String str = (String)iter.next() ; 
if("C".equals(str)){ 
// 使用了List中的删除语法。 
list.remove(str) ; 
} 
} 
} 
} ; 
以上代码运行时出现了错误： 
Exception in thread  " main "  java.util.ConcurrentModificationException 
 at java.util.AbstractList$Itr.checkForComodification(Unknown Source) 
 at java.util.AbstractList$Itr.next(Unknown Source) 
 at ColDemo08.main(ColDemo08.java: 11 ) 
同样的代码，现在直接使用Iterator中的删除方法完成： 
import  java.util. *  ; 
public   class  ColDemo09 { 
public static void main(String args[]){ 
// Collection list = new ArrayList() ; 
List list = new ArrayList() ; 
list.add("A") ; 
list.add("B") ; 
list.add("C") ; 
Iterator iter = list.iterator() ; 
while(iter.hasNext()){ 
String str = (String)iter.next() ; 
if("C".equals(str)){ 
// 使用了Iterator中的删除语法。 
iter.remove() ; 
} 
} 
System.out.println(list) ; 
} 
} ; 
3.4 . 3 、子接口 —— ListIterator 
Iterator本身只支持由前向后的输出，并不支持由后向前，那么其有一个子接口 —— ListIterator，此接口可以将内容从前向后，也可以从后向前，但是必须注意的是：必须先由前向后输出完之后，才能由后向前输出。只有List接口的对象才可以使用此种方法。 
ListIterator中的主要方法： 
 判断是否有下一个内容： public   boolean  hasNext() 
 取出下一个元素： public  Object next() 
 判断是否有上一个元素： public   boolean  hasPrevious(); 
 取出上一个元素： public  Object previous() ; 
 本身ListIterator也是支持泛型的 
例如：以下代码演示了ListIterator的作用 
import  java.util. *  ; 
public   class  ColDemo13 { 
public static void main(String args[]){ 
List<String> list = new ArrayList<String>() ; 
list.add("A") ; 
list.add("B") ; 
list.add("C") ; 
list.add("D") ; 
list.add("E") ; 
ListIterator<String> liter = list.listIterator() ; 
System.out.println(" ============== 由前向后输出 ==================") ; 
while(liter.hasNext()){ 
System.out.print(liter.next()+"、") ; 
} 
System.out.println("") ; 
System.out.println(" ============== 由后向前输出 ==================") ; 
while(liter.hasPrevious()){ 
System.out.print(liter.previous()+"、") ; 
} 
} 
} ; 
3.4 、Enumeration接口 
是最早的迭代输出接口，其本身的功能和Iterator类似，但是因为其出现较早，而且代码本身存在安全问题，所以现在使用较少，但是对于一些原有的系统中的若干方法，还是只能使用Enumeration输出。 
Enumerationi接口的定义： 
 判断是否有下一个元素： public   boolean  hasMoreElements() 
 取出元素： public  Object nextElement() 
例如：使用Enumeration输出Vector中的内容 
import  java.util. *  ; 
public   class  ColDemo15 { 
public static void main(String args[]){ 
Vector<String> list = new Vector<String>() ; 
list.add("A") ; 
list.add("B") ; 
list.add("C") ; 
list.add("D") ; 
list.add("E") ; 
Enumeration<String> enu = list.elements() ; 
while(enu.hasMoreElements()){ 
System.out.print(enu.nextElement()+"、") ; 
} 
} 
} ; 
3.5 、foreach输出（了解） 
提供了比Iterator更简单的输出语法，但是是在JDK  1 .5之后才增加的。 
语法格式： 
for (类型 对象:集合) { 
进行对象的操作 
}  
例如：验证foreach语法 
import  java.util. *  ; 
class  Person  implements  Comparable < Person > { 
private String name ; 
private int age ; 
public Person(String name,int age){ 
this.name = name ; 
this.age = age ; 
} 
public String toString(){ 
return "姓名；" + this.name + "，年龄；" + this.age ; 
} 
public int compareTo(Person per){ 
if(this.age>per.age){ 
return -1 ; 
}else if(this.age<per.age){ 
return 1 ; 
}else{ 
return 0 ; 
} 
} 
} ; 
public   class  ColDemo21 { 
public static void main(String args[]){ 
Set<Person> list = new TreeSet<Person>() ; 
list.add(new Person("张三",30)) ; 
list.add(new Person("李四",31)) ; 
list.add(new Person("王五",32)) ; 
for(Person p:list){ 
System.out.println(p) ; 
} 
} 
} ; 
3.6 、Map接口 
与之前Collection不同的是Map接口可以存放一对值。 
Map与Set一样，本身不能有任何重复的内容（key不能重复）。 
主要操作方法如下； 
 向集合中插入一组数据： public  V put(K key,V value) 
 根据key取出value： public  V get(Object key) 
在Map中因为其组成较为特殊，所以本身不直接支持Iterator输出。 
Set实例 entrySet()  步骤：Map   区分key和value。 Map.Entry实例  Iterator  
 Map.Entry：是Map的内部接口 
|-  得到key： public  K getKey() 
|-  得到value： public  V getValue() 
 操作方法： 
|-  将全部的Map变为Set集合： public  Set < Map.Entry < K,V >>  entrySet() 
|-  将全部的key变为Set集合： public  Set < K >  keySet() 
|-  将全部的value变为Collection集合： public  Collection < V >  values() 
3.6 . 1 、常用子类 
1 、HashMap：是一个新的类，是在JDK  1 .2之后推出的，属于异步处理方式。 
2 、Hashtable：是一个旧的类，是在JDK  1 .0时推出，属于同步处理方式 
3 、TreeMap：按照key排序，同样key所在的类必须实现Comparable接口 
3.6 . 2 、Hashtable子类 —— Properties 
与Hashtable不同的是Properties主要操作的内容为字符串，表示的是属性操作。 
Properties的主要方法： 
 设置属性： public  Object setProperty(String key, String value) 
 取得属性： 
|-   public  String getProperty(String key)：根据key找到value，没找到返回null。 
|-   public  String getProperty(String key,String defaultValue)：如果没有找到，则指定默认值。 
 保存属性到文件： public   void  store(OutputStream out,String comments)  throws  IOException 
 从文件中读取内容： public   void  load(InputStream inStream)  throws  IOException 
 把文件保存成XML样式： 
|-   public   void  storeToXML(OutputStream os,String comment)  throws  IOException 
 从XML样式的文件之中读取属性： 
|-   public   void  loadFromXML(InputStream in)  throws  IOException, 
 InvalidPropertiesFormatException 
3.6 . 3 、Map操作（HashMap） 
例如：通过HashMap验证Map的使用 
import  java.util. *  ; 
public   class  ColDemo24 { 
public static void main(String arg[]){ 
Map<String,String> m = new HashMap<String,String>() ; 
m.put("zhangsan","123456") ; 
m.put("lisi","234567") ; 
m.put("wangwu","345678") ; 
String str = m.get("zhangsan") ; 
System.out.println(str) ; 
System.out.println(m.get("xxx")) ; 
} 
} ; 
3.6 . 4 、Map操作（Hashtable） 
import  java.util. *  ; 
public   class  ColDemo25 { 
public static void main(String arg[]){ 
Map<String,String> m = new Hashtable<String,String>() ; 
m.put("zhangsan","123456") ; 
m.put("lisi","234567") ; 
m.put("wangwu","345678") ; 
String str = m.get("zhangsan") ; 
System.out.println(str) ; 
System.out.println(m.get("xxx")) ; 
} 
} ; 
3.6 . 5 、Map操作（TreeMap） 
import  java.util. *  ; 
public   class  ColDemo26 { 
public static void main(String arg[]){ 
Map<String,String> m = new TreeMap<String,String>() ; 
m.put("zhangsan","123456") ; 
m.put("lisi","234567") ; 
m.put("wangwu","345678") ; 
String str = m.get("zhangsan") ; 
System.out.println(str) ; 
System.out.println(m.get("xxx")) ; 
} 
} ; 
3.6 . 6 、Map操作（输出） 
1 、使用Iterator输出Map中的全部数据（格式是固定的） 
  public  Set < Map.Entry < K,V >>  entrySet() 
import  java.util. *  ; 
public   class  ColDemo27 { 
public static void main(String arg[]){ 
Map<String,String> m = new TreeMap<String,String>() ; 
m.put("zhangsan","123456") ; 
m.put("lisi","234567") ; 
m.put("wangwu","345678") ; 
Set<Map.Entry<String,String>> list = m.entrySet() ; 
Iterator<Map.Entry<String,String>> iter = list.iterator() ; 
while(iter.hasNext()){ 
Map.Entry me = iter.next() ; 
System.out.println(me.getKey() + " --> " + me.getValue()) ; 
} 
} 
} ; 
2 、将Map中全部的key输出 
import  java.util. *  ; 
public   class  ColDemo28 { 
public static void main(String arg[]){ 
Map<String,String> m = new TreeMap<String,String>() ; 
m.put("zhangsan","123456") ; 
m.put("lisi","234567") ; 
m.put("wangwu","345678") ; 
Set<String> list = m.keySet() ; 
Iterator<String> iter = list.iterator() ; 
while(iter.hasNext()){ 
System.out.println(iter.next()) ; 
} 
} 
} ; 
3 、将Map中全部的value输出 
import  java.util. *  ; 
public   class  ColDemo29 { 
public static void main(String arg[]){ 
Map<String,String> m = new TreeMap<String,String>() ; 
m.put("zhangsan","123456") ; 
m.put("lisi","234567") ; 
m.put("wangwu","345678") ; 
Collection<String> list = m.values() ; 
Iterator<String> iter = list.iterator() ; 
while(iter.hasNext()){ 
System.out.println(iter.next()) ; 
} 
} 
} ; 
3.6 . 7 、Map操作（问题） 
例如：定义一个Person类，里面有name和age属性，之后在Map中保存一个person对象。 
import  java.util. *  ; 
class  Person { 
private String name ; 
private int age ; 
public Person(String name,int age){ 
this.name = name ; 
this.age = age ; 
} 
public String toString(){ 
return "姓名：" + this.name + "，年龄：" + this.age ; 
} 
} ; 
public   class  ColDemo30 { 
public static void main(String args[]){ 
Map<String,Person> m = new HashMap<String,Person>() ; 
m.put("zhangsan",new Person("张三",30)) ; 
System.out.println(m.get("zhangsan")) ; 
} 
} ; 
以上的运行结果，可以发现内容已经查找出来了。如果现在换个方式，使用Person对象表示张三呢？ 
import  java.util. *  ; 
class  Person { 
private String name ; 
private int age ; 
public Person(String name,int age){ 
this.name = name ; 
this.age = age ; 
} 
public String toString(){ 
return "姓名：" + this.name + "，年龄：" + this.age ; 
} 
} ; 
public   class  ColDemo31 { 
public static void main(String args[]){ 
Map<Person,String> m = new HashMap<Person,String>() ; 
m.put(new Person("张三",30),"zhangsan") ; 
System.out.println(m.get(new Person("张三",30))) ; 
} 
} ; 
从运行结果，发现，里面没有任何的内容，返回一个“ null ”。此时再修改代码： 
import  java.util. *  ; 
class  Person { 
private String name ; 
private int age ; 
public Person(String name,int age){ 
this.name = name ; 
this.age = age ; 
} 
public String toString(){ 
return "姓名：" + this.name + "，年龄：" + this.age ; 
} 
} ; 
public   class  ColDemo32 { 
public static void main(String args[]){ 
Map<Person,String> m = new HashMap<Person,String>() ; 
Person p = new Person("张三",30) ; 
m.put(p,"zhangsan") ; 
System.out.println(m.get(p)) ; 
} 
} ; 
以上可以找到代号。 
从以上代码中可以发现问题： 
 如果使用字符串作为key，就算是匿名对象也是可以找得到 
 如果自己编写了一个key，则如果使用匿名对象则无法找到。 
因为在对象上有一个对象自己的编码，那么如果要想使用此编码，则必须在对象所在的类中覆写Object类中的hashCode()方法。 
import  java.util. *  ; 
class  Person { 
private String name ; 
private int age ; 
public Person(String name,int age){ 
this.name = name ; 
this.age = age ; 
} 
public String toString(){ 
return "姓名：" + this.name + "，年龄：" + this.age ; 
} 
public boolean equals(Object obj){ 
if(this==obj){ 
return true ; 
} 
if(!(obj instanceof Person)){ 
return false ; 
} 
Person p = (Person)obj ; 
if(this.name.equals(p.name)&&this.age==p.age){ 
return true ; 
}else{ 
return false ; 
} 
} 
public int hashCode(){ 
// 正常来说，应该为hashCode的产生自己定义一个公式 
return this.age * this.name.hashCode() ; 
} 
} ; 
public   class  ColDemo33 { 
public static void main(String args[]){ 
Map<Person,String> m = new HashMap<Person,String>() ; 
m.put(new Person("张三",30),"zhangsan") ; 
System.out.println(m.get(new Person("张三",30))) ; 
} 
} ; 
3.6 . 8 、Properties操作 
1 、向Properties中设置属性，并取得属性 
import  java.util. *  ; 
public   class  ColDemo35 { 
public static void main(String args[]){ 
Properties pro = new Properties() ; 
pro.setProperty("BJ","BeiJing") ; 
pro.setProperty("NJ","NanJing") ; 
pro.setProperty("SH","ShangHai") ; 
System.out.println(pro.getProperty("BJ")) ; 
System.out.println(pro.getProperty("XJ")) ; 
System.out.println(pro.getProperty("XJ","nofound")) ; 
} 
} ; 
2 、将全部的属性保存在普通文件之中 
import  java.util. *  ; 
import  java.io. *  ; 
public   class  ColDemo36 { 
public static void main(String args[]) throws Exception{ 
Properties pro = new Properties() ; 
pro.setProperty("BJ","BeiJing") ; 
pro.setProperty("NJ","NanJing") ; 
pro.setProperty("SH","ShangHai") ; 
pro.store(new FileOutputStream(new File("e:\\pro.ini")),"AREA") ; 
} 
} ; 
3 、从文件中读取属性 
import  java.util. *  ; 
import  java.io. *  ; 
public   class  ColDemo37 { 
public static void main(String args[]) throws Exception{ 
Properties pro = new Properties() ; 
pro.load(new FileInputStream(new File("e:\\pro.ini"))) ; 
System.out.println(pro.getProperty("BJ")) ; 
} 
} ; 
4 、将属性按照XML样式的风格进行保存 
import  java.util. *  ; 
import  java.io. *  ; 
public   class  ColDemo38 { 
public static void main(String args[]) throws Exception{ 
Properties pro = new Properties() ; 
pro.setProperty("BJ","BeiJing") ; 
pro.setProperty("NJ","NanJing") ; 
pro.setProperty("SH","ShangHai") ; 
pro.storeToXML(new FileOutputStream(new File("e:\\pro.xml")),"AREA") ; 
} 
} ; 
5 、将属性从XML中读取出来 
import  java.util. *  ; 
import  java.io. *  ; 
public   class  ColDemo39 { 
public static void main(String args[]) throws Exception{ 
Properties pro = new Properties() ; 
pro.loadFromXML(new FileInputStream(new File("e:\\pro.xml"))) ; 
System.out.println(pro.getProperty("BJ")) ; 
} 
} ; 
现在操作属性的时候基本上都是以XML样式为准。 
3.7 、实例 
3.7 . 1 、实例一 
一个人有多本书，一本书属于一个人。 
package  org.lxh.demo1; 
import  java.util.ArrayList; 
import  java.util.Iterator; 
import  java.util.List; 
class  Person  { 
private String name; 
private int age; 
private List<Book> listBooks; 
public Person() { 
this.listBooks = new ArrayList<Book>(); 
} 
public Person(String name, int age) { 
this(); 
this.name = name; 
this.age = age; 
} 
public String getName() { 
return name; 
} 
public void setName(String name) { 
this.name = name; 
} 
public int getAge() { 
return age; 
} 
public void setAge(int age) { 
this.age = age; 
} 
public List<Book> getlistBooks() { 
return listBooks; 
} 
public void setlistBooks(List<Book> listBooks) { 
this.listBooks = listBooks; 
} 
}  
class  Book  { 
private String title; 
private Person person; 
public Book(String title) { 
super(); 
this.title = title; 
} 
public String getTitle() { 
return title; 
} 
public void setTitle(String title) { 
this.title = title; 
} 
public Person getPerson() { 
return person; 
} 
public void setPerson(Person person) { 
this.person = person; 
} 
}  
public   class  Demo01  { 
public static void main(String[] args) { 
Person per = new Person("张三", 30); 
Book b1 = new Book("JAVA"); 
Book b2 = new Book("C"); 
Book b3 = new Book("NET"); 
per.getlistBooks().add(b1); 
per.getlistBooks().add(b2); 
per.getlistBooks().add(b3); 
b1.setPerson(per); 
b2.setPerson(per); 
b3.setPerson(per); 
System.out.println("姓名：" + per.getName() + "，年龄：" + per.getAge()); 
Iterator<Book> iter = per.getlistBooks().iterator(); 
while (iter.hasNext()) { 
System.out.println("\t|- " + iter.next().getTitle()); 
} 
} 
}  
3.7 . 2 、实例二 
一个学生可以选多个课程，一个课程可以多个学生参加。 
package  org.lxh.demo2; 
import  java.util.ArrayList; 
import  java.util.Iterator; 
import  java.util.List; 
class  Student  { 
private String name; 
private List<Course> listCourses; 
public Student() { 
this.listCourses = new ArrayList<Course>(); 
} 
public Student(String name) { 
this(); 
this.name = name; 
} 
public String getName() { 
return name; 
} 
public void setName(String name) { 
this.name = name; 
} 
public List<Course> getlistCourses() { 
return listCourses; 
} 
public void setlistCourses(List<Course> listCourses) { 
this.listCourses = listCourses; 
} 
}  
class  Course  { 
private String name; 
public List<Student> listStudents; 
public Course() { 
this.listStudents = new ArrayList<Student>(); 
} 
public Course(String name) { 
this(); 
this.name = name; 
} 
public String getName() { 
return name; 
} 
public void setName(String name) { 
this.name = name; 
} 
public List<Student> getlistStudents() { 
return listStudents; 
} 
public void setlistStudents(List<Student> listStudents) { 
this.listStudents = listStudents; 
} 
}  
public   class  Demo02  { 
public static void main(String[] args) { 
Student s1 = new Student("张三"); 
Student s2 = new Student("李四"); 
Student s3 = new Student("王五"); 
Student s4 = new Student("赵六"); 
Student s5 = new Student("孙七"); 
Course c1 = new Course("JAVA"); 
Course c2 = new Course("Oracle"); 
// 设置关系 
s1.getlistCourses().add(c1); 
c1.getlistStudents().add(s1); 
s2.getlistCourses().add(c1); 
c1.getlistStudents().add(s2); 
s3.getlistCourses().add(c1); 
c1.getlistStudents().add(s3); 
s4.getlistCourses().add(c2); 
c2.getlistStudents().add(s4); 
s5.getlistCourses().add(c2); 
c2.getlistStudents().add(s5); 
s1.getlistCourses().add(c2); 
c2.getlistStudents().add(s1); 
s2.getlistCourses().add(c2); 
c2.getlistStudents().add(s2); 
System.out.println("学生：" + s1.getName()); 
Iterator<Course> iter1 = s1.getlistCourses().iterator(); 
while (iter1.hasNext()) { 
System.out.println("\t|- " + iter1.next().getName()); 
} 
System.out.println("---------------------------------"); 
System.out.println("课程：" + c2.getName()); 
Iterator<Student> iter2 = c2.getlistStudents().iterator(); 
while (iter2.hasNext()) { 
System.out.println("\t|- " + iter2.next().getName()); 
} 
} 
}  
4 、总结 
1 、Collection（保存单个对象） 
 List：允许有重复元素，拥有更多的操作方法 
|-  ArrayList：新的、异步处理 
|-  Vector：旧的， 同步处理，支持Iterator和Enumeration两种输出 
|-  Stack：入栈、出栈 
 Set：不允许有重复元素，靠hashCode和equals方法来区分重复元素 
|-  HashSet：无序 
|-  TreeSet：有序、按照Comparable指定的规则排序 
 常用方法：add()、iterator()、remove 
2 、Map（保存一对对象） 
 HashMap：新的类，异步处理 
 Hashtable：旧的类，同步处理 
|-  Properties（属性操作），可以将属性保存在文件之中 
 TreeMap：排序操作类，此类按key排序，使用Comparable完成 
 主要方法：put、get、entrySet 
 Map不能直接使用Iterator输出，必须转换成Set，通过Map.Entry分离key和value 
3 、Iterator 
 输出接口，只要是类集都使用此接口输出，一般情况下很少有删除代码出现 
 主要方法： 
|-  判断是否有下一个元素： public   boolean  hasNext() 
|-  取出当前元素： public  Object next() 
 子接口：ListIterator 
|-  双向输出，但是此接口只能通过List实例化 
4 、Enumeration接口 
 最早的输出接口，现在部分代码上依然使用