java基础-集合

第1章 List接口

我们掌握了Collection接口的使用后，再来看看Collection接口中的子类，他们都具备那些特性呢？

接下来，我们一起学习Collection中的常用几个子类（List集合、Set集合）。

1.1 List接口介绍

查阅API，看List的介绍。有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。与 set 不同，列表通常允许重复的元素。

看完API，我们总结一下：

List接口：

l 它是一个元素存取有序的集合。例如，存元素的顺序是11、22、33。那么集合中，元素的存储就是按照11、22、33的顺序完成的）。

l 它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素（与数组的索引是一个道理）。

l 集合中可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素。

List接口的常用子类有：

l ArrayList集合

l LinkedList集合

1.2 List接口中常用的方法

l 增加元素方法

l add(Object e)：向集合末尾处，添加指定的元素

l add(int index, Object e)：向集合指定索引处，添加指定的元素，原有元素依次后移

l 删除元素删除

l remove(Object e)：将指定元素对象，从集合中删除，返回值为被删除的元素

l remove(int index)：将指定索引处的元素，从集合中删除，返回值为被删除的元素

l 替换元素方法

l set(int index, Object e)：将指定索引处的元素，替换成指定的元素，返回值为替换前的元素

l 查询元素方法

l get(int index)：获取指定索引处的元素，并返回该元素

方法演示：

 1 List<String> list = new ArrayList<String>();
 2 
 3 //1,添加元素。
 4 
 5 list.add("小红");
 6 
 7 list.add("小梅");
 8 
 9 list.add("小强");
10 
11 //2,插入元素。插入元素前的集合["小红","小梅","小强"]
12 
13 list.add(1, "老王"); //插入元素后的集合["小红","老王","小梅","小强"]
14 
15 //3,删除元素。
16 
17 list.remove(2);// 删除元素后的集合["小红","老王","小强"]
18 
19 //4,修改元素。
20 
21 list.set(1, "隔壁老王");// 修改元素后的集合["小红","隔壁老王","小强"]
22 
23  
24 
25 Iterator<String> it = list.iterator();
26 
27 　　while (it.hasNext()) {
28 
29 　　String str = it.next();
30 
31 　　System.out.println(str);
32 
33 }

View Code

由于List集合拥有索引，因此List集合迭代方式除了使用迭代器之外，还可以使用索引进行迭代。

1 for (int i = 0; i < list.size(); i++) {
2 
3 　　String str = list.get(i);
4 
5 　　System.out.println(str);
6 
7 }

1.2.1 Iterator的并发修改异常

在list集合迭代元素中，对元素进行判断，一旦条件满足就添加一个新元素。代码如下

 1 public class IteratorDemo {
 2 
 3 　　//在list集合迭代元素中，对元素进行判断，一旦条件满足就添加一个新元素
 4 
 5 　　public static void main(String[] args) {
 6 
 7 　　//创建List集合
 8 
 9 　　List<String> list = new ArrayList<String>();
10 
11 　　//给集合中添加元素
12 
13 　　list.add("abc1");
14 
15 　　list.add("abc2");
16 
17 　　list.add("abc3");
18 
19 　　list.add("abc4");
20 
21 　　//迭代集合，当有元素为"abc2"时，集合加入新元素"itcast"
22 
23 　　Iterator<String> it = list.iterator();
24 
25 　　while(it.hasNext()){
26 
27 　　　　String str = it.next();
28 
29 　　　　//判断取出的元素是否是"abc2"，是就添加一个新元素
30 
31 　　if("abc2".equals(str)){
32 
33 　　　　list.add("itcast");// 该操作会导致程序出错
34 
35 　　}
36 
37 }
38 
39 //打印容器中的元素
40 
41 　　System.out.println(list);
42 
43 }
44 
45 }

View Code

运行上述代码发生了错误 java.util.ConcurrentModificationException这是什么原因呢？

在迭代过程中，使用了集合的方法对元素进行操作。导致迭代器并不知道集合中的变化，容易引发数据的不确定性。

并发修改异常解决办法：在迭代时，不要使用集合的方法操作元素。

