黑马程序员 集合框架

　　-------android培训、java培训、期待与您交流！ ----------

第一节 集合框架

一．概述：

1.面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。

2.数组和集合类同是容器，有何不同：

   数组虽然也可以存储对象，但长度是固定的，集合长度是可变的。

   数组中可以存储基本数据类型，集合只能存储对象。

3.集合类的特点：集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。

4.每一个容器对数据的存储方式都有不同。这个存储方式我们称之为数据结构。

二．集合中德共性方法。

1.增加：boolean add(E e) ; 添加元素方法。

2.删除：boolean remove(Object o) ;从集合中移除单个元素。

        boolean removeAll(Collection<?> c); 移除一堆元素。

        void clear();  清空集合中的元素。

3.查：Iterator<E> iterator();  返回在此collection的元素上进行迭代的迭代器。

4.长度：  int size()；  返回集合中元素的大小。

5. Object[] toArray() ；  把集合转成数组。

注意：

add方法的参数类型是Object。以便于接收任意类型对象。

集合中存储的都是对象的引用（地址）

什么是迭代器呢？

其实就是集合的取出元素的方式。

因为每个容器的数据结构不一样，所以存取的方式也不一样。

对于取出这个动作，不足以用一个函数来表示。而是需要多个，所以就把这个动作提取为一个类。集合中存放着元素，你想要操作集合中的元素。所以把取出方式定义在集合的内部。这样取出方式就可以直接访问集合内容的元素。

那么取出方式就被定义成了内部类。而每一个容器的数据结构不同，所以取出的动作细节也不一样。但是都有共性内容判断和取出。那么可以将共性抽取。

那么这些内部类都符合一个规则。该规则是Iterator。如何获取集合的取出对象呢？通过一个对外提供的方法。iterator();

 

Collection:

|--List:元素是有序的，元素可以重复。因为该集合体系有索引。

   |--ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。

   |--LinkedList ：底层使用的是链表数据结构。特点：增删的速度很快，查询速度慢。

   |--Vector：底层是数组数据结构。线程同步。被ArrayList替代了.

|--Set:元素是无序的。元素不可以重复。

第二节 List集合

一．概述：

  List：特有方法。凡是可以操作脚标的方法都是该体系特有的方法。

  增： add(index,element);

       addAll(index Collection)

  删 : remove(index) 

  改 : set(index,elements);

  查 :  get(index);  

       subList(from,to);

       listIterator();

方法演示示例代码：

package Collection;
import java.util.*;
public class CollectionDemo {
	  public static void main(String[] args){
		   method_2();
	  }
	  public static void method_2(){
		  ArrayList  al = new ArrayList();
		   //添加元素
		   al.add("java01");
		   al.add("java02");
		   al.add("java03");
		   al.add("java04");
		   
		   ArrayList  al2 = new ArrayList();
		   //添加元素
		   al2.add("java03");
		   al2.add("java04");
		   al2.add("java05");
		   al2.add("java06");
		   //取两个集合中的交集，al中只保留交集元素
		 //  al.retainAll(al2);
		  // sop(al);
		   //移除两个集合交集的元素。
		   al.removeAll(al2);
		   sop(al);
	  }
	  public static void method_1(){
		   ArrayList  al = new ArrayList();
		   //添加元素
		   al.add("java01");
		   al.add("java02");
		   al.add("java03");
		   al.add("java04");
		   sop(al);  //打印集合中的元素
		   sop("size:"+al.size());  //打印集合长度
		   al.remove("java01");  //删除元素
		   sop("size:"+al.size()); 
		   sop(al);
		   al.clear();  //清空集合中的元素。
		   sop(al);
	  }
	  public static void sop(Object o){
		  System.out.println(o);
	  }

}

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

所以在迭代时，只能用迭代器的方法操作元素，可是Iterator方法是有局限性的。只能对元素进行判断，取出，删除的操作。

如果想要其他的操作如添加，修改等，就需要使用其子接口：ListIterator。

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

 

枚举就是Vector特有的取出方式。发现枚举和迭代器很像。

其实枚举和迭代是一样的。

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

