黑马程序员--------java Collection、Map集合 、泛型

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------

一、Collection 集合

1、Collection集合结构分布

     |——List：元素是有序的，元素可以重复

        |——ArrayList：底层使用的是数组数据结构。特点：查询速度快，增删稍慢

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

        |——Vcter   ：底层是数组数据结构。被ArrayList取代

     |——Set：元素是无序的，元素不可以重复

        |——HashSet：底层数据结构是哈希表

        |——TreeSet：底层数据结构是二叉树

2、 共性方法：集合中存储的都是对象的引用（地址）

1，添加：

    add(object)：添加一个元素

    addAll(Collection) ：添加一个集合中的所有元素。

2，删除：

    clear()：将集合中的元素全删除，清空集合。

    remove(obj) ：删除集合中指定的对象。

    removeAll(collection) ：删除部分元素。部分元素和传入Collection一致。

3，判断：

    boolean contains(obj) ：集合中是否包含指定元素 。

    boolean containsAll(Collection) ：集合中是否包含指定的多个元素。

    boolean isEmpty()：集合中是否有元素。

4，获取：

    int size()：集合中有几个元素。

5，取交集：

    boolean retainAll(Collection) ：对当前集合中保留和指定集合中的相同的元素。如果两个集合元素相同，返回flase；如果retainAll修改了当前集合，返回true。

6，获取集合中所有元素：

    迭代器：集合取出元素的方式Iterator it = 集合对象.iterator()

    方式1：Iterator it = coll.iterator();

           while(it.hasNext()){

              System.out.println(it.next());

          }

    方式2：for(Iterator it =coll.iterator();it.hasNext(); ){

            System.out.println(it.next());

          }

    方式2要比方式1好，循环结束后会自动释放内存

7，将集合变成数组：

    toArray();

List集合

1、结构：

List：元素是有序的，元素可以重复

        |——ArrayList：底层使用的是数组数据结构。特点：查询速度快，增删稍慢

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

        |——Vcter   ：底层是数组数据结构。被ArrayList取代

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

  *增：add(index,element) 

      addAll(index,Collection)

  *删：remove(index)

4000

  *改：set(index,element)

  *查：get(index)

      subList(from,to)

      listIterator()

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

    ListIterator it = 集合对象.listIterator()

    在迭代时，不可以通过集合对象的方法操作集合中的元素，因为会发生ConcurrentModificationException异常。所以在迭代时，只能使用迭代器的方法操作元素，可是Iterator方法有限，只能对元素进行判断、去除、删除操作。如果想要其他的操作，如添加、修改等，这时就需要使用其子接口——ListIterator，该接口只能通过List集合的listTiterator方法获取。

4、Vector中的枚举

  1）枚举就是Vector特有的元素取出方式（迭代器），

  2）枚举和迭代是一样的。因为枚举的名称和方法都和过长，被迭代器取代了

     Enumeration e = Vector.elements();

     while(e.hasMoreElements())

     {   e.nextElement();  }取出下一个元素

5、LinkedList特有方法：

   addFirst();//从开始处添加

   addLast();//从结尾处添加

   getFirst();

   getLast()

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

   removeFirst();

   removeLast();

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

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

  offerFirst()  //替代add

  offerLast()

  peekFirst()  //替代get

  peekLast()

获取元素，但不删除元素，如果集合中没有元素，会返回null

  pollFirst(); //替代remove

  pollLast();

获取元素，删除元素，如果集合中没有元素，会返回null

练习1:

/*
模拟LinkdeList 堆栈和队列
堆栈：先进后出，如同一个杯子
队列：先进先出，如同一个水管
思路：1、在自定义类中来new LinkedList的对象
2、定义一个元素添加的方法
3、定义元素取出方法
4、定义判断元素有无的方法
5、建立类的对象，调用这些方法
*/
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();//想改为堆栈值需将removeLast改为removeFirst
}
public boolean isNull()
{
return link.isEmpty();
}
}
class LinkedListTest
{
public static void main(String[] args)
{
DuiLie dl = new DuiLie();
dl.myAdd("java01");//调用方法来给集合添加元素
dl.myAdd("java02");
dl.myAdd("java03");
dl.myAdd("java04");
while(!dl.isNull())//调用判断方法，判断元素是否为空
{
System.out.println(dl.myGet());
}
}
}练习2：

