集合

一、概述

1、为什么出现集合类？

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

2、数组和集合类同是容器，有何不同？

数组虽然也可以存储对象，但长度是固定的；
集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象。

3、集合类的特点

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

4、为什么会出现那么多的容器呢？

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

二、Collection接口常见操作

//创建一个集合容器，使用Cillection接口的子类。
ArrayList al=new ArrayList();

1、添加元素

add（Object obj）//add方法的参数类型是Object，以便于接受任意类型对象。

2、获取个数。集合长度。//集合中存储的都是对象的引用（地址）

size（）

3、删除元素

remove();
clear();//晴空集合

4、判断元素

contains(); //是否包含
isEmpty();//是否为空

5、取交集

retainAll();//保留此 collection 中那些也包含在指定 collection 中的所有元素
removeAll();//移除此 collection 中那些也包含在指定 collection 中的所有元素

 

我的总结：数组取长度为length；字符串取长度length（）；集合取长度size（）。

三、迭代器

1、概述

就把取出方式定义在集合的内部，

这样取出方式就可以直接访问集合内容的元素。

那么取出方式就被定义成了内部类。

而每一个容器的数据结构都不同，

所以取出的动作细节也不也一样，但是都有共性内容：

判断和取出。那么可以将这些共性抽取。

那么这些内部类都符合一个规则。该规则是Iterator。

如何获取集合的取出对象呢？

通过一个对外提供的方法。iterator（）；

如：Iterator it =al.iterator(); //获取迭代器，用于取出集合中的元素。

2、常见操作

2.1 hasnext( )

判断是否还有元素可以迭代

2.2 next（）

返回下一个迭代的元素

2.3 remove（）

从迭代器指向的 collection 中移除迭代器返回的最后一个元素（可选操作）。

两种应用方法,效果相同，但后一个更严谨

如：

方案一
while(it.hasNext())
{
sop(it.next());
}
方案二
for(Iterator it=al.iterator();it.hasNext(); )
{
sop(it.next());
}

三、List

1、组成

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

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

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

|--Vector：底层是数组数据结构。线程同步。被ArrayList替代了。
|--Set：元素师无序的，元素不可以重复。

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

2、常见操作

2.1 增
add(index,element);
addAll(index,Collection);
如：al.add(1,"java09");

2.2 删
remove(index);
如：al.remove(2);

2.3 改
set(index,element);
如：al.set(2,"java07");

2.4 查
get(index);
subList(from,to);
listIterator();
如：sop("get(1):"+al.get(1));

3、ListIterator

List集合特有的迭代器。ListIterator是Iterator的子接口。

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

所以，在迭代器时，只能用迭代器的方法操作元素，课时Interator方法时有限的。
只能对元素进行判断，取出，删除的操作，
如果想要其他的操作如添加，修改等，就需要使用其子接口，ListIterator。

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

4、Enumeration

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


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

5、LinkedList

LinkedList：特有方法：
5.1添加

addFirst();
addLast();

5.2 获取
getFirst();
getLast();

获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException

5.3移除
removeFirst();
removeLast();
获取元素，但是元素被删除。如果集合中没有元素，会出现NoSuchElementException

在JDK1.6中出现了替代方法。

offerFirst();
offerLast();

peekFirst();
peekLast();
获取元素，但不删除元素。如果集合中没有元素，会返回null。

pollFirst();
pollLast();
获取元素，但是元素被删除。如果集合中没有元素，会返回null。

练习1：