示例代码：

package Collection;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;

public class ListDemo {
	public static void main(String[] args){

		listIteratorMethod();
	}
	  public static void addMethod(){
			ArrayList  al = new ArrayList();
			   //添加元素
			   al.add("java01");
			   al.add("java02");
			   al.add("java03");
			   al.add("java04");
			   //原集合为：
			   sop(al);
			   //删除某个元素
			   //al.remove(1);
			   //sop(al);
			   //修改元素
			   al.set(2, "java09");
			   //两种方式获取元素。
			   for(int i=0;i<al.size();i++){
				   sop("al"+i+":"+al.get(i));
			   }
			  for( Iterator it = al.iterator(); it.hasNext();){
				   sop(it.next());
			  }
	  }
	  public static void sop(Object o){
		  System.out.println(o);
	  }
	  
	  public static void listIteratorMethod(){
		  ArrayList  al = new ArrayList();
		   //添加元素
		   al.add("java01");
		   al.add("java02");
		   al.add("java03");
		   al.add("java04");   
		   sop(al);
		   for(ListIterator  lit = al.listIterator();lit.hasNext();){
			    Object obj = lit.next();
			    if(obj.equals("java01"))
			    	//lit.add("java008");   // 在迭代的时候添加元素
			    	//lit.set("java007");  //在迭代的时候修改元素
			    	lit.remove();  //在迭代的时候移除元素
			    sop(obj);
		   }
		   sop(al);
	  }

}

LinkedList类：

特有方法：

增：

addFirst(E e);  将指定元素插入此列表的开头。

addLast(E e); 将指定元素添加到此列表的结尾。

删：

removeFirst() ;移除并返回此列表的第一个元素。若列表为空，则抛出NosuchElementException异常

removeLast();  移除并返回此列表的最后一个元素。同上的异常

获取：

getFirst();  返回此列表的第一个元素。 若列表为空，则抛出NosuchElementException异常

 

getLast();  返回此列表的最后一个元素。

 

LinkedList升级后的方法：

增加 ：

  offerFirst();

  offerLast();

获取：

 peekFirst(); 若列表为空，返回null；

 peekLast(); 若列表为空，返回null；

删除：

poolFirst();  若列表为空，返回null；

poolLast();  若列表为空，返回null；

第三节  Set集合

一．概述：

1.Set：元素是无序(存入和取出的顺序不一定一致)，元素不可以重复。

      |--HashSet：底层数据结构是哈希表。线程不同步

           HashSet是如何保证元素的唯一性的呢？

           是通过元素的两个方法，hashCode和equals来完成。

           如果元素的HashCode值相同，才会判断equals是否为true。

           如果元素的HashCode不同。就不会调用equals方法。

注意：对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。

      |--TreeSet：底层数据结构是二叉树。保证元素唯一性的依据。

        TreeSet排序的第一种方式：让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法。这种方式也成为元素的自然顺序，或者叫做默认顺序。

      TreeSet的第二种排序方式。当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。在集合初始化时，就有了比较方式。

特点：可以对Set集合中的元素进行排序。

当两种排序都存在时，以比较起为主。

     记住，当排序时，当主要条件相同时，一定要判断一下次要条件。

2.Set集合的功能和Collection是一致的。

3.Set集合取出方式只有一种就是迭代器。

二．哈希表：

1）哈希表是按照哈希值的大小进行排列的，如果两个哈希值不同，则大的值放后面；如果两个哈希值相同，则再用equals方法比较两个元素的对象是否相同，如果不同，则将第二个值顺延，两个值串起来，放在同一个位置上。

2）取值时是按照哈希值取出来的。

 

HashSet存储自定义对象：

示例代码：

package Collection;

import java.util.HashSet;
import java.util.Iterator;



public class HashSetDemo {
	  public static void main(String[] args){
		   HashSet hs = new HashSet();
		   hs.add(new Person("java01",11));
		   hs.add(new Person("java02",12));
		   hs.add(new Person("java01",11));
		   hs.add(new Person("java03",13));
		   
		    for(Iterator it =hs.iterator();it.hasNext();){
		    	 Person p = (Person)it.next();
		    	 System.out.println(p.getName()+"......"+p.getAge());
		    }
	  }

}
class Person {
	 private String name;
	 private int age;
	 
