黑马程序员——Java基础---集合

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一、 集合框架

1.概念

集合类的由来：

对象用于封装特有数据，对象多了需要存储；如果对象的个数不确定，就使用集合容器进行存储。

集合特点：

1. 用于存储对象的容器。

2. 集合的长度是可变的。

3. 集合中不可以存储基本数据类型值。

集合容器因为内部的数据结构不同，有多种具体容器。

不断的向上抽取，就形成了集合框架。

P.S.

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

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

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

2.Collection接口

框架的顶层Collection接口：

Collection的常见方法：

1、添加：

boolean add(Object obj);

boolean addAll(Collection coll);

2、删除：

boolean remove(Object obj);

boolean removeAll(Collection coll);

void clear();

3、判断：

boolean contains(Object obj);

boolean containsAll(Collection coll);

boolean isEmpty();判断集合中是否有元素。

4、获取：

int size();

Iterator iterator();

取出元素的方式：迭代器。

该对象必须依赖于具体容器，因为每一个容器的数据结构都不同，所以该迭代器对象是在容器中进行内部实现的，也就是iterator方法在每个容器中的实现方式是不同的。

对于使用容器者而言，具体的实现不重要，只要通过容器获取到该实现的迭代器的对象即可，也就是iterator方法。

Iterator接口就是对所有的Collection容器进行元素取出的公共接口。

. 集合类的itreator()方法，返回的是一个Iterator接口，这个接口有三个方法。
Iterator it= c.iterator();

it.next()获取元素，返回值是Object类型，所以记得类型转换。
it.hasNext()
判断是否还有下一个元素
it.remove
从迭代器指向的 collection
中移除迭代器返回的最后一个元素。

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

public class IteratorDemo{
public static void main(String[] args){
Collection coll = new ArrayList();

coll.add( "abc1");
coll.add( "abc2");
coll.add( "abc3");
coll.add( "abc4");

System.out.println(coll);

//使用了Collection中的iterator()方法。调用集合中的迭代器方法，是为了获取集合中的迭代器对象。
Iterator it1 = coll.iterator();

while(it1.hasNext()){
System.out.println(it1.next());
}

//for循环结束，Iterator变量内存释放，更高效
for(Iterator it2 = coll.iterator();it2.hasNext();){
System.out.println(it2.next());
}
}
}

5、其他：

boolean retainAll(Collection coll);取交集

Object toArray();将集合转成数组

/**
* 需求：演示collection集合通用方法
*
* @author jinlong
* */
package com.blog.part4.集合;

import java.util.*;

public class CollectionDemo
{

public static void main(String[] args)
{
//
Collection coll=new ArrayList();
show(coll);
sop("-------------------------------------------");

Collection c1=new ArrayList();
Collection c2=new ArrayList();
show(c1,c2);

}
public static void show(Collection coll)
{
//1、添加元素add
coll.add("abc");
coll.add("bcd");
coll.add("efg");
sop(coll);
//2、删除元素remove
coll.remove("abc");
sop(coll);
//3、清空集合
coll.clear();
sop(coll);
}

public static void show(Collection coll1,Collection coll2)
{
//给c1添加元素
coll1.add("abc");
coll1.add("bcd");
coll1.add("cde");
coll1.add("def");
//给c2添加元素
coll2.add("abc");
coll2.add("xyz");
coll2.add("ghf");
sop("coll1::"+coll1);
sop("coll2::"+coll2);
//取交集
boolean b2=coll1.retainAll(coll2);
sop("retainAll::"+coll1);
//演示addAll
coll1.addAll(coll2);
sop("addAll::"+coll1);
//演示removeAll
//从coll1集合中删除与coll2相同的元素
boolean b=coll1.removeAll(coll2);
sop("removeAll::"+coll1);
//演示containAll
boolean b1=coll1.containsAll(coll2);
sop("containAll"+coll1);

}
//打印
public static void sop(Object obj)
{
System.out.println(obj);
}

}

3.List类

Collection：常用子类