那么想要在迭代时对元素操作咋办？通过ListIterator迭代器操作元素是可以的，ListIterator的出现，解决了使用Iterator迭代过程中可能会发生的错误情况。

1.3 List集合存储数据的结构

List接口下有很多个集合，它们存储元素所采用的结构方式是不同的，这样就导致了这些集合有它们各自的特点，供给我们在不同的环境下进行使用。数据存储的常用结构有：堆栈、队列、数组、链表。我们分别来了解一下：

l 堆栈，采用该结构的集合，对元素的存取有如下的特点：

l 先进后出（即，存进去的元素，要在后它后面的元素依次取出后，才能取出该元素）。例如，子弹压进弹夹，先压进去的子弹在下面，后压进去的子弹在上面，当开枪时，先弹出上面的子弹，然后才能弹出下面的子弹。

l 栈的入口、出口的都是栈的顶端位置

l 压栈：就是存元素。即，把元素存储到栈的顶端位置，栈中已有元素依次向栈底方向移动一个位置。

l 弹栈：就是取元素。即，把栈的顶端位置元素取出，栈中已有元素依次向栈顶方向移动一个位置。

l 队列，采用该结构的集合，对元素的存取有如下的特点：

l 先进先出（即，存进去的元素，要在后它前面的元素依次取出后，才能取出该元素）。例如，安检。排成一列，每个人依次检查，只有前面的人全部检查完毕后，才能排到当前的人进行检查。

l 队列的入口、出口各占一侧。例如，下图中的左侧为入口，右侧为出口。

l 数组，采用该结构的集合，对元素的存取有如下的特点：

l 查找元素快：通过索引，可以快速访问指定位置的元素

l 增删元素慢：

l 指定索引位置增加元素：需要创建一个新数组，将指定新元素存储在指定索引位置，再把原数组元素根据索引，复制到新数组对应索引的位置。如下图

l 指定索引位置删除元素：需要创建一个新数组，把原数组元素根据索引，复制到新数组对应索引的位置，原数组中指定索引位置元素不复制到新数组中。如下图

l 链表，采用该结构的集合，对元素的存取有如下的特点：

l 多个节点之间，通过地址进行连接。例如，多个人手拉手，每个人使用自己的右手拉住下个人的左手，依次类推，这样多个人就连在一起了。

l 查找元素慢：想查找某个元素，需要通过连接的节点，依次向后查找指定元素

l 增删元素快：

l 增加元素：操作如左图，只需要修改连接下个元素的地址即可。

l 删除元素：操作如右图，只需要修改连接下个元素的地址即可。

1.4 ArrayList集合

ArrayList集合数据存储的结构是数组结构。元素增删慢，查找快，由于日常开发中使用最多的功能为查询数据、遍历数据，所以ArrayList是最常用的集合。

许多程序员开发时非常随意地使用ArrayList完成任何需求，并不严谨，这种用法是不提倡的。

1.5 LinkedList集合

LinkedList集合数据存储的结构是链表结构。方便元素添加、删除的集合。实际开发中对一个集合元素的添加与删除经常涉及到首尾操作，而LinkedList提供了大量首尾操作的方法。如下图

LinkedList是List的子类，List中的方法LinkedList都是可以使用，这里就不做详细介绍，我们只需要了解LinkedList的特有方法即可。在开发时，LinkedList集合也可以作为堆栈，队列的结构使用。

方法演示：

 1 LinkedList<String> link = new LinkedList<String>();
 2 
 3 //添加元素
 4 
 5 link.addFirst("abc1");
 6 
 7 link.addFirst("abc2");
 8 
 9 link.addFirst("abc3");
10 
11 //获取元素
12 
13 System.out.println(link.getFirst());
14 
15 System.out.println(link.getLast());
16 
17 //删除元素
18 
19 System.out.println(link.removeFirst());
20 
21 System.out.println(link.removeLast());
22 
23  
24 
25 while(!link.isEmpty()){ //判断集合是否为空
26 
27 　　System.out.println(link.pop()); //弹出集合中的栈顶元素
28 
29  }

View Code

1.6 Vector集合