	 //定义构造方法，在学生创建时就赋予它基本信息(名字,成绩,总成绩)
	 Person(String name,int age){
		 this.name=name;
	     this.age=age;
	 }
	 public String getName(){
		 return this.name;
	 }
	 public int getAge(){
		 return this.age;
	 }
	 //重写hashCode方法
	 public int hashCode(){
		 System.out.println(this.name+".....hashcode");
		 return 60;
	 }
	 public boolean equals(Object o){
		  if(! (o instanceof Person))
			  return false;
		  
		  Person p  = (Person)o;
		  System.out.println(this.name+"equals"+p.name);
		  return this.name.equals(p.name)&&this.age==p.age;
		  
	 }
	 
}

TreeSet排序示例代码：

package Collection;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

public class TreeSetDemo {
	public static void main(String[] args){
		//第二种排序方式。就是让集合具有可比性
		TreeSet ts = new TreeSet(new Mycomparator());
		 ts.add(new Student("java01",40));
		 ts.add(new Student("java073",55));
		 ts.add(new Student("java02",20));
		 ts.add(new Student("java01",35));
		 ts.add(new Student("java013",55));
		 ts.add(new Student("java03",55));
		 
		 for(Iterator it = ts.iterator();it.hasNext();){
			 Student s =(Student)it.next();
			 System.out.println(s.getName()+"........."+s.getAge());
		 }
	}
	


}
//第一种排序方式。让元素自身实现可比性。
class Student implements Comparable{
    private String name;
    private int age;
    Student(String name,int age){
    	this.name=name;
    	this.age=age;
    }
    Student(){
    	
    }
    public String getName(){
    	return this.name;
    }
    public int getAge(){
    	return this.age;
    }
	@Override
	public int compareTo(Object o) {
		 if(!(o instanceof Student))
			 throw new RuntimeException("类型不匹配");
		 Student s = (Student)o;
		 int num = new Integer(this.age).compareTo(new Integer(s.getAge()));
		 if(num==0)
			 return this.name.compareTo(s.getName());
		return num;
	}
	
}
class Mycomparator implements Comparator{

	@Override
	public int compare(Object o1, Object o2) {
		// TODO Auto-generated method stub
		Student s = (Student)o1;
		Student s2 = (Student)o2;
		int num = new Integer(s.getAge()).compareTo(new Integer(s2.getAge()));
		if(num==0)
			return s.getName().compareTo(s2.getName());
		return num;
	}
	 
}

泛型概述：

泛型：JDK1.5版本以后出现的新特性。用于解决安全问题，是一个类型安全机制。

好处：

1.将运行时期出现问题ClassCastException，转移到了编译时期。方便于程序员解决问题。让运行事情问题减少，安全。

2.避免了强制转换的麻烦。

 

泛型格式：通过< >来定义要操作的引用数据类型。

在使用java提供的对象时，什么时候写泛型呢？

通常在集合框架中很常见，只要见到< >就要定义泛型。

其实< >就是用来接收类型的。当使用集合时，将集合中要存储的数据类型作为参数传递到< >中即可。

泛型使用示例代码：

package Collection;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

public class GenericDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
         TreeSet<String> ts = new TreeSet<String>(new lengthComparator());
         ts.add("abc");
         ts.add("fdsf");
         ts.add("obnjde");
         ts.add("abd");
         ts.add("abcde");
         ts.add("obnjee");
         //定义泛型的好处一： 在把元素添加进集合时，要是添加的不是String类型。编译器就会报错。
        // ts.add(4);
        for(Iterator<String> it =ts.iterator();it.hasNext();){
        	// String s = (String)it.next();  //好处二：没有泛型前这里需要强制类型转换。而有了泛型后不用强制转换了。
        	String s = it.next();
        	System.out.println(s);
        }
	}
}
class lengthComparator implements Comparator<String>{