|--List：有序（存入和取出的顺序一致），元素都有索引（角标），允许重复元素。

|--Set：元素不能重复，无序。

这里我们先介绍List类及其子类

1.List子类共性

有一个共性特点就是都可以操作角标。

1、添加

void add(index,element);

void addAll(index,collection);

2、删除

Object remove(index);

3、修改

Object set(index,element);

4、获取：

Object get(index);

int indexOf(object);

int lastIndexOf(object);

List subList(from,to);

2.List子类共性

三个常用子类
1.ArrayList:底层数据结构使用的是数组结构。查询速度很快，但是增删较慢。
百分之五十延长。
2.LinkList：
底层使用的是链表数据结构。查询速度稍慢，增删的速度很快。
3.Vector :
底层是数组结构。1.0版本的时候，当时没有集合框架。线程是是同步的。百分之百延长。
List集合判断元素是否相同，依据的是元素的equals方法，可以重写定义自己需要的equals。这个是底层调用的。

3.LinkedList

1.链表结构特有方法。
addFirst( ); addLast( );
getFirst( ); getLast( );
获取元素但不删除元素。
removeFirst( );removeLast( );
获取元素，但元素会被删除。
2.在JDK1.6出现了替代方法：
offerFirst();offerLast(); peekFirest(); peekLast();

pollFirst(); pollLast();

1和2的区别在于，获取元素如果集合中没有元素，1会返回NoSuchElementException异常,2会返回null；

经典示例：

/**
* 需求：请使用LinkedList来模拟一个堆栈数据结构。
* 思路：这里我们要先要确定队列的特点
*           堆栈：如同一个杯子：先进后出
*           队列：如同一个水管：先进先出
*           所以模拟队列就是模拟先进先出的特点
*
*
* @author jinlong
* */
package com.blog.part4.集合;
import java.util.LinkedList;
//定义一个队列类
class DuiLie
{
//定义私有变量LinkedList
private LinkedList link;
//构造函数初始化私有变量
public DuiLie()
{
link = new LinkedList();
}

//队列的添加元素的功能。
public void myAdd(Object obj)
{
//用addLast从后往前添加元素
link.addLast(obj);
}

//获取元素
public Object myGet()
{
//removeFirst();从前往后读
return link.removeFirst();
}
//判断是否还有元素
public boolean isNull()
{
return link.isEmpty();
}
}

public class DuiLieDemo
{
public static void main(String[] args)
{
DuiLie dl = new DuiLie();

dl.myAdd( "abc1");
dl.myAdd( "abc2");
dl.myAdd( "abc3");
dl.myAdd( "abc4");
//循环打印
while(!dl.isNull())
{
System.out.println(dl.myGet());
}
}
}

4.Vector

Vector有一个自己特殊的取出方式，枚举。

其实枚举和迭代是一样的。因为枚举的名称以及方法的名称都过长。所以被迭代器取代了。

5.ArrayList

/**
* 需求：将一个自定义对象存储到ArrayList集合中去，并去除重复元素。
* 思路:每个元素都是一个对象。
* @author jinlong
* */
package com.blog.part4.集合;
import java.util.*;
//定义Person类
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;
}

//重写equals方法
public boolean equals(Object obj)
{
//判断是否是同一个对象。
if(!(obj instanceof Person))
return false;
//判断是否符合需求：姓名和年龄相同及作为相同元素
Person p=(Person)obj;
return this.name.equals(p.name)&&this.age==p.age;

}
}

class ArrayListDemo

运算结果：

4.Set类

Set:元素不可以重复，是无序。

Set接口中的方法和Collection一致。

|--HashSet：内部数据结构是哈希表，是不同步的。

|--TreeSet：可以对Set集合中的元素进行排序，是不同步的。

1.HashSet类

保证元素的唯一性原理：hashCode
返回值相同，并且equals方法return
true，那么两个元素相同。