Vector集合数据存储的结构是数组结构，为JDK中最早提供的集合。Vector中提供了一个独特的取出方式，就是枚举Enumeration，它其实就是早期的迭代器。此接口Enumeration的功能与 Iterator 接口的功能是类似的。Vector集合已被ArrayList替代。枚举Enumeration已被迭代器Iterator替代。

l Vector常见的方法：

l Enumeration枚举常见的方法：

l Vector集合对ArrayList集合使用的对比

第2章 Set接口

学习Collection接口时，记得Collection中可以存放重复元素，也可以不存放重复元素，那么我们知道List中是可以存放重复元素的。那么不重复元素给哪里存放呢？那就是Set接口，它里面的集合，所存储的元素就是不重复的。

2.1 Set接口介绍

查阅Set集合的API介绍，通过元素的equals方法，来判断是否为重复元素，

2.2 HashSet集合介绍

查阅HashSet集合的API介绍：此类实现Set接口，由哈希表支持（实际上是一个 HashMap集合）。HashSet集合不能保证的迭代顺序与元素存储顺序相同。

HashSet集合，采用哈希表结构存储数据，保证元素唯一性的方式依赖于：hashCode()与equals()方法。

2.3 HashSet集合存储数据的结构（哈希表）

什么是哈希表呢？

哈希表底层使用的也是数组机制，数组中也存放对象，而这些对象往数组中存放时的位置比较特殊，当需要把这些对象给数组中存放时，那么会根据这些对象的特有数据结合相应的算法，计算出这个对象在数组中的位置，然后把这个对象存放在数组中。而这样的数组就称为哈希数组，即就是哈希表。

当向哈希表中存放元素时，需要根据元素的特有数据结合相应的算法，这个算法其实就是Object类中的hashCode方法。由于任何对象都是Object类的子类，所以任何对象有拥有这个方法。即就是在给哈希表中存放对象时，会调用对象的hashCode方法，算出对象在表中的存放位置，这里需要注意，如果两个对象hashCode方法算出结果一样，这样现象称为哈希冲突，这时会调用对象的equals方法，比较这两个对象是不是同一个对象，如果equals方法返回的是true，那么就不会把第二个对象存放在哈希表中，如果返回的是false，就会把这个值存放在哈希表中。

总结：保证HashSet集合元素的唯一，其实就是根据对象的hashCode和equals方法来决定的。如果我们往集合中存放自定义的对象，那么保证其唯一，就必须复写hashCode和equals方法建立属于当前对象的比较方式。

2.4 HashSet存储JavaAPI中的类型元素

给HashSet中存储JavaAPI中提供的类型元素时，不需要重写元素的hashCode和equals方法，因为这两个方法，在JavaAPI的每个类中已经重写完毕，如String类、Integer类等。

l 创建HashSet集合，存储String对象。

 1 public class HashSetDemo {
 2 
 3 　　public static void main(String[] args) {
 4 
 5 　　//创建HashSet对象
 6 
 7 　　HashSet<String> hs = new HashSet<String>();
 8 
 9 　　//给集合中添加自定义对象
10 
11 　　hs.add("zhangsan");
12 
13 　　hs.add("lisi");
14 
15 　　hs.add("wangwu");
16 
17 　　hs.add("zhangsan");
18 
19 　　//取出集合中的每个元素
20 
21 　　Iterator<String> it = hs.iterator();
22 
23 　　while(it.hasNext()){
24 
25 　　String s = it.next();
26 
27 　　System.out.println(s);
28 
29 　　}
30 
31 }
32 
33 }

View Code

输出结果如下，说明集合中不能存储重复元素：

wangwu

lisi

zhangsan

2.5 HashSet存储自定义类型元素

给HashSet中存放自定义类型元素时，需要重写对象中的hashCode和equals方法，建立自己的比较方式，才能保证HashSet集合中的对象唯一