	@Override
	public int compare(String o1, String o2) {
		// TODO Auto-generated method stub
		int num = new Integer(o1.length()).compareTo(new Integer(o2.length()));
		if(num==0)
		{
			return o1.compareTo(o2);
		}
		return num;
	}
	  
}

泛型类：

什么时候定义泛型类？当类中要操作的引用数据类型不确定的时候，早期定义Object来完成扩展，现在定义泛型来完成扩展。

示例代码：

package Collection;

public class GenericDemo2 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
//        Tool  t = new Tool();
//        t.setObject(new Student());
//        Student s = (Student)t.getObject();     
		//有个泛型这个特性后的做法
		 Utils<Student> ut = new Utils<Student>();
		 ut.setQQ(new Student());
		 Student s = ut.getQQ();
		 
	}
  

}
//没有出现泛型这个特性之前的做法
class Tool{
	private Object o;
	public void setObject(Object o){
		this.o=o;
	}
	public Object getObject(){
		return this.o;
	}
     
}
class Utils<QQ>{
	private QQ q;
	public void setQQ(QQ q){
		this.q=q;
	}
	public QQ getQQ(){
		return q;
	}
}

泛型方法：

泛型类定义的泛型，在整个类中有效。如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。

为了让不同方法可以操作不同类型，而且类型还不确定。

那么可以将泛型定义在方法上。

特殊之处：

静态方法不可以访问类上定义的泛型。如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。

示例代码：

package Collection;

import java.util.ArrayList;
import java.util.Iterator;

public class GenericDemo3 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ArrayList<String> ts = new ArrayList<String>();
        ts.add("abc");
        ts.add("fdsf");
        ts.add("obnjde");
        ts.add("abd");
        ts.add("abcde");
        ts.add("obnjee");
        iteratorMethod(ts);
        ArrayList<Integer> ts2 = new ArrayList<Integer>();
        ts2.add(18);
        ts2.add(19);
        ts2.add(20);
        iteratorMethod(ts2);
	}
	//定义泛型可以为？，也可以为T
	public static <T> void iteratorMethod(ArrayList<T>  list){
		for(Iterator<T > it  =list.iterator();it.hasNext();){
			  System.out.println(it.next());
		}
	}
	

}

泛型定义在接口上。

泛型限定： ?  Extends E ：可以接收E类型或者E的子类型。上限。

           ?  super  E :可以接收E类型或者E的父类型。下限

? 通配符。也可以理解为占位符。

第四节 Map集合

一．概述：

1.特点：该集合存储键值对。一对一对往里存。而且要保证键的唯一性。

2.常用方法：

   1.添加：v  put(k key , v value); 将数据以键值对的方式存进集合中。

          void putAll(Map<? extends k,? extends v> m) ;从指定映射中将所有映射关系复制到此映射中

   2.删除：void clear();  清空集合

          v remove(Object key); 将集合中的元素以键的形式移除。

 

   3.判断：containsKey(Object key) 判断集合中是否有key。如果有，则返回true。

          contaninValue(Object value) 判断集合中是否有value

   4.查询：get(Object key);

          size();

          values();

          entrySet();

         keySet();

 Map有三个常见子类：

   |---Hashtable：此类实现一个哈希表，该哈希表将映射到相应的值。任何非null对象都可以用作键或值。该集合是线程同步的。 Jdk1.0 效率低

   |--HashMap：底层是哈希表数据结构，允许使用null值和null键，该集合是不同步的。 Jdk1.2 效率高

   |--TreeMap：底层是二叉树数据结构。线程不同步。可以用于给map集合中的键进行排序。

 

和Set很像。

其实Set底层就是使用了Map集合。

 

注：如果添加相同的键，那么后添加的值会覆盖原来键对应值。

map集合的两种取出方式：

1.keySet：将map中所有的键存入到Set集合。因为set具备迭代器。所以可以用迭代的方式取出所有的键，在根据get方法。获取每一个键对应的值。

 Map集合的取出原理：将map集合转成set集合。再通过迭代器取出。

2.Set<Map.Entry<k,v>>  entrySet：将map集合中德映射关系存入到了set集合中，而这个关系的数据类型就是：map.entry.

 

