------
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容器进行元素取出的公共接口。
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：有序（存入和取出的顺序一致），元素都有索引（角标），允许重复元素。
|--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);
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:元素不可以重复，是无序。
c、保证数据的唯一性的依据：通过compareTo方法的返回值，是正整数、负整数或零，则两个对象较大、较小或相同。相等时则不会存入。
Set接口中的方法和Collection一致。
|--HashSet：内部数据结构是哈希表，是不同步的。
|--TreeSet：可以对Set集合中的元素进行排序，是不同步的。
|--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接口。
注意：排序时，当主要条件相同时，按次要条件排序。
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);
}
}
}
扫一扫
693
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