l 创建自定义对象Student

  1 public class Student {
  2 
  3 　　private String name;
  4 
  5 　　private int age;
  6 
  7 　　public Student(String name, int age) {
  8 
  9 　　super();
 10 
 11 　　this.name = name;
 12 
 13 　　this.age = age;
 14 
 15 }
 16 
 17 public String getName() {
 18 
 19 　　return name;
 20 
 21 }
 22 
 23 public void setName(String name) {
 24 
 25 　　this.name = name;
 26 
 27 }
 28 
 29 public int getAge() {
 30 
 31 　　return age;
 32 
 33 }
 34 
 35 public void setAge(int age) {
 36 
 37 　　this.age = age;
 38 
 39 }
 40 
 41 @Override
 42 
 43 public String toString() {
 44 
 45 　　return "Student [name=" + name + ", age=" + age + "]";
 46 
 47 }
 48 
 49 @Override
 50 
 51 public int hashCode() {
 52 
 53 　　final int prime = 31;
 54 
 55 　　int result = 1;
 56 
 57 　　result = prime * result + age;
 58 
 59 　　result = prime * result + ((name == null) ? 0 : name.hashCode());
 60 
 61 　　return result;
 62 
 63 }
 64 
 65 @Override
 66 
 67 public boolean equals(Object obj) {
 68 
 69 　　if (this == obj)
 70 
 71 　　return true;
 72 
 73 　　if(!(obj instanceof Student)){
 74 
 75 　　System.out.println("类型错误");
 76 
 77 　　return false;
 78 
 79 　　}
 80 
 81 　　Student other = (Student) obj;
 82 
 83 　　return this.age ==  other.age && this.name.equals(other.name);
 84 
 85 　　}
 86 
 87 }
 88 
 89  
 90 
 91 l 创建HashSet集合，存储Student对象。
 92 
 93 public class HashSetDemo {
 94 
 95 　　public static void main(String[] args) {
 96 
 97 　　//创建HashSet对象
 98 
 99 　　HashSet hs = new HashSet();
100 
101 　　//给集合中添加自定义对象
102 
103 　　hs.add(new Student("zhangsan",21));
104 
105 　　hs.add(new Student("lisi",22));
106 
107 　　hs.add(new Student("wangwu",23));
108 
109 　　hs.add(new Student("zhangsan",21));
110 
111 　　//取出集合中的每个元素
112 
113 　　Iterator it = hs.iterator();
114 
115 　　while(it.hasNext()){
116 
117 　　Student s = (Student)it.next();
118 
119 　　System.out.println(s);
120 
121 　　}
122 
123 }
124 
125 }

View Code

输出结果如下，说明集合中不能存储重复元素：

Student [name=lisi, age=22]

Student [name=zhangsan, age=21]

Student [name=wangwu, age=23]

2.6 LinkedHashSet介绍

我们知道HashSet保证元素唯一，可是元素存放进去是没有顺序的，那么我们要保证有序，怎么办呢？

在HashSet下面有一个子类LinkedHashSet，它是链表和哈希表组合的一个数据存储结构。

演示代码如下：

 1 public class LinkedHashSetDemo {
 2 
 3 　　public static void main(String[] args) {
 4 
 5 　　　　Set<String> set = new LinkedHashSet<String>();
 6 
 7 　　　　set.add("bbb");
 8 
 9 　　　　set.add("aaa");
10 
11 　　　　set.add("abc");
12 
13 　　　　set.add("bbc");
14 
15 　　　　Iterator it = set.iterator();
16 
17 　　　　while (it.hasNext()) {
18 
19 　　　　　　System.out.println(it.next());
20 
21 　　　　}
22 
23 　　}
24 
25 }

View Code

输出结果如下，LinkedHashSet集合保证元素的存入和取出的顺序：

bbb

aaa

abc

bbc

第3章判断集合元素唯一的原理

3.1 ArrayList的contains方法判断元素是否重复原理

ArrayList的contains方法会使用调用方法时，传入的元素的equals方法依次与集合中的旧元素所比较，从而根据返回的布尔值判断是否有重复元素。此时，当ArrayList存放自定义类型时，由于自定义类型在未重写equals方法前，判断是否重复的依据是地址值，所以如果想根据内容判断是否为重复元素，需要重写元素的equals方法。

3.2 HashSet的add/contains等方法判断元素是否重复原理

Set集合不能存放重复元素，其添加方法在添加时会判断是否有重复元素，有重复不添加，没重复则添加。

HashSet集合由于是无序的，其判断唯一的依据是元素类型的hashCode与equals方法的返回结果。规则如下：