/*需求：使用LinkedList模拟一个堆栈或者队列数据结构。思路：1.堆栈：先进后出如同：手枪的弹夹    队列：先进先出 First in First out如同：水管  2.选用LinkedList中的getFirst()和getLast()方法  3.封装方法*/import java.util.*;class DuiLie{private LinkedList link;DuiLie(){link=new LinkedList();}public void myAdd(Object obj)//添加元素{link.addFirst(obj);}public Object myGet() //移除末尾的元素{return link.removeLast();}public boolean isNull()//判断是否为空{return link.isEmpty();}}class LinkedListDemo{public static void main(String[] args){DuiLie dl=new DuiLie();dl.myAdd("java05");dl.myAdd("java04");dl.myAdd("java03");dl.myAdd("java02");dl.myAdd("java01");while (!dl.isNull())//不为空时循环获取{sop(dl.myGet());}}public static void sop(Object obj){System.out.println(obj);}}

结果输出：

练习2：

/*需求：去除ArrayList集合中的重复元素。思路：1.定义一个ArrayList临时容器  2.创建迭代器对象  3.创建for循环判断ArrayList集合中是否有相同元素*/import java.util.*;class ArrayListDemo{public static void main(String[] args){ArrayList al=new ArrayList();//创建数组列表对象al.add("java01");//添加元素al.add("java02");al.add("java03");al.add("java01");al.add("java02");al.add("java01");sop(al);//打印未改变的数组列表al=singleElement(al);//用al装载在singleElement中改变后的alsop(al);//打印改变后的数组列表}public static ArrayList singleElement(ArrayList al){ArrayList newAl=new ArrayList();//定义一个新容器来装载Iterator it=al.iterator();//创建迭代器对象for ( ;it.hasNext() ;  )//for循环比while循环节约内存{Object obj=it.next();//创建obj来显示迭代器迭代的下一个元素if (!newAl.contains(obj))//不包含则装入临时容器{newAl.add(obj);}}return newAl;}public static void sop(Object obj)//打印函数{System.out.println(obj);}} 

结果输出：

练习3

/*需求：将自定义对象作为元素存到ArrayList集合中，并去除重复元素。比如：存人对象。同姓名同年龄，视为同一个人，为重复元素。思路：1.对人描述，将数据封装进人对象  2.定义容器，将人存入。  3.取出List集合判断元素是否相同，依据是元素的equals方法。*/import java.util.*;class Person//描述对象{private String name;private int age;Person(String name,int age){this.name=name;this.age=age;}public boolean equals(Object obj)//判断是否相同{if(!(obj instanceof Person)){return false;}Person p=(Person)obj;//向下转型System.out.println(this.name+"....."+p.name);return this.name.equals(p.name) && this.age==p.age;}public String getName()//获取名字方法{return name;}public int getAge()//获取年龄方法{return age;}}class ArrayListTest{public static void main(String[] args){ArrayList al=new ArrayList();al.add(new Person("lisi01",30));al.add(new Person("lisi02",31));al.add(new Person("lisi03",32));al.add(new Person("lisi04",33));al.add(new Person("lisi03",32));al.add(new Person("lisi06",33));al=singleElement(al);sop("remove 03:"+al.remove(new Person("lisi03",32)));Iterator it=al.iterator();for( ;it.hasNext(); ){Person p=(Person)it.next();sop(p.getName()+"::"+p.getAge());}}public static ArrayList singleElement(ArrayList al){ArrayList newAl=new ArrayList();//定义一个新容器来装载Iterator it=al.iterator();//创建迭代器对象for ( ;it.hasNext() ;  )//for循环比while循环节约内存{Object obj=it.next();//创建obj来显示迭代器迭代的下一个元素if (!newAl.contains(obj))//不包含则装入临时容器{newAl.add(obj);}}return newAl;}public static void sop(Object obj)//打印函数{System.out.println(obj);}} 

结果输出：

四、Set

1、概述

|--Set：元素师无序（存入和取出的顺序不一定一致），元素不可以重复。
|--HashSet：底层数据结构是哈希表。线程时不同步的。

HashSet是如何保证元素唯一性的呢？
是通过元素的两个方法，hashCode和equals是否为true。
如果元素的HashCode值相同，才会判断equals是否为true。
如果元素的hashcode值不同，不会调用equals。

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

|--TreeSet：可以对Set集合中的元素进行自然排序，排序按照ASCLL码表进行。

      底层数据结构是二叉树。
保证元素唯一性的依据：
compareTo方法return 0.

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

TreeSet的第二种排序方式。

当元素自身不具备比较性时，或者具备的比较性不是所需要的。

这时就需要让集合自身具备比较性。

在集合初始化时，就有了比较方式。

定义了比较器，将比较器对象作为存数传递给TreeSet集合的构造函数。

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

定义一个类，实现Comparator接口，覆盖compare方法。

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

2、HashSet

例1

/*需求：往hashset集合中存入自定义对象。姓名、年龄相同为同一个人，重复元素。*/import java.util.*;class Person{private String name;private int age;Person(String name,int age)//描述人对象{this.name=name;this.age=age;}public int hashCode()//唯一的hash值{System.out.println(this.name+"......hashCode");return name.hashCode()+age*39;}public boolean equals(Object obj)//判断是否相同{if(!(obj instanceof Person)){return false;}Person p=(Person)obj;//向下转型System.out.println(this.name+"...equals.."+p.name);return this.name.equals(p.name) && this.age==p.age;}public String getName()//获取名字函数{return name;}public int getAge()//获取年龄函数{return age;}}class HashSetDemo{public static void main(String[] args){HashSet hs=new HashSet();hs.add(new Person("lisi",12));hs.add(new Person("lisi1",13));hs.add(new Person("lisi2",14));hs.add(new Person("lisi",12));Iterator it=hs.iterator();//创建HashSet的迭代器for( ;it.hasNext(); ){Person p=(Person)it.next();sop(p.getName()+"..."+p.getAge());}}public static void sop(Object obj)//打印函数{System.out.println(obj);}}

结果输出：

3、TreeSet

第一种排序：

例2

/*需求：往TreeSet集合中存储自定义对象学生。想按照学生的年龄进行排序。思路：1.定义学生类  2.创建比较方式  3.创建TreeSet集合、迭代器，循环获取记住：排序时，当主要条件相同时，一定要判断次要条件。*/import java.util.*;class TreeSetDemo{public static void main(String[] args){TreeSet ts=new TreeSet();ts.add(new Student("lisi02",22));ts.add(new Student("lisi0007",20));ts.add(new Student("lisi09",19));ts.add(new Student("lisi01",40));Iterator it=ts.iterator();//创建TreeSet的迭代器for( ;it.hasNext(); )//创建循环获取名字，年龄{Student stu=(Student)it.next();System.out.println(stu.getName()+"....."+stu.getAge());}}} class Student implements Comparable//该接口强制让学生具备比较性。 { private String name; private int age; Student(String name,int age)//描述学生 {this.name=name;this.age=age; } public int compareTo(Object obj)//设置比较方式 {if(!(obj instanceof Student))//筛选是否符合学生的特征    {throw new RuntimeException("不是学生对象");}Student s=(Student)obj;//向下转型System.out.println(this.name+"...compareto.."+s.name);if(this.age>s.age)return 1;if (this.age==s.age)//判断主要条件{return this.name.compareTo(s.name);//判断次要条件}return -1; } public String getName() {return name; } public int getAge() {return age; } }

结果输出：

第二种排序：

例3

/*需求：往TreeSet集合中存储自定义对象学生。想按照学生的年龄进行排序。思路：1.定义学生类  2.创建比较方式  3.创建TreeSet集合、迭代器，循环获取记住：排序时，当主要条件相同时，一定要判断次要条件。*/import java.util.*;class TreeSetDemo{public static void main(String[] args){TreeSet ts=new TreeSet(new MyCompare());ts.add(new Student("lisi02",22));ts.add(new Student("lisi0007",20));ts.add(new Student("lisi09",19));ts.add(new Student("lisi01",40));Iterator it=ts.iterator();//创建TreeSet的迭代器for( ;it.hasNext(); )//创建循环获取名字，年龄{Student stu=(Student)it.next();System.out.println(stu.getName()+"....."+stu.getAge());}}} class Student implements Comparable//该接口强制让学生具备比较性。 { private String name; private int age; Student(String name,int age)//描述学生 {this.name=name;this.age=age; } public int compareTo(Object obj)//设置比较方式 {if(!(obj instanceof Student))//筛选是否符合学生的特征    {throw new RuntimeException("不是学生对象");}Student s=(Student)obj;//向下转型System.out.println(this.name+"...compareto.."+s.name);if(this.age>s.age)return 1;if (this.age==s.age)//判断主要条件{return this.name.compareTo(s.name);//判断次要条件}return -1; } public String getName() {return name; } public int getAge() {return age; } }class MyCompare implements Comparator//两种比较方式同在，优先用第二种比较方式{public int compare(Object o1,Object o2){Student s1=(Student)o1;//向下转型Student s2=(Student)o2;int num=s1.getName().compareTo(s2.getName());if (num==0){return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));/*if(s1.getAge()>s2.getAge())return 1;if(s1.getAge()==s2.getAge())return 0;return -1;*/}return num;}}

结果输出：

练习：

//需求：按照字符串长度排序import java.util.*;//导包class TreeSetDemo{public static void main(String[] args){TreeSet ts=new TreeSet(new StrLenComparator());//调用比较器的方法，也就是第二种方式ts.add("abcd");ts.add("add");ts.add("abcd");ts.add("cc");ts.add("abcdrgeg");ts.add("a");Iterator it=ts.iterator();//迭代器for ( ;it.hasNext();  )//循环输出语句{System.out.println(it.next());}}}class StrLenComparator implements Comparator{public int compare(Object o1,Object o2){String s1=(String)o1;//向下转型String s2=(String)o2;/*if(s1.length()>s2.length())//第一种写法return 1;if(s1.length()==s2.length())return 0;return -1;*/int num=new Integer(s1.length()).compareTo(new Integer(s2.length()));//第二种写法，封装numif(num==0)return s1.compareTo(s2);return num;}}

结果输出：

五、Map

1、概述

Map集合：该集合存储键值对。一对一对往里存，而且要保证键的唯一性。
1.1、添加。
put(K key,V value)
putAll(Map<? extends K,? extends V>m)

添加元素，添加元素。如果出现添加时，相同的键，那么后添加的值会覆盖原有键对应值。

并且put方法会返回被覆盖的值。

1.2、删除。
clear()
remove(Object key)

1.3、判断。
containsValue(Object value)
containsKey(Object key)
isEmpty()

1.4、获取
get(Object key)可以通过get方法的返回值来判断一个键是否存在。通过返回null来判断。
size()
value()获取map集合中所有的值

map集合的两种取出方式：
1、Set<Map.Entry<k,v>> entrySet( )：将map集合中的映射关系存入搭配䠾Set集合中，

而这个关系的数据类型就是：Map。Entry。

Map。Entry 其实Entry也是一个接口，它是接口中的一个内部接口。
2、keySet()：将map中所有的键存入到Set集合。因为set具备迭代器。

所有可以迭代方式取出所有的键，再根据get方法，获取每一个键对应的值。

Map
|--Hashtable：底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。jdk1.0效率低。

|--HashMap：底层是哈希表数据结构，允许使用null值和null键，该集合是不同步的。jdk1.2效率高。
|--TreeMap：底层是二叉树数据结构。线程不同步。可以用于给map集合中的键进行排序。

和Set很像。

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

keySet应用：

例1

import java.util.*;class MapDemo{public static void main(String[] args){Map<String,String> map=new HashMap<String,String>();map.put("01","zs1");map.put("02","zs2");//先获取map集合的所有键的Set集合，keySet（）；Set<String> keySet=map.keySet();//有了Set集合，就可以获取其迭代器。Iterator<String> it=keySet.iterator();for ( ;it.hasNext(); ){String key=it.next();//有了键可以通过map集合的get方法获取其对应的值。String value=map.get(key);System.out.println("key:"+key+",value:"+value);}}}

结果输出：

图示解析：

entrySet()应用：

例2

import java.util.*;class MapDemo{public static void main(String[] args){Map<String,String> map=new HashMap<String,String>();map.put("01","zs1");map.put("02","zs2");//将Map集合中的映射关系取出，存入到Set集合中。Set<Map.Entry<String,String>> entrySet=map.entrySet();//数据类型为Map.EntryIterator<Map.Entry<String,String>> it=entrySet.iterator();//数据类型为Map.Entryfor ( ;it.hasNext(); ){Map.Entry<String,String> me=it.next();//创建Map。Entry接口对象String key=me.getKey();String value=me.getValue();System.out.println(key+":"+value);}}}

结果输出：

图示解析：

Map练习：

/*需求：学生属性：姓名，年龄。注意：姓名和年龄相同的视为同一个学生。保证学生的唯一性。思路：1、描述学生。  2、定义map容器。将学生作为键，地址作为值，存入。  3、获取map集合中的元素。*/import java.util.*;//导包class Student implements Comparable<Student>//该接口强制让学生具备比较性{private String name;private int age;Student(String name,int age){this.name=name;this.age=age;}public int compareTo(Student s)//复写compareTo，以年龄为主，名字为辅{int num=new Integer(this.age).compareTo(new Integer(s.age));if (num==0){return this.name.compareTo(s.name);}return num;}public int hashCode()//赋予哈希值{return name.hashCode()+age*37;}public boolean equals(Object obj)//复写equals方法，判断传入的值是否具有Student特征{if(!(obj instanceof Student)){throw new ClassCastException("类型不匹配");//抛出类型转换异常}Student s=(Student)obj;//向下强制转换return this.name.equals(s.name) && this.age==s.age;}public String geetName()//获取名字方法{return name;}public int getAge()//获取年龄方法{return age;}public String toString()//复写toString，自定义输出内容{return name+":"+age;}}class StudentDemo{public static void main(String[] args){HashMap<Student,String> hm=new HashMap<Student,String>();hm.put(new Student("lisi1",21),"beijing");hm.put(new Student("lisi2",22),"shanghai");hm.put(new Student("lisi3",23),"nanjing");hm.put(new Student("lisi",24),"wuhan");//第一种取出方式 keySetSet<Student> keySet=hm.keySet();Iterator<Student> it=keySet.iterator();for ( ;it.hasNext(); ){Student stu=it.next();//等到keyString addr=hm.get(stu); //等到valueSystem.out.println(stu+":"+addr);}//第二种取出方式 entrySetSet<Map.Entry<Student,String>> entrySet=hm.entrySet();Iterator<Map.Entry<Student,String>> iter=entrySet.iterator();for( ;iter.hasNext(); ){Map.Entry<Student,String> me=iter.next();Student stu=me.getKey();String addr=me.getValue();System.out.println(stu+"............"+addr);}}}

结果输出：

TreeMap小练习1：

/*需求：对学生对象的年龄进行升序排序。因为数据是以键值对形式存在的。所以要使用可以排序的Map集合。TreeMap*/import java.util.*;//导包class Student implements Comparable<Student>//该接口强制让学生具备比较性{private String name;private int age;Student(String name,int age){this.name=name;this.age=age;}public int compareTo(Student s)//复写compareTo，以年龄为主，名字为辅{int num=new Integer(this.age).compareTo(new Integer(s.age));if (num==0){return this.name.compareTo(s.name);}return num;}public int hashCode()//赋予哈希值{return name.hashCode()+age*37;}public boolean equals(Object obj)//复写equals方法，判断传入的值是否具有Student特征{if(!(obj instanceof Student)){throw new ClassCastException("类型不匹配");//抛出类型转换异常}Student s=(Student)obj;//向下强制转换return this.name.equals(s.name) && this.age==s.age;}public String getName()//获取名字方法{return name;}public int getAge()//获取年龄方法{return age;}public String toString()//复写toString，自定义输出内容{return name+":"+age;}}class StudentDemo{public static void main(String[] args){TreeMap<Student,String> tm=new TreeMap<Student,String>(new StuNameComparator());tm.put(new Student("clisi01",23),"nanjing");tm.put(new Student("alisi05",21),"shanghia");tm.put(new Student("lisi03",26),"beijing");Set<Map.Entry<Student,String>> entrySet=tm.entrySet();Iterator<Map.Entry<Student,String>> it=entrySet.iterator();for ( ;it.hasNext(); ){Map.Entry<Student,String> me=it.next();Student stu=me.getKey();String addr=me.getValue();System.out.println(stu+"....."+addr);}}}//以名字自然顺序来排序class StuNameComparator implements Comparator<Student>//以名字为排序的比较器{public int compare(Student s1,Student s2)//复写compare方法{int num=s1.getName().compareTo(s2.getName()); //名字比较if (num==0){return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge())); //如果相等则比较年龄}return num;}}

结果输出：

TreeMap小练习2

/*需求：希望打印结果：a(1)c(2)......通过结果发现，每一个字母都有对应的次数。说明字母和次数之间都有映射关系。注意了，当发现有映射关系时，可以选择map集合。因为map集合中存放就是映射关系。什么时候使用map集合呢？当数据之间存在着映射关系时，就要先想到map集合。思路：1、将字符串转换成字符数组，因为要对每一个字母进行操作。  2、定义一个map集合，因为打印结果的字母有顺序，所以使用TreeSet集合。  3、遍历字符数组。将每一个字母作为键去查map集合。如果返回null，将该字母和1存入到map集合中。如果返回不是null，说明该字母在map集合已经存在并有对应次数。那么就获取该次数并进行自增，然后将该字母和自增后的次数存入到map集合中，覆盖调用原理键锁对应的值。  4、将map集合中的数据变成指定的字符串形式返回。*/import java.util.*;//导包class MapDemo{public static void main(String[] args){String s=charCount("abasbsbds");System.out.println(s);}public static String charCount(String str){char[] chs=str.toCharArray();//转成字符数组TreeMap<Character,Integer> tm=new TreeMap<Character,Integer>();//创建TreeMap对象int count=0;for(int x=0;x<chs.length;x++)//遍历{Integer value=tm.get(chs[x]);//获取角标if(value!=null)//下面代码的优化count=value;//不为null，则为valuecount++;//为null先自增，后赋值tm.put(chs[x],count);/*if(value==null){tm.put(chs[x],1);}else{value=value+1;tm.put(chs[x],value);}*/}System.out.println(tm);//打印没转换形式的StringBuilder sb=new StringBuilder();//定义容器装入Set<Map.Entry<Character,Integer>> entrySet=tm.entrySet();//返回Set视图Iterator<Map.Entry<Character,Integer>> it=entrySet.iterator();//创建迭代器for ( ;it.hasNext(); ){Map.Entry<Character,Integer> me=it.next();//取出下个元素Character ch=me.getKey();//获取字符串Integer value=me.getValue();//获取值sb.append(ch+"("+value+")");//装入容器}return sb.toString();//自定义输出内容}}

结果输出：

Map扩展：

/*map扩展知识。map集合被使用是因为具备映射关系。需求："yureban" "01" "zhangsan"  "yureban" "02" "lisi"  "jiuyeban" "01" "wangwu"  "jiuyeban" "02" "zhaoliu"思路：1、集合嵌套，创建大集合装预热班和就业班等小集合2、封装教室内容的取出函数3、大集合czbk的取出*/import java.util.*;//导包class MapDemo{public static void main(String[] args){HashMap<String,HashMap<String,String>> czbk=new HashMap<String,HashMap<String,String>>();//创建学校HashMap<String,String> yureban=new HashMap<String,String>();//创建班级HashMap<String,String> jiuyeban=new HashMap<String,String>();//创建班级yureban.put("01","zhangsan");//添加班级内容yureban.put("02","lisi");jiuyeban.put("01","wangwu");//添加班级内容jiuyeban.put("02","zhaoliu");czbk.put("01教室预热班",yureban);//添加学校内容czbk.put("02教室就业班",jiuyeban);//遍历czbk集合。获取所有的教室Iterator<String> it=czbk.keySet().iterator();for ( ;it.hasNext(); ){String roomName=it.next();//取出下一个班级名称HashMap<String,String> room=czbk.get(roomName);//取出对应班级名称中的内容System.out.println(roomName);//打印班级名称getStudentInfo(room);//打印班级内容}}public static void getStudentInfo(HashMap<String,String> roomMap)//教室内容取出函数{Iterator<String> it=roomMap.keySet().iterator();//定义键取出器for ( ;it.hasNext(); ){String id=it.next();//取出下一个String name=roomMap.get(id);//取出对应键的名字System.out.println(id+"...."+name);}}}

结果输出：