Java——集合——list、set、map
2015-10-25 10:55
309 查看
-----------android培训、java培训、java学习型技术博客、期待与您交流！------------
第一讲 集合框架
先看下面的图：
这就是集合框架的构成。由于数据结构的不同，有不同的集合，也叫容器。下面是集合类的简单介绍。
一、为什么出现集合类？
面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。
二、数组和集合类同是容器，有何不同？
数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象。
三、集合类的特点
集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。
第二讲 Collection
Collection是集合框架中的常用接口。其下有两个子接口：List（列表），Set（集）。
所属关系：
Collection
|--List//元素是有序的，元素可以重复。因为该集合体系有索引。
|--Set//元素是无序的，元素不可以重复。
一、Collection接口中的常见操作
1、添加元素
add(Objectobj); //add方法的参数类型是Object。以便于接收任意类型对象。
2、删除元素
remove(Objectobj);
removeAll(另一集合);//调用者只保留另一集合中没有的元素。
clear();//清空集合
3、判断元素
contains(Objectobj);//判断是否存在obj这个元素
isEmpty();//是否为空
4、获取个数，集合长度
size();
5、取交集
retainAll(另一集合);//调用者只保留两集合的共性元素。
注：集合中存储的都是对象的引用（地址）。
二、迭代
1、概述
迭代是取出集合中元素的一种方式。
对于集合的元素取出这个动作：
当不足以用一个函数来描述，需要用多个功能来体现，所以就将取出这个动作封装成一个对象来描述。就把取出方式定义在集合的内部，这样取出方式就可以直接访问集合内部的元素。那么取出方式就被定义成了内部类。
而每一个容器的数据结构不同，所以取出的动作细节也不一样。但是都具有共性内容： 判断和取出。那么就可以将这些共性抽取。
那么这些内部类都符合一个规则（或者说都抽取出来一个规则）。该规则就是Iterator。通过一个对外提供的方法：iterator();，来获取集合的取出对象。
因为Collection中有iterator方法，所以每一个子类集合对象都具备迭代器。
2、迭代的常见操作
hasNext();//有下一个元素，返回真
next();//取出下一个元素
remove();//移除
注：在迭代时循环中next调用一次，就要hasNext判断一次。
使用：
ArrayList a=newArrayList();//创建一个集合
Iteratorit=a.iterator();//获取一个迭代器，用于取出集合中的元素。
第一种打印方式：
for(Iterator iter = a.iterator();iter.hasNext(); )
{
System.out.println(iter.next());
}
第二种打印方式：
Iteratoriter = a.iterator();
while(iter.hasNext())
{
System.out.println(iter.next());
}
3、迭代注意事项
· 迭代器在Collcection接口中是通用的，它替代了Vector类中的Enumeration(枚举)。
· 迭代器的next方法是自动向下取元素，要避免出现NoSuchElementException。
· 迭代器的next方法返回值类型是Object，所以要记得类型转换。
第三讲 List
一、List
组成
List：元素是有序的，元素可以重复。因为该集合体系有索引。
|--ArrayList：底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。
|--LinkedList：底层使用的是链表数据结构。特点：增删速度很快，查询稍慢。
|--Vector：底层是数组数据结构。线程同步。被ArrayList替代了。
二、List的特有方法
凡是可以操作角标的方法都是该体系特有的方法。
1、增
booleanadd(index,element);//指定位置添加元素
BooleanaddAll(index,Collection);//在指定位置增加给定集合中的所有元素，若省略位置参数，则在当前集合的后面依次添加元素
2、删
Booleanremove(index);//删除指定位置的元素
3、改
set(index,element);//修改指定位置的元素。
4、查
get(index);//通过角标获取元素
subList(from,to);//获取部分对象元素
5、其他
listIterator();//List特有的迭代器
indexOf(obj);//获取元素第一次出现的位置，如果没有则返回-1
注：List集合判断元素是否相同，移除等操作，依据的是元素的equals方法。
三、ListIterator
1、概述
ListIterator是List集合特有的迭代器，是Iterator的子接口。
在迭代时，不可以通过集合对象的方法操作集合中的元素。因为会发生ConcurrentModificationException异常。所以在迭代器时，只能用迭代器的方法操作元素。可是Iterator方法是有限的，只能对元素进行判断，取出，删除的操作。如果想要其他的操作，如添加、修改等，就需要使用其子接口：ListIterrator。该接口只能通过List集合的ListIterator方法获取。
2、ListIterator特有的方法
add(obj);//增加
set(obj);//修改为obj
hasPrevious();//判断前面有没有元素
previous();//取前一个元素
四、枚举Enumeration
枚举：
就是Vector特有的取出方式。Vector有三种取出方式。
其实枚举和迭代是一样的。因为枚举的名称以及方法的名称都过长。所以被迭代器取代了。
特有方法：
addElement(obj);//添加元素，相当于add(obj);
Enumerationelements();//Vector特有取出方式(枚举)
hasMoreElements();//相当于Iterator的hasNext()方法
nextElements();//相当于Iterator的next()方法
例：
[java] view plaincopy
1. Vector v=new Vector();
2. for(Enumeration e=v.elements();e.hasMoreElements();)
3. {
4. System.out.println(e.nextElements());
5. }
五、LinkedList
LinkedList：底层使用的是链表数据结构。特点：增删速度很快，查询稍慢。
特有方法：
1、增
addFirst();
addLast();
2、获取
//获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException
getFirst();
getLast();
3、删
//获取元素，并删除元素。如果集合中没有元素，会出现NoSuchElementException
removeFirst();
removeLast();
在JDK1.6以后，出现了替代方法。
1、增
offerFirst();
offerLast();
2、获取
//获取元素，但是不删除。如果集合中没有元素，会返回null。
peekFirst();
peekLast();
3、删
//获取元素，并删除元素。如果集合中没有元素，会返回null。
pollFirst();
pollLast();
示例：
[java] view plaincopy
1. /*
2. 使用LinkedList模拟一个堆栈或者队列数据结构。
3.
4. 堆栈：先进后出 如同一个杯子。
5. 队列：先进先出 First in First out FIFO 如同一个水管。
6.
7. */
8. import java.util.*;
9.
10. class LinkedListTest
11. {
12. public static void main(String[] args)
13. {
14. LinkedList l=new LinkedList();
15. l.addFirst("java01");
16. l.addFirst("java02");
17. l.addFirst("java03");
18. l.addFirst("java04");
19. l.addFirst("java05");
20.
21. //堆栈输出
22. // stack(l);
23.
24. //队列输出
25. queue(l);
26.
27. }
28.
29. //堆栈
30. public static void stack(LinkedList l)
31. {
32. while (!l.isEmpty())
33. {
34. sop(l.removeFirst());
35. }
36. }
37.
38. //队列
39. public static void queue(LinkedList l)
40. {
41. while(!l.isEmpty())
42. {
43. sop(l.removeLast());
44. }
45. }
46.
47. //输出
48. public static void sop(Object obj)
49. {
50. System.out.println(obj);
51. }
52. }
第四讲 Set
一、概述
Set：元素是无序（存入和取出的顺序不一定一致），元素不可以重复。
|--HashSet：底层数据结构是哈希表。线程不同步。 保证元素唯一性的原理：判断元素的hashCode值是否相同。如果相同，还会继续判断元素的equals方法，是否为true。
|--TreeSet：可以对Set集合中的元素进行排序。默认按照字母的自然排序。底层数据结构是二叉树。保证元素唯一性的依据：compareTo方法return 0。
Set集合的功能和Collection是一致的。
二、HasSet
HashSet：线程不安全，存取速度快。
可以通过元素的两个方法，hashCode和equals来完成保证元素唯一性。如果元素的HashCode值相同，才会判断equals是否为true。如果元素的hashCode值不同，不会调用equals。
注意：HashSet对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashCode和equals方法。
示例：
[java] view plaincopy
1. /*
2. 往hashSet集合中存入自定对象
3. 姓名和年龄相同为同一个人，重复元素。去除重复元素
4. 思路：1、对人描述，将人的一些属性等封装进对象
5. 2、定义一个HashSet容器，存储人对象
6. 3、取出
7.
8. */
9. import java.util.*;
10.
11. //人描述
12. class Person
13. {
14. private String name;
15. private int age;
16.
17. Person(String name,int age)
18. {
19. this.name=name;
20. this.age=age;
21. }
22.
23. public String getName()
24. {
25. return name;
26. }
27.
28. public int getAge()
29. {
30. return age;
31. }
32.
33. public boolean equals(Object obj)
34. {
35. if(!(obj instanceof Person))
36. return false;
37. Person p=(Person)obj;
38. return this.name.equals(p.name)&&this.age==p.age;
39. }
40.
41. public int hashCode()
42. {
43. return this.name.hashCode()+this.age;
44. }
45. }
46. class HashSetTest
47. {
48. public static void main(String[] args)
49. {
50. HashSet h=new HashSet();
51. h.add(new Person("shenm",10));
52. h.add(new Person("shenm2",6));
53. h.add(new Person("shenm1",30));
54. h.add(new Person("shenm0",10));
55. h.add(new Person("shenm0",10));
56.
57. getOut(h);
58.
59. }
60.
61. //取出元素
62. public static void getOut(HashSet h)
63. {
64. for (Iterator it=h.iterator(); it.hasNext(); )
65. {
66. Person p=(Person)it.next();
67. sop(p.getName()+"..."+p.getAge());
68. }
69. }
70.
71. //打印
72. public static void sop(Object obj)
73. {
74. System.out.println(obj);
75. }
76. }
三、TreeSet
1、特点
a、底层的数据结构为二叉树结构（红黑树结构）
b）可对Set集合中的元素进行排序，是因为：TreeSet类实现了Comparable接口，该接口强制让增加到集合中的对象进行了比较，需要复写compareTo方法，才能让对象按指定需求（如人的年龄大小比较等）进行排序，并加入集合。
java中的很多类都具备比较性，其实就是实现了Comparable接口。
注意：排序时，当主要条件相同时，按次要条件排序。
二叉树示意图
c、保证数据的唯一性的依据：通过compareTo方法的返回值，是正整数、负整数或零，则两个对象较大、较小或相同。相等时则不会存入。
2、Tree排序的两种方式
1）第一种排序方式：自然排序
让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法。这种方式也被称为元素的自然顺序，或者叫做默认顺序。
示例：
[java] view plaincopy
1. import java.util.*;
2. //学生类
3. class Student implements Comparable
4. {
5. private String name;
6. private int age;
7. Student(String name,int age)
8. {
9. this.name=name;
10. this.age=age;
11. }
12. public String getName()
13. {
14. return name;
15. }
16.
17. public int getAge()
18. {
19. return age;
20. }
21. //复写hashCode以便HashSet集合调用
22. public int hashCode()
23. {
24. return name.hashCode()+age;
25. }
26. //复写equals以便HashSet集合和集合中一些比较方法调用
27. public boolean equals(Object obj)
28. {
29. if(!(obj instanceof Student))
30. throw new RuntimeException();
31. Student s = (Student)obj;
32. return this.name.equals(s.name)&&this.age==s.age;
33. }
34. //复写compareTo以便TreeSet集合调用
35. public int compareTo(Object obj)
36. {
37. Student s=(Student)obj;
38. if(this.age==s.age)
39. return this.name.compareTo(s.name);
40. return this.age-s.age;
41. //return new Integer(this.age).compareTo(new Integer(s.age));
42. }
43. }
44.
45. class TreeSetTest
46. {
47. public static void main(String[] args)
48. {
49. TreeSet<Student> t=new TreeSet<Student>();
50. t.add(new Student("wo1",12));
51. t.add(new Student("wosj",2));
52. t.add(new Student("wo1sdj",12));
53. t.add(new Student("wo6sd",12));
54. t.add(new Student("wo",22));
55.
56.
57. for (Iterator<Student> it=t.iterator(); it.hasNext(); )
58. {
59. Student s=it.next();
60. System.out.println(s.getName()+"....."+s.getAge());
61. }
62. }
63. }
2）第二种方式：比较器
当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。
在集合初始化时，就有了比较方式。定义一个比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。
比较器构造方式：定义一个类，实现Comparator接口，覆盖compare方法。
当两种排序都存在时，以比较器为主。
示例：
[java] view plaincopy
1. /*
2. 需求：
3. 往TreeSet集合中存储自定义对象学生。
4. 想按照学生的年龄进行排序。
5.
6. */
7.
8. import java.util.*;
9. //学生类
10. class Student implements Comparable
11. {
12. private String name;
13. private int age;
14. Student(String name,int age)
15. {
16. this.name=name;
17. this.age=age;
18. }
19. public String getName()
20. {
21. return name;
22. }
23.
24. public int getAge()
25. {
26. return age;
27. }
28. //复写hashCode以便HashSet集合调用
29. public int hashCode()
30. {
31. return name.hashCode()+age;
32. }
33. //复写equals以便HashSet集合和集合中一些比较方法调用
34. public boolean equals(Object obj)
35. {
36. if(!(obj instanceof Student))
37. throw new RuntimeException();
38. Student s = (Student)obj;
39. return this.name.equals(s.name)&&this.age==s.age;
40. }
41. //复写compareTo以便TreeSet集合调用
42. public int compareTo(Object obj)
43. {
44. Student s=(Student)obj;
45. if(this.age==s.age)
46. return this.name.compareTo(s.name);
47. return this.age-s.age;
48. //return new Integer(this.age).compareTo(new Integer(s.age));
49. }
50.
51. }
52.
53. class TreeSetTest
54. {
55. public static void main(String[] args)
56. {
57. TreeSet<Student> t=new TreeSet<Student>(new LenCompare());
58. t.add(new Student("wo1",12));
59. t.add(new Student("wosj",2));
60. t.add(new Student("wo1sdj",12));
61. t.add(new Student("wo6sd",12));
62. t.add(new Student("wo",22));
63.
64.
65. for (Iterator<Student> it=t.iterator(); it.hasNext(); )
66. {
67. Student s=it.next();
68. System.out.println(s.getName()+"....."+s.getAge());
69. }
70. }
71.
72. }
73. //定义一个比较器，以姓名长度为主要比较
74. class LenCompare implements Comparator<Student>
75. {
76. public int compare(Student s1,Student s2)
77. {
78. int num=new Integer(s1.getName().length()).compareTo(new Integer(s2.getName().length()));
79. if (num==0)
80. {
81. return new Integer(s1.getAge()).compareTo(s2.getAge());
82. }
83. return num;
84. }
85. }
第五讲 Map集合
一、概述
1、简述：
Map<K,V>集合是一个接口，和List集合及Set集合不同的是，它是双列集合，并且可以给对象加上名字，即键（Key）
2、特点：
1）该集合存储键值对，一对一对往里存
2）要保证键的唯一性。
二、Map集合的子类
Map
|--Hashtable：底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。JDK1.0，效率低。
|--HashMap：底层是哈希表数据结构。允许使用null键null值，该集合是不同步的。JDK1.2，效率高。
|--TreeMap：底层是二叉树数据结构。线程不同步。可以用于给Map集合中的键进行排序。
Map和Set很像。其实Set底层就是使用了Map集合。
三、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来判断。
四、Map集合的两种取出方式
Map集合的取出原理：将Map集合转成Set集合。再通过迭代器取出。
1、Set<K> keySet()：将Map中所以的键存入到Set集合。因为Set具备迭代器。所以可以通过迭代方式取出所以键的值，再通过get方法。获取每一个键对应的值。
示例：
[java] view plaincopy
1. /*
2. 每一个学生都有对应的归属地。
3. 学生Student，地址String。
4. 学生属性：姓名，年龄。
5. 注意：姓名和年龄相同的视为同一个学生。
6. 保证学生的唯一性。
7.
8. 思路：1、描述学生类
9. 2、定义一个Map集合，存储学生对象和地址值
10. 3、获取Map中的元素
11. */
12.
13. import java.util.*;
14.
15. //描述学生类
16. class Student implements Comparable<Student>
17. {
18. private String name;
19. private int age;
20. Student(String name,int age)
21. {
22. this.name=name;
23. this.age=age;
24. }
25. public String getName()
26. {
27. return name;
28. }
29.
30. public int getAge()
31. {
32. return age;
33. }
34.
35. //复写hashCode
36. public int hashCode()
37. {
38. return name.hashCode()+age*33;
39. }
40. //复写equals，比较对象内容
41. public boolean equals(Object obj)
42. {
43. if(!(obj instanceof Student))
44. throw new ClassCastException("类型不匹配");
45. Student s=(Student)obj;
46. return this.name.equals(s.name)&&this.age==s.age;
47. }
48.
49. //复写compareTo,以年龄为主
50. public int compareTo(Student c)
51. {
52. int num=new Integer(this.age).compareTo(new Integer(c.age));
53. if(num==0)
54. {
55. return this.name.compareTo(c.name);
56. }
57. return num;
58. }
59.
60. //复写toString，自定义输出内容
61. public String toString()
62. {
63. return name+"..."+age;
64. }
65.
66. }
67. class HashMapTest
68. {
69. public static void main(String[] args)
70. {
71. HashMap<Student,String > hm=new HashMap<Student,String >();
72. hm.put(new Student("zhangsan",12),"beijing");
73. hm.put(new Student("zhangsan",32),"sahnghai");
74. hm.put(new Student("zhangsan",22),"changsha");
75. hm.put(new Student("zhangsan",62),"USA");
76. hm.put(new Student("zhangsan",12),"tianjing");
77.
78. keyset(hm);
79. }
80.
81. //keySet取出方式
82. public static void keyset(HashMap<Student,String> hm)
83. {
84. Iterator<Student> it=hm.keySet().iterator();
85.
86. while(it.hasNext())
87. {
88. Student s=it.next();
89. String addr=hm.get(s);
90. System.out.println(s+":"+addr);
91. }
92. }
93. }
2、Set<Map.Entry<K,V>> entrySet()：将Map集合中的映射关系存入到Set集合中，而这个关系的数据类型就是：Map.Entry
其实，Entry也是一个接口，它是Map接口中的一个内部接口。
[java] view plaincopy
1. interface Map
2. {
3. public static interface Entry
4. {
5. public abstract Object getKey();
6. public abstract Object getValue();
7. }
8. }
示例：
同上面示例的学生类----
[java] view plaincopy
1. class HashMapTest
2. {
3. public static void main(String[] args)
4. {
5. HashMap<Student,String > hm=new HashMap<Student,String >();
6. hm.put(new Student("zhangsan",12),"beijing");
7. hm.put(new Student("zhangsan",32),"sahnghai");
8. hm.put(new Student("zhangsan",22),"changsha");
9. hm.put(new Student("zhangsan",62),"USA");
10. hm.put(new Student("zhangsan",12),"tianjing");
11.
12. entryset(hm);
13. }
14. //entrySet取出方式
15. public static void entryset(HashMap<Student,String> hm)
16. {
17. Iterator<Map.Entry<Student,String>> it=hm.entrySet().iterator();
18.
19. while(it.hasNext())
20. {
21. Map.Entry<Student,String> me=it.next();
22. Student s=me.getKey();
23. String addr=me.getValue();
24. System.out.println(s+":::"+addr);
25. }
26. }
27. }
关于Map.Entry：
Map是一个接口，其实，Entry也是一个接口，它是Map的子接口中的一个内部接口，就相当于是类中有内部类一样。为何要定义在其内部呢？
原因：a、Map集合中村的是映射关系这样的两个数据，是先有Map这个集合，才可有映射关系的存在，而且此类关系是集合的内部事务。
b、并且这个映射关系可以直接访问Map集合中的内部成员，所以定义在内部。
五、Map集合的应用及扩展
1、何时使用Map集合：当量数据之间存在着映射关系的时候，就应该想到使用Map集合。
2、示例：
获取该字符串中的字母出现的次数，如："sjokafjoilnvoaxllvkasjdfns"；希望打印的结果是：a(3)c(0).....
通过结果发现，每个字母都有对应的次数，说明字母和次数之间有映射关系。代码如下：
[java] view plaincopy
1. /*
2. 思路：1、将字符串转换为字符数组
3. 2、定义一个TreeMap集合，用于存储字母和字母出现的次数
4. 3、用数组去遍历集合，如果集合中有该字母则次数加1，如果集合中没有则存入
5. 4、将TreeMap集合中的元素转换为字符串
6. */
7. package TreeMapTest;
8. import java.util.*;
9.
10. class CharCount
11. {
12. public static void main(String[] args)
13. {
14. String s="sdfgzxcvasdfxcvdf";
15. System.out.println("s中各字母出现的次数："+charCount(s));
16. }
17.
18. //定义一个方法获取字符串中字母出现的次数
19. public static String charCount(String str)
20. {
21. char[] cha=str.toCharArray();//转换为字符数组
22.
23. //定义一个TreeMap集合，因为TreeMap集合会给键自动排序
24. TreeMap<Character,Integer> tm=new TreeMap<Character,Integer>();
25.
26. int count=0;//定义计数变量
27. for (int x=0;x<cha.length ;x++ )
28. {
29. if(!(cha[x]>='a'&&cha[x]<='z'||cha[x]>='A'&&cha[x]<='Z'))
30. continue;//如果字符串中非字母，则不计数
31. Integer value=tm.get(cha[x]);//获取集合中的值
32. if(value!=null)//如果集合中没有该字母，则存入
33. count=value;
34. count++;
35. tm.put(cha[x],count);//存入键值对
36. count=0;//复位计数变量
37. }
38.
39. StringBuilder sb=new StringBuilder();//定义一个容器
40.
41. //遍历集合，取出并以题目格式存入容器中
42. for(Iterator<Character> it=tm.keySet().iterator();it.hasNext();)
43. {
44. Character ch=it.next();
45. Integer value=tm.get(ch);
46. sb.append(ch+"("+value+")");
47. }
48. return sb.toString();//返回字符串
49. }
50. }
六、Map扩展知识
在很多项目中，应用比较多的是一对多的映射关系，这就可以通过嵌套的形式将多个映射定义到一个大的集合中，并将大的集合分级处理，形成一个体系。
如：
[java] view plaincopy
1. /*
2. map扩展知识。
3. map集合被使用是因为具备映射关系。
4. 以下是班级对应学生，而学生中学号对应着姓名的映射关系：
5. "yureban" Student("01" "zhangsan");
6.
7. "yureban" Student("02" "lisi");
8.
9. "jiuyeban" "01" "wangwu";
10. "jiuyeban" "02" "zhaoliu";
11.
12. 就如同一个学校有多个教室。每一个教室都有名称。
13. */
14. import java.util.*;
15.
16. class MapExpandKnow
17. {
18. public static void main(String[] args)
19. {
20. //预热班集合
21. HashMap<String,String> yureban=new HashMap<String,String>();
22. //就业班集合
23. HashMap<String,String> jiuyeban=new HashMap<String,String>();
24. //学校集合
25. HashMap<String,HashMap<String,String>> czbk=new HashMap<String,HashMap<String,String>>();
26.
27. //学校中班级集合和名称的映射
28. czbk.put("yureban",yureban);
29. czbk.put("jiuyueban",jiuyeban);
30.
31. //预热班级中学号与姓名的映射
32. yureban.put("01","zhangsan");
33. yureban.put("02","lisi");
34.
35. //就业班级中学号与姓名的映射
36. jiuyeban.put("01","wangwu");
37. jiuyeban.put("02","zhouqi");
38.
39. //直接显示全部学生信息
40. getAllStudentInfo(czbk);
41.
42. }
43. //定义一个方法获取全部学生信息，包括在哪个班级，叫什么名字，学号多少
44. public static void getAllStudentInfo(HashMap<String ,HashMap<String,String>> hm)
45. {
46. for (Iterator<String> it=hm.keySet().iterator();it.hasNext() ; )//用keySet取出方式
47. {
48. String s= it.next();//班级名称
49. System.out.println(s+":");
50. HashMap<String,String> stu=hm.get(s);//班级集合
51.
52. getStudentInfo(stu);
53. }
54. }
55.
56. //获取班级中学生的信息，包括姓名和学号
57. public static void getStudentInfo(HashMap<String,String> hm)
58. {
59. for (Iterator<String> it=hm.keySet().iterator();it.hasNext() ; )
60. {
61. String key=it.next();//学号
62. String value=hm.get(key);//姓名
63. System.out.println(key+"..."+value);
64. }
65. }
66. }
-----------android培训、java培训、java学习型技术博客、期待与您交流！------------
第一讲 集合框架
先看下面的图：
这就是集合框架的构成。由于数据结构的不同，有不同的集合，也叫容器。下面是集合类的简单介绍。
一、为什么出现集合类？
面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。
二、数组和集合类同是容器，有何不同？
数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象。
三、集合类的特点
集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。
第二讲 Collection
Collection是集合框架中的常用接口。其下有两个子接口：List（列表），Set（集）。
所属关系：
Collection
|--List//元素是有序的，元素可以重复。因为该集合体系有索引。
|--Set//元素是无序的，元素不可以重复。
一、Collection接口中的常见操作
1、添加元素
add(Objectobj); //add方法的参数类型是Object。以便于接收任意类型对象。
2、删除元素
remove(Objectobj);
removeAll(另一集合);//调用者只保留另一集合中没有的元素。
clear();//清空集合
3、判断元素
contains(Objectobj);//判断是否存在obj这个元素
isEmpty();//是否为空
4、获取个数，集合长度
size();
5、取交集
retainAll(另一集合);//调用者只保留两集合的共性元素。
注：集合中存储的都是对象的引用（地址）。
二、迭代
1、概述
迭代是取出集合中元素的一种方式。
对于集合的元素取出这个动作：
当不足以用一个函数来描述，需要用多个功能来体现，所以就将取出这个动作封装成一个对象来描述。就把取出方式定义在集合的内部，这样取出方式就可以直接访问集合内部的元素。那么取出方式就被定义成了内部类。
而每一个容器的数据结构不同，所以取出的动作细节也不一样。但是都具有共性内容： 判断和取出。那么就可以将这些共性抽取。
那么这些内部类都符合一个规则（或者说都抽取出来一个规则）。该规则就是Iterator。通过一个对外提供的方法：iterator();，来获取集合的取出对象。
因为Collection中有iterator方法，所以每一个子类集合对象都具备迭代器。
2、迭代的常见操作
hasNext();//有下一个元素，返回真
next();//取出下一个元素
remove();//移除
注：在迭代时循环中next调用一次，就要hasNext判断一次。
使用：
ArrayList a=newArrayList();//创建一个集合
Iteratorit=a.iterator();//获取一个迭代器，用于取出集合中的元素。
第一种打印方式：
for(Iterator iter = a.iterator();iter.hasNext(); )
{
System.out.println(iter.next());
}
第二种打印方式：
Iteratoriter = a.iterator();
while(iter.hasNext())
{
System.out.println(iter.next());
}
3、迭代注意事项
· 迭代器在Collcection接口中是通用的，它替代了Vector类中的Enumeration(枚举)。
· 迭代器的next方法是自动向下取元素，要避免出现NoSuchElementException。
· 迭代器的next方法返回值类型是Object，所以要记得类型转换。
第三讲 List
一、List
组成
List：元素是有序的，元素可以重复。因为该集合体系有索引。
|--ArrayList：底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。
|--LinkedList：底层使用的是链表数据结构。特点：增删速度很快，查询稍慢。
|--Vector：底层是数组数据结构。线程同步。被ArrayList替代了。
二、List的特有方法
凡是可以操作角标的方法都是该体系特有的方法。
1、增
booleanadd(index,element);//指定位置添加元素
BooleanaddAll(index,Collection);//在指定位置增加给定集合中的所有元素，若省略位置参数，则在当前集合的后面依次添加元素
2、删
Booleanremove(index);//删除指定位置的元素
3、改
set(index,element);//修改指定位置的元素。
4、查
get(index);//通过角标获取元素
subList(from,to);//获取部分对象元素
5、其他
listIterator();//List特有的迭代器
indexOf(obj);//获取元素第一次出现的位置，如果没有则返回-1
注：List集合判断元素是否相同，移除等操作，依据的是元素的equals方法。
三、ListIterator
1、概述
ListIterator是List集合特有的迭代器，是Iterator的子接口。
在迭代时，不可以通过集合对象的方法操作集合中的元素。因为会发生ConcurrentModificationException异常。所以在迭代器时，只能用迭代器的方法操作元素。可是Iterator方法是有限的，只能对元素进行判断，取出，删除的操作。如果想要其他的操作，如添加、修改等，就需要使用其子接口：ListIterrator。该接口只能通过List集合的ListIterator方法获取。
2、ListIterator特有的方法
add(obj);//增加
set(obj);//修改为obj
hasPrevious();//判断前面有没有元素
previous();//取前一个元素
四、枚举Enumeration
枚举：
就是Vector特有的取出方式。Vector有三种取出方式。
其实枚举和迭代是一样的。因为枚举的名称以及方法的名称都过长。所以被迭代器取代了。
特有方法：
addElement(obj);//添加元素，相当于add(obj);
Enumerationelements();//Vector特有取出方式(枚举)
hasMoreElements();//相当于Iterator的hasNext()方法
nextElements();//相当于Iterator的next()方法
例：
[java] view plaincopy
1. Vector v=new Vector();
2. for(Enumeration e=v.elements();e.hasMoreElements();)
3. {
4. System.out.println(e.nextElements());
5. }
五、LinkedList
LinkedList：底层使用的是链表数据结构。特点：增删速度很快，查询稍慢。
特有方法：
1、增
addFirst();
addLast();
2、获取
//获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException
getFirst();
getLast();
3、删
//获取元素，并删除元素。如果集合中没有元素，会出现NoSuchElementException
removeFirst();
removeLast();
在JDK1.6以后，出现了替代方法。
1、增
offerFirst();
offerLast();
2、获取
//获取元素，但是不删除。如果集合中没有元素，会返回null。
peekFirst();
peekLast();
3、删
//获取元素，并删除元素。如果集合中没有元素，会返回null。
pollFirst();
pollLast();
示例：
[java] view plaincopy
1. /*
2. 使用LinkedList模拟一个堆栈或者队列数据结构。
3.
4. 堆栈：先进后出 如同一个杯子。
5. 队列：先进先出 First in First out FIFO 如同一个水管。
6.
7. */
8. import java.util.*;
9.
10. class LinkedListTest
11. {
12. public static void main(String[] args)
13. {
14. LinkedList l=new LinkedList();
15. l.addFirst("java01");
16. l.addFirst("java02");
17. l.addFirst("java03");
18. l.addFirst("java04");
19. l.addFirst("java05");
20.
21. //堆栈输出
22. // stack(l);
23.
24. //队列输出
25. queue(l);
26.
27. }
28.
29. //堆栈
30. public static void stack(LinkedList l)
31. {
32. while (!l.isEmpty())
33. {
34. sop(l.removeFirst());
35. }
36. }
37.
38. //队列
39. public static void queue(LinkedList l)
40. {
41. while(!l.isEmpty())
42. {
43. sop(l.removeLast());
44. }
45. }
46.
47. //输出
48. public static void sop(Object obj)
49. {
50. System.out.println(obj);
51. }
52. }
第四讲 Set
一、概述
Set：元素是无序（存入和取出的顺序不一定一致），元素不可以重复。
|--HashSet：底层数据结构是哈希表。线程不同步。 保证元素唯一性的原理：判断元素的hashCode值是否相同。如果相同，还会继续判断元素的equals方法，是否为true。
|--TreeSet：可以对Set集合中的元素进行排序。默认按照字母的自然排序。底层数据结构是二叉树。保证元素唯一性的依据：compareTo方法return 0。
Set集合的功能和Collection是一致的。
二、HasSet
HashSet：线程不安全，存取速度快。
可以通过元素的两个方法，hashCode和equals来完成保证元素唯一性。如果元素的HashCode值相同，才会判断equals是否为true。如果元素的hashCode值不同，不会调用equals。
注意：HashSet对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashCode和equals方法。
示例：
[java] view plaincopy
1. /*
2. 往hashSet集合中存入自定对象
3. 姓名和年龄相同为同一个人，重复元素。去除重复元素
4. 思路：1、对人描述，将人的一些属性等封装进对象
5. 2、定义一个HashSet容器，存储人对象
6. 3、取出
7.
8. */
9. import java.util.*;
10.
11. //人描述
12. class Person
13. {
14. private String name;
15. private int age;
16.
17. Person(String name,int age)
18. {
19. this.name=name;
20. this.age=age;
21. }
22.
23. public String getName()
24. {
25. return name;
26. }
27.
28. public int getAge()
29. {
30. return age;
31. }
32.
33. public boolean equals(Object obj)
34. {
35. if(!(obj instanceof Person))
36. return false;
37. Person p=(Person)obj;
38. return this.name.equals(p.name)&&this.age==p.age;
39. }
40.
41. public int hashCode()
42. {
43. return this.name.hashCode()+this.age;
44. }
45. }
46. class HashSetTest
47. {
48. public static void main(String[] args)
49. {
50. HashSet h=new HashSet();
51. h.add(new Person("shenm",10));
52. h.add(new Person("shenm2",6));
53. h.add(new Person("shenm1",30));
54. h.add(new Person("shenm0",10));
55. h.add(new Person("shenm0",10));
56.
57. getOut(h);
58.
59. }
60.
61. //取出元素
62. public static void getOut(HashSet h)
63. {
64. for (Iterator it=h.iterator(); it.hasNext(); )
65. {
66. Person p=(Person)it.next();
67. sop(p.getName()+"..."+p.getAge());
68. }
69. }
70.
71. //打印
72. public static void sop(Object obj)
73. {
74. System.out.println(obj);
75. }
76. }
三、TreeSet
1、特点
a、底层的数据结构为二叉树结构（红黑树结构）
b）可对Set集合中的元素进行排序，是因为：TreeSet类实现了Comparable接口，该接口强制让增加到集合中的对象进行了比较，需要复写compareTo方法，才能让对象按指定需求（如人的年龄大小比较等）进行排序，并加入集合。
java中的很多类都具备比较性，其实就是实现了Comparable接口。
注意：排序时，当主要条件相同时，按次要条件排序。
二叉树示意图
c、保证数据的唯一性的依据：通过compareTo方法的返回值，是正整数、负整数或零，则两个对象较大、较小或相同。相等时则不会存入。
2、Tree排序的两种方式
1）第一种排序方式：自然排序
让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法。这种方式也被称为元素的自然顺序，或者叫做默认顺序。
示例：
[java] view plaincopy
1. import java.util.*;
2. //学生类
3. class Student implements Comparable
4. {
5. private String name;
6. private int age;
7. Student(String name,int age)
8. {
9. this.name=name;
10. this.age=age;
11. }
12. public String getName()
13. {
14. return name;
15. }
16.
17. public int getAge()
18. {
19. return age;
20. }
21. //复写hashCode以便HashSet集合调用
22. public int hashCode()
23. {
24. return name.hashCode()+age;
25. }
26. //复写equals以便HashSet集合和集合中一些比较方法调用
27. public boolean equals(Object obj)
28. {
29. if(!(obj instanceof Student))
30. throw new RuntimeException();
31. Student s = (Student)obj;
32. return this.name.equals(s.name)&&this.age==s.age;
33. }
34. //复写compareTo以便TreeSet集合调用
35. public int compareTo(Object obj)
36. {
37. Student s=(Student)obj;
38. if(this.age==s.age)
39. return this.name.compareTo(s.name);
40. return this.age-s.age;
41. //return new Integer(this.age).compareTo(new Integer(s.age));
42. }
43. }
44.
45. class TreeSetTest
46. {
47. public static void main(String[] args)
48. {
49. TreeSet<Student> t=new TreeSet<Student>();
50. t.add(new Student("wo1",12));
51. t.add(new Student("wosj",2));
52. t.add(new Student("wo1sdj",12));
53. t.add(new Student("wo6sd",12));
54. t.add(new Student("wo",22));
55.
56.
57. for (Iterator<Student> it=t.iterator(); it.hasNext(); )
58. {
59. Student s=it.next();
60. System.out.println(s.getName()+"....."+s.getAge());
61. }
62. }
63. }
2）第二种方式：比较器
当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。
在集合初始化时，就有了比较方式。定义一个比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。
比较器构造方式：定义一个类，实现Comparator接口，覆盖compare方法。
当两种排序都存在时，以比较器为主。
示例：
[java] view plaincopy
1. /*
2. 需求：
3. 往TreeSet集合中存储自定义对象学生。
4. 想按照学生的年龄进行排序。
5.
6. */
7.
8. import java.util.*;
9. //学生类
10. class Student implements Comparable
11. {
12. private String name;
13. private int age;
14. Student(String name,int age)
15. {
16. this.name=name;
17. this.age=age;
18. }
19. public String getName()
20. {
21. return name;
22. }
23.
24. public int getAge()
25. {
26. return age;
27. }
28. //复写hashCode以便HashSet集合调用
29. public int hashCode()
30. {
31. return name.hashCode()+age;
32. }
33. //复写equals以便HashSet集合和集合中一些比较方法调用
34. public boolean equals(Object obj)
35. {
36. if(!(obj instanceof Student))
37. throw new RuntimeException();
38. Student s = (Student)obj;
39. return this.name.equals(s.name)&&this.age==s.age;
40. }
41. //复写compareTo以便TreeSet集合调用
42. public int compareTo(Object obj)
43. {
44. Student s=(Student)obj;
45. if(this.age==s.age)
46. return this.name.compareTo(s.name);
47. return this.age-s.age;
48. //return new Integer(this.age).compareTo(new Integer(s.age));
49. }
50.
51. }
52.
53. class TreeSetTest
54. {
55. public static void main(String[] args)
56. {
57. TreeSet<Student> t=new TreeSet<Student>(new LenCompare());
58. t.add(new Student("wo1",12));
59. t.add(new Student("wosj",2));
60. t.add(new Student("wo1sdj",12));
61. t.add(new Student("wo6sd",12));
62. t.add(new Student("wo",22));
63.
64.
65. for (Iterator<Student> it=t.iterator(); it.hasNext(); )
66. {
67. Student s=it.next();
68. System.out.println(s.getName()+"....."+s.getAge());
69. }
70. }
71.
72. }
73. //定义一个比较器，以姓名长度为主要比较
74. class LenCompare implements Comparator<Student>
75. {
76. public int compare(Student s1,Student s2)
77. {
78. int num=new Integer(s1.getName().length()).compareTo(new Integer(s2.getName().length()));
79. if (num==0)
80. {
81. return new Integer(s1.getAge()).compareTo(s2.getAge());
82. }
83. return num;
84. }
85. }
第五讲 Map集合
一、概述
1、简述：
Map<K,V>集合是一个接口，和List集合及Set集合不同的是，它是双列集合，并且可以给对象加上名字，即键（Key）
2、特点：
1）该集合存储键值对，一对一对往里存
2）要保证键的唯一性。
二、Map集合的子类
Map
|--Hashtable：底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。JDK1.0，效率低。
|--HashMap：底层是哈希表数据结构。允许使用null键null值，该集合是不同步的。JDK1.2，效率高。
|--TreeMap：底层是二叉树数据结构。线程不同步。可以用于给Map集合中的键进行排序。
Map和Set很像。其实Set底层就是使用了Map集合。
三、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来判断。
四、Map集合的两种取出方式
Map集合的取出原理：将Map集合转成Set集合。再通过迭代器取出。
1、Set<K> keySet()：将Map中所以的键存入到Set集合。因为Set具备迭代器。所以可以通过迭代方式取出所以键的值，再通过get方法。获取每一个键对应的值。
示例：
[java] view plaincopy
1. /*
2. 每一个学生都有对应的归属地。
3. 学生Student，地址String。
4. 学生属性：姓名，年龄。
5. 注意：姓名和年龄相同的视为同一个学生。
6. 保证学生的唯一性。
7.
8. 思路：1、描述学生类
9. 2、定义一个Map集合，存储学生对象和地址值
10. 3、获取Map中的元素
11. */
12.
13. import java.util.*;
14.
15. //描述学生类
16. class Student implements Comparable<Student>
17. {
18. private String name;
19. private int age;
20. Student(String name,int age)
21. {
22. this.name=name;
23. this.age=age;
24. }
25. public String getName()
26. {
27. return name;
28. }
29.
30. public int getAge()
31. {
32. return age;
33. }
34.
35. //复写hashCode
36. public int hashCode()
37. {
38. return name.hashCode()+age*33;
39. }
40. //复写equals，比较对象内容
41. public boolean equals(Object obj)
42. {
43. if(!(obj instanceof Student))
44. throw new ClassCastException("类型不匹配");
45. Student s=(Student)obj;
46. return this.name.equals(s.name)&&this.age==s.age;
47. }
48.
49. //复写compareTo,以年龄为主
50. public int compareTo(Student c)
51. {
52. int num=new Integer(this.age).compareTo(new Integer(c.age));
53. if(num==0)
54. {
55. return this.name.compareTo(c.name);
56. }
57. return num;
58. }
59.
60. //复写toString，自定义输出内容
61. public String toString()
62. {
63. return name+"..."+age;
64. }
65.
66. }
67. class HashMapTest
68. {
69. public static void main(String[] args)
70. {
71. HashMap<Student,String > hm=new HashMap<Student,String >();
72. hm.put(new Student("zhangsan",12),"beijing");
73. hm.put(new Student("zhangsan",32),"sahnghai");
74. hm.put(new Student("zhangsan",22),"changsha");
75. hm.put(new Student("zhangsan",62),"USA");
76. hm.put(new Student("zhangsan",12),"tianjing");
77.
78. keyset(hm);
79. }
80.
81. //keySet取出方式
82. public static void keyset(HashMap<Student,String> hm)
83. {
84. Iterator<Student> it=hm.keySet().iterator();
85.
86. while(it.hasNext())
87. {
88. Student s=it.next();
89. String addr=hm.get(s);
90. System.out.println(s+":"+addr);
91. }
92. }
93. }
2、Set<Map.Entry<K,V>> entrySet()：将Map集合中的映射关系存入到Set集合中，而这个关系的数据类型就是：Map.Entry
其实，Entry也是一个接口，它是Map接口中的一个内部接口。
[java] view plaincopy
1. interface Map
2. {
3. public static interface Entry
4. {
5. public abstract Object getKey();
6. public abstract Object getValue();
7. }
8. }
示例：
同上面示例的学生类----
[java] view plaincopy
1. class HashMapTest
2. {
3. public static void main(String[] args)
4. {
5. HashMap<Student,String > hm=new HashMap<Student,String >();
6. hm.put(new Student("zhangsan",12),"beijing");
7. hm.put(new Student("zhangsan",32),"sahnghai");
8. hm.put(new Student("zhangsan",22),"changsha");
9. hm.put(new Student("zhangsan",62),"USA");
10. hm.put(new Student("zhangsan",12),"tianjing");
11.
12. entryset(hm);
13. }
14. //entrySet取出方式
15. public static void entryset(HashMap<Student,String> hm)
16. {
17. Iterator<Map.Entry<Student,String>> it=hm.entrySet().iterator();
18.
19. while(it.hasNext())
20. {
21. Map.Entry<Student,String> me=it.next();
22. Student s=me.getKey();
23. String addr=me.getValue();
24. System.out.println(s+":::"+addr);
25. }
26. }
27. }
关于Map.Entry：
Map是一个接口，其实，Entry也是一个接口，它是Map的子接口中的一个内部接口，就相当于是类中有内部类一样。为何要定义在其内部呢？
原因：a、Map集合中村的是映射关系这样的两个数据，是先有Map这个集合，才可有映射关系的存在，而且此类关系是集合的内部事务。
b、并且这个映射关系可以直接访问Map集合中的内部成员，所以定义在内部。
五、Map集合的应用及扩展
1、何时使用Map集合：当量数据之间存在着映射关系的时候，就应该想到使用Map集合。
2、示例：
获取该字符串中的字母出现的次数，如："sjokafjoilnvoaxllvkasjdfns"；希望打印的结果是：a(3)c(0).....
通过结果发现，每个字母都有对应的次数，说明字母和次数之间有映射关系。代码如下：
[java] view plaincopy
1. /*
2. 思路：1、将字符串转换为字符数组
3. 2、定义一个TreeMap集合，用于存储字母和字母出现的次数
4. 3、用数组去遍历集合，如果集合中有该字母则次数加1，如果集合中没有则存入
5. 4、将TreeMap集合中的元素转换为字符串
6. */
7. package TreeMapTest;
8. import java.util.*;
9.
10. class CharCount
11. {
12. public static void main(String[] args)
13. {
14. String s="sdfgzxcvasdfxcvdf";
15. System.out.println("s中各字母出现的次数："+charCount(s));
16. }
17.
18. //定义一个方法获取字符串中字母出现的次数
19. public static String charCount(String str)
20. {
21. char[] cha=str.toCharArray();//转换为字符数组
22.
23. //定义一个TreeMap集合，因为TreeMap集合会给键自动排序
24. TreeMap<Character,Integer> tm=new TreeMap<Character,Integer>();
25.
26. int count=0;//定义计数变量
27. for (int x=0;x<cha.length ;x++ )
28. {
29. if(!(cha[x]>='a'&&cha[x]<='z'||cha[x]>='A'&&cha[x]<='Z'))
30. continue;//如果字符串中非字母，则不计数
31. Integer value=tm.get(cha[x]);//获取集合中的值
32. if(value!=null)//如果集合中没有该字母，则存入
33. count=value;
34. count++;
35. tm.put(cha[x],count);//存入键值对
36. count=0;//复位计数变量
37. }
38.
39. StringBuilder sb=new StringBuilder();//定义一个容器
40.
41. //遍历集合，取出并以题目格式存入容器中
42. for(Iterator<Character> it=tm.keySet().iterator();it.hasNext();)
43. {
44. Character ch=it.next();
45. Integer value=tm.get(ch);
46. sb.append(ch+"("+value+")");
47. }
48. return sb.toString();//返回字符串
49. }
50. }
六、Map扩展知识
在很多项目中，应用比较多的是一对多的映射关系，这就可以通过嵌套的形式将多个映射定义到一个大的集合中，并将大的集合分级处理，形成一个体系。
如：
[java] view plaincopy
1. /*
2. map扩展知识。
3. map集合被使用是因为具备映射关系。
4. 以下是班级对应学生，而学生中学号对应着姓名的映射关系：
5. "yureban" Student("01" "zhangsan");
6.
7. "yureban" Student("02" "lisi");
8.
9. "jiuyeban" "01" "wangwu";
10. "jiuyeban" "02" "zhaoliu";
11.
12. 就如同一个学校有多个教室。每一个教室都有名称。
13. */
14. import java.util.*;
15.
16. class MapExpandKnow
17. {
18. public static void main(String[] args)
19. {
20. //预热班集合
21. HashMap<String,String> yureban=new HashMap<String,String>();
22. //就业班集合
23. HashMap<String,String> jiuyeban=new HashMap<String,String>();
24. //学校集合
25. HashMap<String,HashMap<String,String>> czbk=new HashMap<String,HashMap<String,String>>();
26.
27. //学校中班级集合和名称的映射
28. czbk.put("yureban",yureban);
29. czbk.put("jiuyueban",jiuyeban);
30.
31. //预热班级中学号与姓名的映射
32. yureban.put("01","zhangsan");
33. yureban.put("02","lisi");
34.
35. //就业班级中学号与姓名的映射
36. jiuyeban.put("01","wangwu");
37. jiuyeban.put("02","zhouqi");
38.
39. //直接显示全部学生信息
40. getAllStudentInfo(czbk);
41.
42. }
43. //定义一个方法获取全部学生信息，包括在哪个班级，叫什么名字，学号多少
44. public static void getAllStudentInfo(HashMap<String ,HashMap<String,String>> hm)
45. {
46. for (Iterator<String> it=hm.keySet().iterator();it.hasNext() ; )//用keySet取出方式
47. {
48. String s= it.next();//班级名称
49. System.out.println(s+":");
50. HashMap<String,String> stu=hm.get(s);//班级集合
51.
52. getStudentInfo(stu);
53. }
54. }
55.
56. //获取班级中学生的信息，包括姓名和学号
57. public static void getStudentInfo(HashMap<String,String> hm)
58. {
59. for (Iterator<String> it=hm.keySet().iterator();it.hasNext() ; )
60. {
61. String key=it.next();//学号
62. String value=hm.get(key);//姓名
63. System.out.println(key+"..."+value);
64. }
65. }
66. }
-----------android培训、java培训、java学习型技术博客、期待与您交流！------------
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- JAVA中的集合框架
- java 获取当前时间及年月日时分秒
- Java 理论与实践: 正确使用 Volatile 变量
- JDK1.5——synchronized升级版（显示的Lock操作）
- Java调用.NET 的Web Service服务故障排除
- 基于lucene的java开发环境配置
- java多进程中waitFor()的作用
- java多进程中waitFor()的作用
- 为经典版eclipse增加web and JavaEE插件
- Spring MVC 如何上传多个文件到指定位置
- struts 下载中文名文件
- java eclipse初次使用前的配置技巧汇总
- Spring @Transactional使用的示例
- Spring学习笔记之aop动态代理（3）
- Spring学习笔记之aop动态代理（3）
- Java编程中二维数组的初始化和基本操作实例
- Gradle Plugin Samples 之 Gradle Eclipse Compatible （三）
- eclipse用华为手机调试，用file explorer 打开data/data下的包名导出数据库
- struts2中action的XXX_* metend={1}
- 早晨起来看了看流的概念，又搞出乱码了-.-! 最后解决了。