先判断新元素与集合内已经有的旧元素的HashCode值

l 如果不同，说明是不同元素，添加到集合。

l 如果相同，再判断equals比较结果。返回true则相同元素；返回false则不同元素，添加到集合。

所以，使用HashSet存储自定义类型，如果没有重写该类的hashCode与equals方法，则判断重复时，使用的是地址值，如果想通过内容比较元素是否相同，需要重写该元素类的hashcode与equals方法。

第4章总结

4.1 知识点总结

l List与Set集合的区别？

List:

它是一个有序的集合(元素存与取的顺序相同)

它可以存储重复的元素

Set:

它是一个无序的集合(元素存与取的顺序可能不同)

它不能存储重复的元素

l List集合中的特有方法

l void add(int index, Object element) 将指定的元素，添加到该集合中的指定位置上

l Object get(int index)返回集合中指定位置的元素。

l Object remove(int index) 移除列表中指定位置的元素, 返回的是被移除的元素

l Object set(int index, Object element)用指定元素替换集合中指定位置的元素,返回值的更新前的元素

l ArrayList:

底层数据结构是数组，查询快，增删慢

l LinkedList:

底层数据结构是链表，查询慢，增删快

l HashSet:

元素唯一，不能重复

底层结构是哈希表结构

元素的存与取的顺序不能保证一致

如何保证元素的唯一的？

重写hashCode() 与 equals()方法

l LinkedHashSet:

元素唯一不能重复

底层结构是哈希表结构 + 链表结构

元素的存与取的顺序一致

第1章 Map接口

1.1 Map接口概述

我们通过查看Map接口描述，发现Map接口下的集合与Collection接口下的集合，它们存储数据的形式不同，如下图。

l Collection中的集合，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储。

l Map中的集合，元素是成对存在的(理解为夫妻)。每个元素由键与值两部分组成，通过键可以找对所对应的值。

l Collection中的集合称为单列集合，Map中的集合称为双列集合。

l 需要注意的是，Map中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。

l Map中常用的集合为HashMap集合、LinkedHashMap集合。

1.2 Map接口中常用集合概述

通过查看Map接口描述，看到Map有多个子类，这里我们主要讲解常用的HashMap集合、LinkedHashMap集合。

l HashMap<K,V>：存储数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

l LinkedHashMap<K,V>：HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

l 注意：Map接口中的集合都有两个泛型变量<K,V>,在使用时，要为两个泛型变量赋予数据类型。两个泛型变量<K,V>的数据类型可以相同，也可以不同。

1.3 Map接口中的常用方法

l put方法：将指定的键与值对应起来，并添加到集合中

l 方法返回值为键所对应的值

使用put方法时，若指定的键(key)在集合中没有，则没有这个键对应的值，返回null，并把指定的键值添加到集合中；

使用put方法时，若指定的键(key)在集合中存在，则返回值为集合中键对应的值（该值为替换前的值），并把指定键所对应的值，替换成指定的新值。

l get方法：获取指定键(key)所对应的值(value)

l remove方法：根据指定的键(key)删除元素，返回被删除元素的值(value)。

Map接口的方法演示

 1 public class MapDemo {
 2 
 3 　　public static void main(String[] args) {
 4 
 5 　　　　//创建Map对象
 6 
 7 　　　　Map<String, String> map = new HashMap<String,String>();
 8 
 9 　　　　//给map中添加元素
10 
11 　　　　map.put("星期一", "Monday");
12 
13 　　　　map.put("星期日", "Sunday");
14 
15 　　　　System.out.println(map); // {星期日=Sunday, 星期一=Monday}
16 
17  
18 
19 　　　　//当给Map中添加元素，会返回key对应的原来的value值，若key没有对应的值，返回null
20 
21 　　　　System.out.println(map.put("星期一", "Mon")); // Monday
22 
23 　　　　System.out.println(map); // {星期日=Sunday, 星期一=Mon}
24 
25  
26 
27 　　　　//根据指定的key获取对应的value
28 
29 　　　　String en = map.get("星期日");
30 
31 　　　　System.out.println(en); // Sunday
32 
33  　　
34 　　　　//根据key删除元素,会返回key对应的value值
35 
36 　　　　String value = map.remove("星期日");
37 
38 　　　　System.out.println(value); // Sunday
39 
40 　　　　System.out.println(map); // {星期一=Mon}
41 
42 　　}
43 
44 }

