Java基础----Java容器之集合

最新推荐文章于 2023-02-21 19:42:20 发布

原创最新推荐文章于 2023-02-21 19:42:20 发布 · 398 阅读

0 ·

CC 4.0 BY-SA版权

本文详细介绍了Java集合类的结构层次、产生背景、特点、常用类的总结及操作方法，包括List、Set、Map的特性与常用方法，以及如何进行迭代与排序。并通过示例展示了如何使用集合类解决实际问题，如存储对象、排序与查找等。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1、Java中集合类的结构层次图

这是网上下载的清晰地表达了集合类之间的

2、集合的产生

一、为什么出现集合类？

Java属于面向对象的程序语言，为了方便对多个对象进行操作和存储，集合就是存储对象最常见的一种方式。

二、数组和集合类同是容器，有什么不同？

数组只能存储单一类型数据包括对象且长度固定；

集合不考虑泛型可以存储多种类型的数据且长度可变；

集合只能存放引用类型；

集合放原始类型其实是通过装箱拆箱来实现的，说白了以前原生类型只能用数组，现在集合也可以了。

三、集合类的特点

A:集合长度可变；B:存储数据--引用类型当然包括数组。

什么时候使用数组---数组的执行效率更高；

3、常用的集合类总结如下：

List:

有顺序的，元素可以重复；

遍历：for，迭代；

排序：ComparableComparator Collections.sort()

Vector:

底层用数组实现List接口的另一个类；
特点：重量级，占据更多的系统开销，线程安全；

-------------------------------------------------------------------------------------------------

Set：

    无顺序的，元素不可重复（值不相同）；
    遍历：迭代；
    排序：SortedSet
HashSet：

唯一性保证：重复对象equals方法返回为true；

重复对象hashCode方法返回相同的整数，不同对象hashCode尽量保证不同（提高效率）；

SortedSet：

对一个Set排序；
TreeSet：

在元素添加的同时，进行排序。也要给出排序规则；
唯一性保证：根据排序规则，compareTo方法返回为0，就可以认定两个对象中有一个是重复对象。

-------------------------------------------------------------------------------------------------

Map：

元素是键值对：key唯一不可重复，value可重复；

遍历：先迭代遍历key的集合，再根据key得到value；

SortedMap：元素自动对key排序

HashMap:

轻量级，线程不安全，允许key或者value是null；
Hashtable：

重量级，线程安全，不允许key或者value是null；
Properties：Hashtable的子类，key和value都是String

TreeMap：

集合是指一个对象可以容纳了多个对象（不是引用），这个集合对象主要用来管理维护一系列相似的对象。

-------------------------------------------------------------------------------------------------------

4、集合类中常用的操作：

一、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();//创建一个集合

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

打印方法：

Iterator iter = 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 plain copy

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、增

offFirst();

offLast();

2、获取

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

peekFirst();

peekLast();

3、删

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

pollFirst();

pollLast();

[java] view plain copy

1. /*

2. 使用LinkedList模拟一个堆栈或者队列数据结构。

4. 堆栈：先进后出如同一个杯子。

5. 队列：先进先出 First in First out FIFO 如同一个水管。

7. */

8. import java.util.*;

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。底层数据结构是二叉树。比较器：调用comparator接口，重写compare（）方法。

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

二、HasSet

HashSet：线程不安全，存取速度快。

可以通过元素的两个方法，hashCode和equals来完成保证元素唯一性。如果元素的HashCode值相同，才会判断equals是否为true。如果元素的hashCode值不同，不会调用equals。

注意：HashSet对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashCode和equals方法。

示例：

[java] view plain copy

1. /*

2. 往hashSet集合中存入自定对象

3. 姓名和年龄相同为同一个人，重复元素。去除重复元素

4. 思路：1、对人描述，将人的一些属性等封装进对象

5. 2、定义一个HashSet容器，存储人对象

6. 3、取出

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接口，通过重写compare（）方法实现排序；

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

二叉树示意图（排序规律就是大的向右排，小的向左排）

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

2、Tree排序的两种方式

1）第一种排序方式：自然排序

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

示例：

[java] view plain copy

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 plain copy

1. /*

2. 需求：

3. 往TreeSet集合中存储自定义对象学生。

4. 想按照学生的年龄进行排序。

6. */

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 <? extendsK,? 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 plain copy

1. /*

2. 每一个学生都有对应的归属地。

3. 学生Student，地址String。

4. 学生属性：姓名，年龄。

5. 注意：姓名和年龄相同的视为同一个学生。

6. 保证学生的唯一性。

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 plain copy

1. interface Map

2. {

3. public static interface Entry

4. {

5. public abstract Object getKey();

6. public abstract Object getValue();

7. }

8. }

示例：

同上面示例的学生类----

[java] view plain copy

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 plain copy

1. /*

2. 思路：1、将字符串转换为字符数组

3. 2、定义一个TreeMap集合，用于存储字母和字母出现的次数

4. 3、用数组去遍历集合，如果集合中有该字母则次数加1，如果集合中没有则存入

5. 4、将TreeMap集合中的元素转换为字符串

6. */

7. package TreeMapTest;

8. import java.util.*;

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 plain copy

1. /*

2. map扩展知识。

3. map集合被使用是因为具备映射关系。

4. 以下是班级对应学生，而学生中学号对应着姓名的映射关系：

5. "yureban" Student("01" "zhangsan");

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

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. {

[java] view plain copy

1. /*

2. 使用LinkedList模拟一个堆栈或者队列数据结构。

4. 堆栈：先进后出如同一个杯子。

5. 队列：先进先出 First in First out FIFO 如同一个水管。

7. */

8. import java.util.*;

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. }