/**
* 需求：像hashSet容器中添加自定义对象，并且年龄和姓名相同作为重复元素。
* 思路：因为hashSet中不能存在相同元素，那么添加自定义对象元素时，也要自定义判断相同元素的方法
*           HashSet中判断两个元素是否相同，首先是判断两元素HashCode值，如果相同再判断equals返回是否为true
* @author jinlong
* */
package com.blog.part4.集合;
import java.util.*;
//建立人这个对象类
class Person
{
//定义基本属性
private String name;
private int age;
//构造函数
Person(String name,int age)
{
this.name=name;
this.age=age;
}
//对外接口
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
//重写equals方法。
public boolean equals(Object obj)
{
//看传入的是不是Person对象的一个实例
if(!(obj instanceof Person))
return false;
//如果是Person的实例，才能转型
Person p= (Person)obj;
//然后定义自己的判断元素相同的判断方法。如果姓名年龄都相同返回真。
return p.name.equals(this.name)&&this.age==p.age;
}
//自定义hashcode算法方法
public int hashCode()
{

return this.name.hashCode()+37*age;
}

}
class  HashSetDemo
{
public static void main(String[] args)
{
//定义一个HashSet容器
HashSet ts=new HashSet();
//添加元素
ts.add(new Person("zhangsan",20));
ts.add(new Person("zhangsi",20));
ts.add(new Person("zhangsan",20));
ts.add(new Person("lisi",20));
ts.add(new Person("wangwu",20));
ts.add(new Person("lisi",20));
ts.add(new Person("wangwu",22));

//定义迭代器
Iterator it= ts.iterator();
//打印
while(it.hasNext())
{
Person p= (Person)it.next();
sop("name:"+p.getName()+":::"+"age:"+p.getAge());
}
}
//打印方法
public static void sop(Object obj)
{
System.out.println(obj);
}
}

运算结果：



jdk1.4后新添加了一个类，LinkHashSet，当无序HashSet集合想变有序时，可以使用。

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

public class LinkedHashSetDemo{
public static void main(String[] args){
HashSet hs = new LinkedHashSet();

hs.add( "hahaa");
hs.add( "hehe");
hs.add( "heihei");
hs.add( "xixii");

Iterator it = hs.iterator();

while(it.hasNext()){
System.out.println(it.next());
}
}
}

2.TreeSet类

TreeSet判断元素唯一性的方式：就是根据比较方法compareTo的返回结果是否是0，是0，就是相同元素，不存。

1、特点

a.底层的数据结构为二叉树结构（红黑树结构）

b.可对Set集合中的元素进行排序，是因为：TreeSet类实现了Comparable接口，该接口强制让增加到集合中的对象进行了比较，需要复写 compareTo方法，才能让对象按指定需求（如人的年龄大小比较等）进行排序，并加入集合。

java中的很多类都具备比较性，其实就是实现了Comparable接口。

注意：排序时，当主要条件相同时，按次要条件排序。

c、保证数据的唯一性的依据：通过compareTo方法的返回值，是正整数、负整数或零，则两个对象较大、较小或相同。相等时则不会存入。

1.自然排序

/**
* 需求：像hashset容器中添加自定义对象，并且年龄和姓名相同作为重复元素。
* 思路:   根据重复元素条件重写compareTo方法
* @author jinlong
* */
package com.blog.part4.集合;
import java.util.*;
//建立人这个对象类
//通过接口让对象具有比较性
class Person implements Comparable
{
//定义基本属性
private String name;
private int age;
//构造函数
Person(String name,int age)
{
this.name=name;
this.age=age;
}
//对外接口
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
//重写接口方法
public int compareTo(Object obj)
{
if(!(obj instanceof Person))
throw new RuntimeException("传入对象不是人");
//转型
Person p= (Person)obj;
//主要比较条件age
if(this.age>p.age)
return 1;
if(this.age==p.age)
{
//这里的conmpareTo方法，是String类本身就实现了comparable接口所具有的方法。
//这里定义了次要比较条件name
return this.name.compareTo(p.name);
}
return -1;

}
}