View Code

1.4 Map集合遍历键找值方式

键找值方式：即通过元素中的键，获取键所对应的值

操作步骤与图解：

1.获取Map集合中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键

2.遍历键的Set集合，得到每一个键

3.根据键，获取键所对应的值

代码演示：

 1 public class MapDemo {
 2 
 3 　　public static void main(String[] args) {
 4 
 5 　　　　//创建Map对象
 6 
 7 　　　　Map<String, String> map = new HashMap<String,String>();
 8 
 9 　　　　//给map中添加元素
10 
11 　　　　map.put("邓超", "孙俪");
12 
13 　　　　map.put("李晨", "范冰冰");
14 
15 　　　　map.put("刘德华", "柳岩");
16 
17 　　　　//获取Map中的所有key
18 
19 　　　　Set<String> keySet = map.keySet();
20 
21 　　　　//遍历存放所有key的Set集合
22 
23 　　　　Iterator<String> it =keySet.iterator();
24 
25 　　　　while(it.hasNext()){
26 
27 　　　　//得到每一个key
28 
29 　　　　String key = it.next();
30 
31 　　　　//通过key获取对应的value
32 
33 　　　　String value = map.get(key);
34 
35 　　　　System.out.println(key+"="+value);
36 
37 　　　　}
38 
39 　　}
40 
41 }

View Code

1.5 Entry键值对对象

在Map类设计时，提供了一个嵌套接口：Entry。Entry将键值对的对应关系封装成了对象。即键值对对象，这样我们在遍历Map集合时，就可以从每一个键值对（Entry）对象中获取对应的键与对应的值。

l Entry是Map接口中提供的一个静态内部嵌套接口。

l getKey()方法：获取Entry对象中的键

l getValue()方法：获取Entry对象中的值

l entrySet()方法：用于返回Map集合中所有的键值对(Entry)对象，以Set集合形式返回。

1.6 Map集合遍历键值对方式

键值对方式：即通过集合中每个键值对(Entry)对象，获取键值对(Entry)对象中的键与值。

操作步骤与图解：

1.获取Map集合中，所有的键值对(Entry)对象，以Set集合形式返回。

2.遍历包含键值对(Entry)对象的Set集合，得到每一个键值对(Entry)对象

3.通过键值对(Entry)对象，获取Entry对象中的键与值。

 1 public class MapDemo {
 2 
 3 　　public static void main(String[] args) {
 4 
 5 　　　　//创建Map对象
 6 
 7 　　　　Map<String, String> map = new HashMap<String,String>();
 8 
 9 　　　　//给map中添加元素
10 
11 　　　　map.put("邓超", "孙俪");
12 
13 　　　　map.put("李晨", "范冰冰");
14 
15 　　　　map.put("刘德华", "柳岩");
16 
17 　　　　//获取Map中的所有key与value的对应关系
18 
19 　　　　Set<Map.Entry<String,String>> entrySet = map.entrySet();
20 
21 　　　　//遍历Set集合
22 
23 　　　　Iterator<Map.Entry<String,String>> it =entrySet.iterator();
24 
25 　　　　while(it.hasNext()){
26 
27 　　　　　　//得到每一对对应关系
28 
29 　　　　　　Map.Entry<String,String> entry = it.next();
30 
31 　　　　　　//通过每一对对应关系获取对应的key
32 
33 　　　　　　String key = entry.getKey();
34 
35 　　　　　　//通过每一对对应关系获取对应的value
36 
37 　　　　　　String value = entry.getValue();
38 
39 　　　　　　System.out.println(key+"="+value);
40 
41 　　　　}
42 
43 　　}
44 
45 }

View Code

注意：Map集合不能直接使用迭代器或者foreach进行遍历。但是转成Set之后就可以使用了。

1.7 HashMap存储自定义类型键值

练习：每位学生（姓名，年龄）都有自己的家庭住址。那么，既然有对应关系，则将学生对象和家庭住址存储到map集合中。学生作为键, 家庭住址作为值。