/*
对人进行判断，同姓名，同年龄视为同一个人 自定义类作为集合参数

ArrayList集合是通过contains方法来自动调用底层equals方法的，ArrayList保证
元素的唯一性是调用元素的equals方法
*/
import java.util.*;
class Person
{
private String name;
private int age;
Person(String name,int age)
{
this.name=name;
this.age=age;
}
public String toString()
{
return name+"..."+age;
}
public boolean equals(Object obj)// 这里的参数类型必须是Object ，必须要强转
{
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;
}
}
class ArrayListTest22
{
public static void fuc(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
ArrayList<Person> al = new ArrayList<Person>();
al.add(new Person("zhangsan",20));
al.add(new Person("lisi",22));
al.add(new Person("wangwu",10));
al.add(new Person("lisi",22));
fuc(method(al));
}
public static ArrayList method(ArrayList<Person> al)
{
ArrayList<Person> al1 =new ArrayList<Person>();
//对集合进行迭代，使用for循环完后悔自动释放内存，以后都使用for循环来操作
for(Iterator<Person> it = al.iterator();it.hasNext();)
{
Person p = it.next();
if(!(al1.contains(p)))
{
al1.add(p);
}
}
return al1;
}

}

Set集合

1、结构

|——Set：元素是无序的，元素不可以重复

        |——HashSet：底层数据结构是哈希表

        |——TreeSet：底层数据结构是二叉树

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

3、HashSet是如何保证元素的唯一性的： 是同元素的两个方法，hashCode和equals来完成，如果元素的hashCode值相同，才会判断equals是否为true；如果元素的hashCode值不同，不会调用equals

4、对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashCode和equals方法

TreeSet：

1、可以对Set集合中的元素进行自然顺序的排序

2、排序时，当主要条件相同时一定要判断一下次要条件

3、保证元素唯一性的方法是compareTo方法return 0

4、TreeSet有两种排序方式

  1）让元素自身具备比较性，元素需要实现comparable接口，覆盖compareTo方法，这种方式也称为元素的自然顺序

  2）当元素自身不具备比较性时，或者具备的比较性不是所需要的，这时就需要让集合自身具备比较性。定义一个类，实现Comparator接口，覆盖compare方法

自定义对象自身总结：

1、ArrayList集合在比较元素对象是否相同时，是通过contains方法自动调用复写的equals方法来判断对象的内容是否相同

2、HashSet集合在进行进迭代器操作时，在集合的每个元素上都会调用hashCode
方法，并合计结果，如果哈希值相同，会自动调用复写的equals方法来判断对象内容是否相同，从而来保证自定义对象的唯一性

3、TreeSet集合是用来给对象排序的

   1）第一种是让元素自身具备比较性，即让元素类实现Comparable接口，并复写conpareTo方法

   2）第二中是让集合具备比较性（比较器），定义一个类实现Comparator接口，复写compare方法