Map.Entry  其实Entry也是一个接口，它是Map接口中的一个内部接口。

为何要定义在其内部呢？

原因：

a.Map集合中存的是映射关系这样的两个数据，是先有Map这个集合，才可有映射关系的存在，而且此类关系是集合的内部事务。

b.并且这个映射关系可以直接访问Map集合中的内部成员，所以定义在内部。

示例代码：

package Collection;

import java.util.HashMap;
import java.util.Iterator;

import java.util.Set;
import java.util.Map.Entry;

public class HashMapDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		entrySetMethod();
         
	}
	//利用keySet这个方法取出map集合中的值。
	public static void keySetMethod(){
		//创建一个HashMap集合，并添加了泛型。键值都是String类型的。
        HashMap<String,String> hm = new HashMap<String,String>();
        hm.put("01","zhangsan01");
        hm.put("02","zhangsan02");
        hm.put("03","zhangsan03");
        hm.put("04","zhangsan04");
        Set<String> keyset = hm.keySet();
        for(Iterator<String> it =keyset.iterator();it.hasNext();){
       	    String key =it.next();
       	    String value = hm.get(key);
       	    System.out.println("key: "+key+" "+"value:"+value);
        }
	}
	public static void entrySetMethod(){
		HashMap<String,String> hm = new HashMap<String,String>();
        hm.put("01","zhangsan01");
        hm.put("02","zhangsan02");
        hm.put("03","zhangsan03");
        hm.put("04","zhangsan04");
        Set<Entry<String, String>> entry=hm.entrySet();
        for(Iterator<Entry<String, String>> it =entry.iterator();it.hasNext();){
        	Entry<String, String> en = it.next();
        	System.out.println(en.getKey()+"  "+en.getValue());
        }
	}
	

}

Map练习：

每一个学生都有对应的归属地。学生Student，地址String。学生属性：姓名，年龄。

注意：姓名和年龄相同的视为同一个学生。保证学生的唯一性。

思路：

1.描述学生。

2.定义map容器。将学生作为键，地址作为值。存入。

3.获取map集合中的元素。

示例代码：

package Collection;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class MapTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		entrySet();
	}
	//第一种取出方式keySet();
    public static void keySet(){
    	HashMap<Students,String> hm   = new HashMap<Students,String>();
    	hm.put(new Students("lisi1",21), "beijing");
    	hm.put(new Students("lisi1",21), "tianjing");
    	hm.put(new Students("lisi4",33), "nanjing");
    	hm.put(new Students("lisi8",44), "ganzhou");
    	hm.put(new Students("lisi5",80), "hengyang");
    	Set<Students> keyset  =hm.keySet();
    	for(Iterator<Students> it = keyset.iterator();it.hasNext();){
    		  Students key =it.next();
    		  String addrv =hm.get(key);
    		  System.out.println(key+":::"+addrv);
    		  
    	}
    }
    public static void entrySet(){
    	HashMap<Students,String> hm   = new HashMap<Students,String>();
    	hm.put(new Students("lisi1",21), "beijing");
    	hm.put(new Students("lisi1",21), "tianjing");
    	hm.put(new Students("lisi4",33), "nanjing");
    	hm.put(new Students("lisi8",44), "ganzhou");
    	hm.put(new Students("lisi5",80), "hengyang");
    	Set<Map.Entry<Students, String>> entryset = hm.entrySet();
    	for(Iterator<Map.Entry<Students, String>> it =entryset.iterator();it.hasNext();){
    		 Map.Entry<Students, String> entry = it.next();
    		 Students s = entry.getKey();
    		 String addr = entry.getValue();
    		 System.out.println(s+":::"+addr);
    	}
    }
	
	

}

练习2：

需求：对学生对象的年龄进行升序排序。

因为数据是以键值对形式存在的。所以要使用可以排序的Map集合TreeMap。

示例代码

package Collection;

import java.util.Comparator;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeMap;