注意，学生姓名相同并且年龄相同视为同一名学生。

l 学生类

 1 public class Student {
 2 
 3 　　private String name;
 4 
 5 　　private int age;
 6 
 7  
 8 
 9 　　//编写构造方法，文档中已省略
10 
11 　　//编写get,set方法，文档中已省略
12 
13 　　//编写toString方法，文档中已省略
14 
15 }

l 测试类

 1 public class HashMapTest {
 2 
 3 　　public static void main(String[] args) {
 4 
 5 　　//1,创建hashmap集合对象。
 6 
 7 　　Map<Student,String> map = new HashMap<Student,String>();
 8 
 9  
10 
11 　　//2,添加元素。
12 
13 　　map.put(new Student("lisi",28), "上海");
14 
15 　　map.put(new Student("wangwu",22), "北京");
16 
17 　　map.put(new Student("zhaoliu",24), "成都");
18 
19 　　map.put(new Student("zhouqi",25), "广州");
20 
21 　　map.put(new Student("wangwu",22), "南京");
22 
23  
24 
25 　　//3,取出元素。键找值方式
26 
27 　　Set<Student> keySet = map.keySet();
28 
29 　　for(Student key : keySet){
30 
31 　　　　String value = map.get(key);
32 
33 　　　　System.out.println(key.toString()+"....."+value);
34 
35 　　}
36 
37  
38 
39 　　//取出元素。键值对方式
40 
41 　　Set<Map.Entry<Student, String>> entrySet = map.entrySet();
42 
43 　　for (Map.Entry<Student, String> entry : entrySet) {
44 
45 　　　　Student key = entry.getKey();
46 
47 　　　　String value = entry.getValue();
48 
49 　　　　System.out.println(key.toString()+"....."+value);
50 
51 　　　　}
52 
53 　　}
54 
55 }

View Code

l 当给HashMap中存放自定义对象时，如果自定义对象作为key存在，这时要保证对象唯一，必须复写对象的hashCode和equals方法(如果忘记，请回顾HashSet存放自定义对象)。

l 如果要保证map中存放的key和取出的顺序一致，可以使用LinkedHashMap集合来存放。

1.8 静态导入

在导包的过程中我们可以直接导入静态部分，这样某个类的静态成员就可以直接使用了。在源码中经常会出现静态导入。

静态导入格式：

import static XXX.YYY; 导入后YYY可直接使用。

例如：Map.Entry的访问，简化后为Entry

 1 import static java.util.Map.Entry;
 2 
 3 public class HashMapTest {
 4 
 5 　　public static void main(String[] args) {
 6 
 7 　　//1,创建hashmap集合对象。
 8 
 9 　　Map<Student,String> map = new HashMap<Student,String>();
10 
11  
12 
13 　　//取出元素。键值对方式
14 
15 　　//Set<Map.Entry<Student, String>> entrySet = map.entrySet();
16 
17 　　Set<Entry<Student, String>> entrySet = map.entrySet();
18 
19  
20 
21 　　//for (Map.Entry<Student, String> entry : entrySet) {
22 
23 　　for (Entry<Student, String> entry : entrySet) {
24 
25 　　　　Student key = entry.getKey();
26 
27 　　　　String value = entry.getValue();
28 
29 　　　　System.out.println(key.toString()+"....."+value);
30 
31 　　　　}
32 
33 　　}
34 
35 }

View Code

1.9 可变参数

在JDK1.5之后，如果我们定义一个方法需要接受多个参数，并且多个参数类型一致，我们可以对其简化成如下格式：

修饰符返回值类型方法名(参数类型... 形参名){ }

其实这个书写完全等价与

修饰符返回值类型方法名(参数类型[] 形参名){ }

只是后面这种定义，在调用时必须传递数组，而前者可以直接传递数据即可。

jdk1.5以后。出现了简化操作。... 用在参数上，称之为可变参数。

同样是代表数组，但是在调用这个带有可变参数的方法时，不用创建数组(这就是简单之处)，直接将数组中的元素作为实际参数进行传递，其实编译成的class文件，将这些元素先封装到一个数组中，在进行传递。这些动作都在编译.class文件时，自动完成了。