练习1：
<span style="color:#333333;">/*
判断同姓名，同年龄视为同一个人
</span><span style="color:#ff6666;">set集合元素是无序的，元素不可以重复</span><span style="color:#333333;">
对 set 进行迭代，在 set 的每个元素上调用元素自身的 hashCode 方法，并合计结果，如果哈希值相同，会调用底层的equals方法来保证元素的唯一性。而ArrayList是在contains（）上调用的equals方法来实现自定义元素的唯一
*/
import java.util.*;
class Person
{
private String name;
private int age;
Person(String name,int age)
{
this.name=name;
this.age = age;
}
public String toString()
{
return name+".."+age;
}
public int hashCode()//复写Object的hashCode方法
{
System.out.println(name+"........."+age);//打印比较过程
return name.hashCode()+age*20;
}
public boolean equals(Object obj)//复写Object的equals方法
{
if(!(obj instanceof Person))
throw new RuntimeException("比较类型错误");
Person p = (Person)obj;
System.out.println(this.name+".........."+p.name);
return this.name.equals(p.name)&&this.age==p.age;
}
}
class HashSettest1
{
public static void fuc(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
HashSet<Person> has = new HashSet<Person>();
has.add(new Person("zhangsan",22));
has.add(new Person("lisi",20));
has.add(new Person("wangwu",12));
has.add(new Person("lisi",20));
for (Iterator<Person> it = has.iterator(); it.hasNext(); )
{
Person p = it.next();
fuc(p.toString());
}
}
}
</span>练习2：TreeSet
/*
<span style="color:#ff0000;">让元素具备比较性 。让元素实现Comparable，复写compareTo方法</span>

优先按照年龄来排序，如果年龄相同再按照名字的自然顺序排列，名字和年龄相同视为同一个人
*/
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 toString()
{
return name+"."+age;
}
public int compareTo(Object obj)//复写Comparable的compareTo方法
{
if(!(obj instanceof Person))
throw new RuntimeException("比较参数错误");
Person p = (Person)obj;
System.out.println(this.name+"."+this.age+"....."+p.name+"."+p.age);
if(this.age>p.age)
return 1;
if(this.age==p.age)
return this.name.compareTo(p.name);//年龄相同按自然顺序比较
else
return -1;
}
}
class TreeSetTest11
{
public static void fuc(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
TreeSet ts = new TreeSet();
ts.add(new Person("zhangsan",22));
ts.add(new Person("zhangsan",20));
ts.add(new Person("lisi",22));
ts.add(new Person("lisi",22));
for (Iterator it = ts.iterator();it.hasNext() ; )
{
Object obj = it.next();
Person p = (Person)obj;
fuc(p.toString());
}
}
}
练习3：TreeSet

/*
TreeSet自然排序
<span style="color:#ff0000;">让集合自身具备比较性，定义比较器类实现Comparator接口</span>
优先按照年龄来排序，如果年龄相同再按照名字的自然顺序排列，名字和年龄相同视为同一个人
*/
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;
}
public String toString()
{
return name+".."+age;
}
}
class myCompare implements Comparator<Person> //加上泛型限定后就不用再进行强转
{
public int compare(Person p1,Person p2)
{
/*if(!((o1 instanceof Person)&&(o2 instanceof Person)))
throw new RuntimeException("异常");
Person p1 = (Person)o1;
Person p2 = (Person)o2;*/
if(p1.getAge()>p2.getAge())
return 1;
if(p1.getAge()==p2.getAge())
return p1.getName().compareTo(p2.getName());
else
return -1;
}
}
class TreeSetTest22
{

public static void main(String[] args)
{
TreeSet<Person> ts = new TreeSet<Person>(new myCompare());
ts.add(new Person("zhangsan",22));
ts.add(new Person("lisi",22));
ts.add(new Person("zhangsan",20));
ts.add(new Person("lisi",22));
for (Iterator<Person> it =ts.iterator();it.hasNext() ; )
{
//Object obj = it.next();
//Person p =(Person)obj;
Person p = it.next();
System.out.println(p.toString());
}
}
}

泛型

一、概述

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

2、好处：

  1)将运行时期出现的问题ClassCastException转移到了编译时期，方便程序员解决问题,让运行时期问题减少

  2）避免了强制转换的麻烦

3、泛型的格式：通过<>来定义要操作

4、什么时候使用泛型？

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

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

二泛型类

1、当类中要操作的引用数据类型不确定时，早期用Object

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

3、为了让不同的方法可以操作不同类型，而类型还不确定，那么可以将泛型定义在方法上

4、特殊之处：静态方法不可以访问类上定义的泛型，如果静态方法操作的引用数据类型不确定，可以将泛型定义在方法上

5、来中的方法可以与类定义不同的泛型。方法上泛型符号一般写在返回值类型的前一段

/*
class Demo<T> //泛型类
{
public void show(T t)
{
System.out.println(t);
}
public void print(T t)
{
System.out.println(t);
}
}
*/
class Demo<T>//泛型类定义
{
public void show( T t)
{
System.out.println(t);
}
public <A> void print(A a)//泛型方法，使用自身的泛型而不使用类上定义的泛型
{
System.out.println(a);
}
public static <M> void method(M m)//静态方法只能自身定义泛型
{
System.out.println(m);
}
}
class GenericDemo3
{
public static void main(String[] args)
{
Demo<String> d = new Demo<String>();
d.show("haha");//使用跟类中泛型一致的数据类型
d.print(5);
d.method("hehe");
/*泛型类
Demo<String> d = new Demo<String>();
d.show("hah");
d.print("hehe");
Demo<Integer> d1 = new Demo<Integer>();
d1.show(5);
*/
}
}