public class MapTest2 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		TreeMap<Students,String> tm   = new TreeMap<Students,String>(new myCom());
    	tm.put(new Students("lisi1",21), "beijing");
    	tm.put(new Students("lisi1",21), "tianjing");
    	tm.put(new Students("lisi4",33), "nanjing");
    	tm.put(new Students("lisi8",44), "ganzhou");
    	tm.put(new Students("lisi5",80), "hengyang");
    	Set<Students> set = tm.keySet();
    	Iterator<Students> it   =set.iterator();
    	while(it.hasNext())
    	{
    		Students stu = it.next();
    		String addrv = tm.get(stu);
    		System.out.println(stu+":::"+addrv);
    	}
    	
	}
}
class  myCom implements Comparator<Students>{

		@Override
		public int compare(Students o1, Students o2) {
			// TODO Auto-generated method stub
			int num = new Integer(o1.getAge()).compareTo(new Integer(o2.getAge()));
			if(num==0)
				return o1.getName().compareTo(o2.getName());
			return num;
		}


		 
}
	

练习3：

“dsfdsfdsfrfew”获取该字符串中的字母出现的次数。

希望打印结果：a(1)c(2).........

通过结果发现，每一个字母都有对应的次数。说明字母和次数之间都有映射关系。

注意了，当发现有映射关系时，可以选择map集合。因为map集合中存放就是映射关系。

什么时候使用map集合呢？

当数据之间存在这映射关系时，就先要想map集合。

思路：

1.将字符串转换成字符数组。因为要对每一个字符进行操作。

2.定义一个map集合，因为打印结果的字母有顺序，所以使用treemap集合。

3.遍历字符数组，将每一个字符作为键去查map集合，如果返回null将该字母和1存入到map集合中。如果返回不是null，说明该字符在map集合已经存在并有对应的次数。那么就获取该次数并进行自增。然后将该字母和自增后的次数存入到map集合中。覆盖调用原键值对。

4.将map集合中的数据变成指定的字符串形式并返回。

示例代码：

package Collection;

import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

public class Maptest3 {
	public static void main(String[] args){
		System.out.println(testMethod("abcaabddkeufdasda"));
	}
	
	public static String  testMethod(String str){
		char[]  chs = str.toCharArray();
		TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();
		StringBuilder sb = new StringBuilder();
		int count=0;
		for(int i=0;i<chs.length;i++){
			Integer value = tm.get(chs[i]);
			if(!(value==null))
					count =value;
			count++;
			tm.put(chs[i], count);
			count=0;
		}
		Set<Map.Entry<Character,Integer>> entry = tm.entrySet();
		for(Iterator<Map.Entry<Character,Integer>> it =entry.iterator();it.hasNext();){
			 Map.Entry<Character,Integer> map = it.next();
			 Character ch = map.getKey();
			 Integer  in = map.getValue();
			 sb.append(ch+"("+in+")");
		}
		return sb.toString();
	}

}

Map扩展知识。

示例代码：

package Collection;

import java.util.*;
public class MapDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		hashMapMethod();
	}
	
	public static void hashMapMethod(){
		HashMap<String,HashMap<String,String>> hm = new HashMap<String,HashMap<String,String>>();
		HashMap<String,String> yure = new HashMap<String,String>();
		HashMap<String,String> jiuye  = new HashMap<String,String>();
		hm.put("yureban", yure);
		hm.put("jiuyeban", jiuye);
		yure.put("01", "小明");
		yure.put("09", "小华");
		jiuye.put("01", "小分");
		jiuye.put("09", "小康");
		Set<String> set = hm.keySet();
		Iterator<String> it = set.iterator();
		while(it.hasNext()){
			 String roomname =it.next();
			 HashMap<String,String> room = hm.get(roomname);
			 entryRoomName(room);
		}
	}
	public static void entryRoomName(HashMap<String,String> room){
		  Set<Map.Entry<String, String>> entry = room.entrySet();
		  for(Iterator<Map.Entry<String, String>> it = entry.iterator();it.hasNext();){
			  Map.Entry<String, String> map = it.next();
			  String num =map.getKey();
			  String name = map.getValue();
			  System.out.println("学号:"+num+"名字："+name);
		  }
	}

}