代码演示：

public class ParamDemo {

　　public static void main(String[] args) {

　　int[] arr = {21,89,32};

　　int sum = add(arr);

　　System.out.println(sum);

　　sum = add(21,89,32);//可变参数调用形式

　　System.out.println(sum);

}

//JDK1.5之后写法

 1 public static int add(int...arr){
 2 
 3 　　int sum = 0;
 4 
 5 　　for (int i = 0; i < arr.length; i++) {
 6 
 7 　　　　sum += arr[i];
 8 
 9 　　}
10 
11 　　return sum;
12 
13 }

View Code

//原始写法

 1 /*
 2 
 3 public static int add(int[] arr) {
 4 
 5 　　int sum = 0;
 6 
 7 　　for (int i = 0; i < arr.length; i++) {
 8 
 9 　　　　sum += arr[i];
10 
11 　　}
12 
13 　　return sum;
14 
15 　　}
16 
17 */
18 
19 }

View Code

l 上述add方法在同一个类中，只能存在一个。因为会发生调用的不确定性

注意：如果在方法书写时，这个方法拥有多参数，参数中包含可变参数，可变参数一定要写在参数列表的末尾位置。

1.10 Collections集合工具类

Collections是集合工具类，用来对集合进行操作。部分方法如下：

l public static <T> void sort(List<T> list) // 集合元素排序

//排序前元素list集合元素 [33,11,77,55]

Collections.sort( list );

//排序后元素list集合元素 [11,33,55,77]

l public static void shuffle(List<?> list) // 集合元素存储位置打乱

//list集合元素 [11,33,55,77]

Collections.shuffle( list );

//使用shuffle方法后，集合中的元素为[77,33,11,55]，每次执行该方法，集合中存储的元素位置都会随机打乱

1.11 集合嵌套

集合嵌套并不是一个新的知识点，仅仅是集合内容又是集合，如Collection集合嵌套、Collection集合与Map集合相互嵌套、Map集合嵌套。

l ArrayList嵌套 ArrayList

ArrayList< ArrayList<String> >

Collection< ArrayList<Integer> >

l Map嵌套 ArrayList

HashMap<String, ArrayList<Person>>

ArrayList< HashMap<String, String>>

l Map集合嵌套

HashMap<String, HashMap<String,String>>

HashMap<String, HashMap<Person,String>>

1.12 集合继承体系的面向对象思想

l 接口：用来明确所有集合中该具有的功能，相当于在定义集合功能标准；

l 抽象类：把多个集合中功能实现方式相同的方法，抽取到抽象类实现，具体集合不再遍写，继承使用即可；

l 具体类：继承抽象类，实现接口，重写所有抽象方法，达到具备指定功能的集合。每个具体集合类，根据自身的数据存储结构方式，对接口中的功能方法，进行不同方式的实现。

java基础-集合

第1章 List接口

1.1 List接口介绍

1.2 List接口中常用的方法

1.2.1 Iterator的并发修改异常

1.3 List集合存储数据的结构

1.4 ArrayList集合

1.5 LinkedList集合

1.6 Vector集合

第2章 Set接口

2.1 Set接口介绍

2.2 HashSet集合介绍

2.3 HashSet集合存储数据的结构（哈希表）

2.4 HashSet存储JavaAPI中的类型元素

2.5 HashSet存储自定义类型元素

2.6 LinkedHashSet介绍

第3章 判断集合元素唯一的原理

3.1 ArrayList的contains方法判断元素是否重复原理

3.2 HashSet的add/contains等方法判断元素是否重复原理

第4章 总结

4.1 知识点总结

第1章 Map接口

1.1 Map接口概述

1.2 Map接口中常用集合概述

1.3 Map接口中的常用方法

1.4 Map集合遍历键找值方式

1.5 Entry键值对对象

1.6 Map集合遍历键值对方式

1.7 HashMap存储自定义类型键值

1.8 静态导入

1.9 可变参数

1.10 Collections集合工具类

1.11 集合嵌套

1.12 集合继承体系的面向对象思想

第3章判断集合元素唯一的原理

第4章总结