泛型练习1：

/*
泛型的上下限定
一般在迭代是使用上限定 ? extends Person
一般在比较器上传参数是直接写他们的父类例如：Person 即可 （? super Person）
*/
import java.util.*;
class Person{
private String name;
Person(String name){
this.name = name;
}
public String getName(){
return name;
}
}
class Student extends Person{
private String name;
Student(String name){
super(name);
}
}
class Woker extends Person{
private String name;
Woker(String name){
super(name);
}
}
class MyCompare implements Comparator<Person>//接收Person和Person子类，方法里不需要进行强转
{
public int compare(Person p1,Person p2){
return p1.getName().compareTo(p2.getName());
}
}
class GenericTest22 {
public static void main(String[] args) {
TreeSet<Student> ts = new TreeSet<Student>(new MyCompare());
TreeSet<Woker> st = new TreeSet<Woker>(new MyCompare());//让集合具备比较性
ts.add(new Student("abc-02"));
ts.add(new Student("abc-03"));
ts.add(new Student("abc-01"));
st.add(new Woker("abc-022"));
st.add(new Woker("abc-033"));
st.add(new Woker("abc-011"));
method(ts);
method(st);
}
public static void method(TreeSet<? extends Person> x)//上限定可以接收Person和Person的子类
{
for(Iterator<? extends Person> it = x.iterator();it.hasNext();){
System.out.println(it.next().getName());
}
}
}

三泛型限定

1、对象再取出(迭代时)的时候一般使用的是上限定(?extends  E)接收E和E的子类型，？为通配符

2、对象在进行比较时（定义的比较器上），一般使用下限定(? super E)，尖括号里直接写父类的类型，?和super不用写，否则编译失败。其实能传入的比较对象还是Person和Person的子类对象，感觉上还是上限定

二、Map集合

1、结构

   |——Hashtable:底层是哈希表数据结构，线程是同步的，不可以存储null值和null键

   |——HashMap：底层是哈希表数据结构，线程不同步，可以存储null值和null键。替代了Hashtable

   |——TreeMap：底层是二叉树结构，能够对Map集合中的键进行自然顺序的排序

2、Map结合与Collection集合的区别

  *Collection集合一次存一个元素，Map集合一次存一对元素

  *Collection集合是单列的，Map集合是双列的

3、Map集合特点：该集合存储键值对，一对一对往里存，而且要保证键的唯一性

4、方法

   *添加: put(K key, Vvalue) 当存储的键相同时，新的值会替换老的值，并将老值返回。如果键没有重复，返回null。

          putAll(Map<?extends K,? extends V> m)

   *删除: clear():清空集合

          remove(Objectkey) ：删除指定键

   *判断: containsValue(Objectvalue) ：是否包含某一个值

          containsKey(Objectkey) ：是否包含某一个键

          isEmpty()：是否为空

   *获取：get(key)：返回指定键对应的值

          size()：返回集合中长度即键值对数

          values()：返回此映射关系包含的值的Collection试图

          entrySet()：返回此映射中包含的键值映射关系的Set视图。用于取出元素的一种方式

          keySet()：返回此映射中包含的键的Set视图。也是用于取出元素一种方式

5、如何获取Map集合中的所有元素:

   由于Map集合中没有迭代器，想要取出元素，需要将Map结合转成Set集合，在使用Set结合的迭代器取出。之所以转成Set集合，因为Map集合具备键的唯一性，其实Set集合底层就是用的Map集合的方法。