class  TreeSetDemo
{
public static void main(String[] args)
{
//定义一个HashSet容器
TreeSet ts=new TreeSet();
//添加元素
ts.add(new Person("zhangsan",20));
ts.add(new Person("zhangsi",20));
ts.add(new Person("zhangsan",20));
ts.add(new Person("lisi",20));
ts.add(new Person("wangwu",20));
ts.add(new Person("lisi",20));
ts.add(new Person("wangwu",22));

//定义迭代器
Iterator it= ts.iterator();
//打印
while(it.hasNext())
{
Person p= (Person)it.next();
sop("name:"+p.getName()+":::"+"age:"+p.getAge());
}
}

public static void sop(Object obj)
{
System.out.println(obj);
}
}

运行结果：

2.实现方法排序

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

在集合初始化时，就有了比较方式。定义一个比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。

比较器构造方式：定义一个类，实现Comparator接口，覆盖compare方法。

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

/**
* 需求：像hashset容器中添加自定义对象，按姓名排序。
* 思路:   实现接口comparator，重写compare方法
*            重写compare的时候要明确主要比较条件和次要比较条件
*
* @author jinlong
* */
package com.blog.part4.集合;
import java.util.*;
//建立人这个对象类
class Person
{
//定义基本属性
private String name;
private int age;
//构造函数
Person(String name,int age)
{
this.name=name;
this.age=age;
}
//对外接口
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
//自定义比较方法，实现Comparator
class Mycomp implements Comparator
{
//重写compare方法
public int compare(Object obj1,Object obj2)
{
if(obj1 instanceof Person&&obj2 instanceof Person)
{
Person p1=(Person)obj1;
Person p2=(Person)obj2;
//主要判断条件
int num= p1.getName().compareTo(p2.getName());
if(num==0)
{
//次要判断条件
return new Integer(p1.getAge()).compareTo(new Integer(p2.getAge()));
}
return num;

}
return 0;

}
}

class  TreeSetDemo
{
public static void main(String[] args)
{
//定义一个HashSet容器
TreeSet ts=new TreeSet(new Mycomp());
//添加元素
ts.add(new Person("zhangsan",20));
ts.add(new Person("zhangsi",20));
ts.add(new Person("zhangsan",22));
ts.add(new Person("lisi",20));
ts.add(new Person("wangwu",20));
ts.add(new Person("lisi",20));
ts.add(new Person("wangwu",22));

//定义迭代器
Iterator it= ts.iterator();
//打印
while(it.hasNext())
{
Person p= (Person)it.next();
sop("name:"+p.getName()+":::"+"age:"+p.getAge());
}
}

public static void sop(Object obj)
{
System.out.println(obj);
}
}

运行结果：



示例二;

/**
* 需求：根据元素的字符串长度作为排序条件给TreeSet集合中元素排序
* 思路：要自定义条件，所以用Comparetor
*          元素的长度作为主要排序条件
* @author jinlong
* */
package com.blog.part4.集合;
import java.util.*;
class TreeSetLengthDemo
{
public static void main(String[] args)
{
TreeSet ts=new TreeSet(new Mycomp1());
ts.add("beijinghuanying");
ts.add("beijinghuanyingni");
ts.add("beijinghuan");
ts.add("hei");
ts.add("heilong");
ts.add("beijing");
ts.add("bei");

Iterator it=ts.iterator();
while(it.hasNext())
{
sop(it.next());
}

}

public static void sop(Object obj)
{
System.out.println(obj);
}
}

class Mycomp1 implements Comparator
{
public int compare(Object o1,Object o2)
{
String s1= (String)o1;
String s2= (String)o2;
//主要判断条件
int num=new Integer(s1.length()).compareTo(new Integer(s2.length()));

//次要判断条件
if(num==0)
return s1.compareTo(s2);
return num;
}
}

5.Map集合

1.概述

1、简述：

Map<K,V>集合是一个接口，和List集合及Set集合不同的是，它是双列集合，并且可以给对象加上名字，即键（Key）

2、特点：

1）该集合存储键值对，一对一对往里存

2）要保证键的唯一性。

2.Map集合的子类

Map

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

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

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

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

3.Map集合的常用方法

1、添加

Vput(K key,V value);//添加元素，如果出现添加时，相同的键，那么后添加的值会覆盖原有键对应值，并put方法会返回被覆盖的值。

voidputAll(Map <? extends K,? extends V> m);//添加一个集合

2、删除

clear();//清空

Vremove(Object key);//删除指定键值对

3、判断

containsKey(Objectkey);//判断键是否存在

containsValue(Objectvalue)//判断值是否存在

isEmpty();//判断是否为空

4、获取

Vget(Object key);//通过键获取对应的值

size();//获取集合的长度

Collection<V>value();//获取Map集合中所以得值，返回一个Collection集合

还有两个取出方法，接下来会逐个讲解：

Set<Map.Entry<K,V>>entrySet();

Set<K> keySet();

注：HashMap集合可以通过get()方法的返回值来判断一个键是否存在，通过返回null来判断。

4.Map集合的两种取出方式

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

1. Set<K> keySet()：将Map中所以的键存入到Set集合。因为Set具备迭代器。所以可以通过迭代方式取出所以键的值，再通过get方法。获取 每一个键对应的值。

/*
每一个学生都有对应的归属地。
学生Student，地址String。
学生属性：姓名，年龄。
注意：姓名和年龄相同的视为同一个学生。
保证学生的唯一性。

思路：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 String getName()
{
return name;
}

public int getAge()
{
return age;
}

//复写hashCode
public int hashCode()
{
return name.hashCode()+age*33;
}
//复写equals，比较对象内容
public boolean equals(Object obj)
{
if(!(obj instanceof Student))
throw new ClassCastException("类型不匹配");
Student s=(Student)obj;
return this.name.equals(s.name)&&this.age==s.age;
}

//复写compareTo,以年龄为主
public int compareTo(Student c)
{
int num=new Integer(this.age).compareTo(new Integer(c.age));
if(num==0)
{
return this.name.compareTo(c.name);
}
return num;
}

//复写toString，自定义输出内容
public String toString()
{
return name+"..."+age;
}

}
class  HashMapTest
{
public static void main(String[] args)
{
HashMap<Student,String > hm=new HashMap<Student,String >();
hm.put(new Student("zhangsan",12),"beijing");
hm.put(new Student("zhangsan",32),"sahnghai");
hm.put(new Student("zhangsan",22),"changsha");
hm.put(new Student("zhangsan",62),"USA");
hm.put(new Student("zhangsan",12),"tianjing");

keyset(hm);
}

//keySet取出方式
public static void keyset(HashMap<Student,String> hm)
{
Iterator<Student> it=hm.keySet().iterator();

while(it.hasNext())
{
Student s=it.next();
String addr=hm.get(s);
System.out.println(s+":"+addr);
}
}
}

2.Set<Map.Entry<K,V>> entrySet()：将Map集合中的映射关系存入到Set集合中，而这个关系的数据类型就是：Map.Entry

Map是一个接口，其实，Entry也是一个接口，它是Map的子接口中的一个内部接口，就相当于是类中有内部类一样。为何要定义在其内部呢？

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

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

interface Map
{
public static interface Entry
{
public abstract Object getKey();
public abstract Object getValue();
}
}

示例:

class  HashMapTest
{
public static void main(String[] args)
{
HashMap<Student,String > hm=new HashMap<Student,String >();
hm.put(new Student("zhangsan",12),"beijing");
hm.put(new Student("zhangsan",32),"sahnghai");
hm.put(new Student("zhangsan",22),"changsha");
hm.put(new Student("zhangsan",62),"USA");
hm.put(new Student("zhangsan",12),"tianjing");

entryset(hm);
}
//entrySet取出方式
public static void entryset(HashMap<Student,String> hm)
{
Iterator<Map.Entry<Student,String>> it=hm.entrySet().iterator();

while(it.hasNext())
{
Map.Entry<Student,String> me=it.next();
Student s=me.getKey();
String addr=me.getValue();
System.out.println(s+":::"+addr);
}
}
}

5.Map集合的应用及扩展

/*
需求：获取该字符串中的字母出现的次数，如："sjokafjoilnvoaxllvkasjdfns"；希望打印的结果是：a(3)c(0).....
思路：    1、将字符串转换为字符数组
2、定义一个TreeMap集合，用于存储字母和字母出现的次数
3、用数组去遍历集合，如果集合中有该字母则次数加1，如果集合中没有则存入
4、将TreeMap集合中的元素转换为字符串
*/
package TreeMapTest;
import java.util.*;

class CharCount
{
public static void main(String[] args)
{
String s="sdfgzxcvasdfxcvdf";
System.out.println("s中各字母出现的次数："+charCount(s));
}

//定义一个方法获取字符串中字母出现的次数
public static String charCount(String str)
{
char[] cha=str.toCharArray();//转换为字符数组

//定义一个TreeMap集合，因为TreeMap集合会给键自动排序
TreeMap<Character,Integer> tm=new TreeMap<Character,Integer>();

int count=0;//定义计数变量
for (int x=0;x<cha.length ;x++ )
{
if(!(cha[x]>='a'&&cha[x]<='z'||cha[x]>='A'&&cha[x]<='Z'))
continue;//如果字符串中非字母，则不计数
Integer value=tm.get(cha[x]);//获取集合中的值
if(value!=null)//如果集合中没有该字母，则存入
count=value;
count++;
tm.put(cha[x],count);//存入键值对
count=0;//复位计数变量
}

StringBuilder sb=new StringBuilder();//定义一个容器

//遍历集合，取出并以题目格式存入容器中
for(Iterator<Character> it=tm.keySet().iterator();it.hasNext();)
{
Character ch=it.next();
Integer value=tm.get(ch);
sb.append(ch+"("+value+")");
}
return sb.toString();//返回字符串
}
}<strong>
</strong>

/*
map扩展知识。
map集合被使用是因为具备映射关系。
以下是班级对应学生，而学生中学号对应着姓名的映射关系：
"yureban"   Student("01" "zhangsan");

"yureban" Student("02" "lisi");

"jiuyeban" "01" "wangwu";
"jiuyeban" "02" "zhaoliu";

就如同一个学校有多个教室。每一个教室都有名称。
*/
import java.util.*;

class  MapExpandKnow
{
public static void main(String[] args)
{
//预热班集合
HashMap<String,String> yureban=new HashMap<String,String>();
//就业班集合
HashMap<String,String> jiuyeban=new HashMap<String,String>();
//学校集合
HashMap<String,HashMap<String,String>> czbk=new HashMap<String,HashMap<String,String>>();

//学校中班级集合和名称的映射
czbk.put("yureban",yureban);
czbk.put("jiuyueban",jiuyeban);

//预热班级中学号与姓名的映射
yureban.put("01","zhangsan");
yureban.put("02","lisi");

//就业班级中学号与姓名的映射
jiuyeban.put("01","wangwu");
jiuyeban.put("02","zhouqi");

//直接显示全部学生信息
getAllStudentInfo(czbk);

}
//定义一个方法获取全部学生信息，包括在哪个班级，叫什么名字，学号多少
public static void getAllStudentInfo(HashMap<String ,HashMap<String,String>> hm)
{
for (Iterator<String> it=hm.keySet().iterator();it.hasNext() ; )//用keySet取出方式
{
String s= it.next();//班级名称
System.out.println(s+":");
HashMap<String,String> stu=hm.get(s);//班级集合

getStudentInfo(stu);
}
}

//获取班级中学生的信息，包括姓名和学号
public static void getStudentInfo(HashMap<String,String> hm)
{
for (Iterator<String> it=hm.keySet().iterator();it.hasNext() ; )
{
String key=it.next();//学号
String value=hm.get(key);//姓名
System.out.println(key+"..."+value);
}
}
}