6、把Map集合转成Set集合的方法

  1）调用Map集合的keySet()方法，返回值为一个Set集合,取出的是Map结合所有的键

      Set<String>keySet = map.keySet();

      Iterator<Syring> it= keySet.iterator();

      while(it.hasNext()) {

          Object key =it.next();

          Object value =map.get(key);

          System.out.println(key+":"+value);

        }

  2）调用Map结合的entrySet()方法，返回值是一个Set集合，取出的是Map集合的键值对关系

        Set<Map.Entry<String,String>>entrySet = map.entrySet();

        Iterator<Map.Entry<String,String>>it = entrySet.iterator();

        while(it.hasNext()) {

            Map.Entry<String,String> me = (Map.Entry)it.next();

            System.out.println(me.getKey()+"::::"+me.getValue());

        }

集合什么时候使用：

1、当存储的是一个元素时，就要Collection集合；当存储对象之间存在着映射关系时就要使用Map集合。

2、保证元素唯一，就是一个set；不保证唯一就用List

HashMap演示：

import java.util.*;
class MapDemo
{
public static void fuc(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
Map<String,String> m = new HashMap<String,String>();
//添加元素时，如果出现相同的键，那么后添加的值会覆盖原有键对应值，put方法会返回被覆盖的值
fuc(m.put("01","lisi1"));
fuc(m.put("01","zhangsan"));
m.put("02","lisi2");
m.put("03","lisi3");
m.put("04","lisi4");
//m.remove("03");删除键值为03的对象
fuc(m.containsValue("lisi2"));//判断是否有值为lisi2的对象
fuc(m.containsKey("03"));//判断是否有键为03的对象
fuc(m.size());//获取集合长度
fuc(m.get("03"));//获取键为03 对象的值
Collection<String> s = m.values();//获取集合中所有的值，返回值为Collection类型
fuc(m);
fuc(s);
}
}练习1：

/*
每个学生都有对应的归属地
学生 Student，地址String Student作为key
学生属性：姓名，年龄
注意：姓名、年龄相同视为同一个人
保证学生唯一性
1、描述学生
2、定义map容器
3、获取map集合中的元素
*/
import java.util.*;
class Student
{
private String name;
private int age;
Student(String name,int age)
{
this.name=name;
this.age=age;
}
public String toString()
{
return name+".."+age;
}
public int hashCode()//复写hashCode方法
{
return name.hashCode()+age*20;
}
public boolean equals(Object obj)//复写equals方法，比较对象的内容
{
if(!(obj instanceof Student))
throw new RuntimeException("对象错误");
Student s = (Student)obj;
return this.name.equals(s.name)&&this.age==s.age;
}
}
class MapTestt
{
public static void main(String[] args)
{
HashMap<Student,String> hs = new HashMap<Student,String>();
hs.put(new Student("lisi01",20),"hubei");
hs.put(new Student("lisi02",23),"hunan");
hs.put(new Student("lisi03",19),"donbei");
hs.put(new Student("lisi02",23),"hubei");
hs.put(new Student("lisi03",19),"donbei");
//方法一
Set<Student> keyset = hs.keySet();//调用keySet方法获取集合中的键，并存入Set集合中
Iterator<Student> it = keyset.iterator();//调用Set集合迭代器遍历存入set集合的键
while(it.hasNext())
{
Student key =it.next();//获取类型为Student的键
String value = hs.get(key);//通过键，调用get(key)方法获取对应的值
System.out.println(key.toString()+".."+value);//打印键值对
}
//方法二
Set<Map.Entry<Student,String>> entry =hs.entrySet();//调用entrySet方法，获取集合中的键值对引用，并存入Set集合
Iterator<Map.Entry<Student,String>> iter = entry.iterator();//使用set集合迭代器遍历键值对引用
while(iter.hasNext())
{
Map.Entry<Student,String> me = iter.next();//获取键值对
Student stu = me.getKey();//获取键
String str = me.getValue();//获取值
System.out.println(stu.toString()+"....."+str);
}
}
}练习2：

/*
练习：
“diuwabdkjgSydfqwvbdksgfaui”获取该字符串中字母出现的次数
希望打印结果：a(1)c(2) 去掉非字母字符
打印顺序是字母的自然顺序，可以使用TreeMap集合来存储
最后通过StringBuilder容器转换为字符串形式输出

思路：1、定义一个字符串
2、将字符串转成字符数组
3、遍历字符数组，拿每次遍历到的值作为键，通过TreeMap的get方法到集合中去寻找是否存在，不存在会返回null，存在返回键对应的值。如果不存在就直接把这个值 和1 作为键值对存入集合，下一次判断不为空的键，值加一。为了将其他字符清除，可以判断一下，让非字母的字符不能参与比较，直接遍历下一个字符
4、循环完成后所有的字符出现的次数都以键值对的形式存入到了集合中，要取出集合的元素必须遍历集合，使用entrySet方法将集合键值对 取出，并存放于Set集合中，在使用Set集合的迭代器，
5、将键值对分别存入StringBuilder容器，通过toString方法转化为字符串返回
*/
import java.util.*;
class MapTreeMapTest22
{
public static void main(String[] args)
{
String s = method();
System.out.println(s);
}
public static String method()
{
TreeMap<Character,Integer> tm = new TreeMap<Character,Integer>();//泛型接受的是引用型参数，char和int必须写成Cha //racter和Integer
StringBuilder sb =new StringBuilder();
String s = "diuw+abd-kjgS-ydfqwvb^!@5dksgf@aui";
char[] arr = s.toCharArray();
for(int x = 0;x<arr.length;x++)
{
if(!(arr[x]>='a' &&arr[x]<='z' ||arr[x]>='A' &&arr[x]<='Z'))//判断是否是字母，不是就进行下一次循环
continue;
Integer index = tm.get(arr[x]);
if(index==null)//如果字母首次出现，就将字母和一作为键值对存入集合
{
tm.put(arr[x],1);
}
else//如果集合里面已有，就将值加一在存入集合
{
index = index+1;
tm.put(arr[x],index);
}
}
Set<Map.Entry<Character,Integer>> entry = tm.entrySet();//使用Map集合获取键值对的形式来取出元素
Iterator<Map.Entry<Character,Integer>> it = entry.iterator();
while(it.hasNext())
{
Map.Entry<Character,Integer> me = it.next();
Character key = me.getKey();
Integer value = me.getValue();
sb.append(key+"("+value+")");//将集合中取出的键值对存入StringBuilder容器，在以字符串形式返回
}
return sb.toString();
}
}
练习4：
/*
Map扩展
使用集合嵌套集合的方式存入下列对象
"yureban" "01" "zhangsan";
"yureban" "02" "lisi"
"jiuyeban" "01" "wangwu"
"jiuyeban" "02" "zhaoliu"
"czbk"包含"yureban" "jiuyeban" 两个
1、可以将预热班看着是一个集合，里面有两组元素"01"="zhangsan"， "02"="lisi"
2、可以将就业班看着是一个集合，里面有两组元素"01"="wangwu"， "02"="zhaoliu"
3、可以将czbk看着是一个集合，里面有两组元素"01"=yureban， "02"=jiuyeban
4、这样就像大集合套小集合
5、取出所有元素先要取出czbk的所有班级
6、取出了所有班级就可以一一取出里面的元素
*/
import java.util.*;
class MapTreeMapTest33
{
public static void fuc(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
HashMap<String,String> yureban = new HashMap<String,String>();//建立预热班集合，添加两个元素
yureban.put("01","zhangsan");
yureban.put("02","wangwu");
HashMap<String,String> jiuyeban = new HashMap<String,String>();//建立就业班集合，添加两个元素
jiuyeban.put("01","lisi");
jiuyeban.put("02","zhaoliu");
HashMap<String,HashMap<String,String>> czbk = new HashMap<String,HashMap<String,String>>();//建立czbk集合将就业班和预热班作为值添加进去
czbk.put("01",yureban);
czbk.put("02",jiuyeban);
Set<String> keyset = czbk.keySet();
for(Iterator<String> it = keyset.iterator();it.hasNext();)//想要打印所有元素，先要找出所有班级
{
String key = it.next();
HashMap<String,String> value = czbk.get(key);
method(value);
}
}
public static void method(HashMap<String,String> map)//建立一个打印班级元素的方法
{
Set<Map.Entry<String,String>> entry = map.entrySet();
for(Iterator<Map.Entry<String,String>> it = entry.iterator();it.hasNext();)
{
Map.Entry<String,String> me = it.next();
String key = me.getKey();
String value = me.getValue();
System.out.println(key+".."+value);
}
}
}

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------