【Java入门】集合框架

---

学习目标

• 掌握集合框架体系结构

• 掌握List接口存储特点

• 掌握ArrayList类常用方法

• 了解泛型的定义和作用

• 掌握使用集合时使用泛型来约束元素类型

---

一、集合框架体系

思考：既然数组可以存储多个数据，为什么要出现集合？

• 数组的长度是固定的，集合的长度是可变的。

• 使用Java类封装出一个个容器类，开发者只需要直接调用即可，不用再手动创建容器类。

1.1、集合框架概述

集合是Java中提供的一种容器，可以用来存储多个数据，根据不同存储方式形成的体系结构，就叫做集合框架体系（掌握）。集合也时常被称为容器。

List、Set集合是继承了Colection接口，跟Collection是继承关系

而ArrayList、LinkedList跟List是继承关系，HashSet、TreeSet跟Set也是继承关系，HashMap、TreeMap跟Map也是继承关系

• Collection接口：泛指广义上集合，主要表示List和Set两种存储方式。

• List接口：表示列表，规定了允许记录添加顺序，允许元素重复的规范。

• Set接口：表示狭义上集合，规定了不记录添加顺序，不允许元素重复的规范。

• Map接口：表示映射关系，规定了两个集合映射关系的规范。

1.2、集合的分类

根据容器的存储特点的不同，可以分成三种情况：

• List(列表)：允许记录添加顺序，允许元素重复。=> 元素有序且可重复

• Set(数据集)：不记录添加顺序，不允许元素重复。=> 元素无序且唯一

二、List接口

List接口是Collection接口子接口，List接口定义了一种规范，要求该容器允许记录元素的添加顺序，也允许元素重复。那么List接口的实现类都会遵循这一种规范。

List集合存储特点：

• 允许元素重复

• 允许记录元素的添加先后顺序

该接口常用的实现类有：

• ArrayList类：数组列表，表示数组结构，底层采用数组实现，开发中使用对多的实现类，重点。

• LinkedList类：链表，表示双向列表和双向队列结构，采用链表实现，使用不多。

• Stack类：栈，表示栈结构，采用数组实现，使用不多。

• Vector类：向量，其实就是古老的ArrayList，采用数组实现，使用不多。

一般来说，集合接口的实现类命名规则：（底层数据结构 + 接口名）例如：ArrayList

2.1、ArrayList类

ArrayList类，基于数组算法的列表，通过查看源代码会发现底层其实就是一个Object数组。

ArrayList常用方法的API：

public class ArrayListDemo1 {
	public static void main(String[] args) {
		// 创建一个默认长度的列表对象
		List list = new ArrayList();
		// 打印集合中元素的个数
		System.out.println("元素数量："+list.size());//0
		// 添加操作：向列表中添加4个元素
		list.add("Will");
		list.add(100);
		list.add(true);
		list.add("Lucy");
		// 查询操作:
		System.out.println("列表中所有元素："+list);//输出:[Will, 100, true, Lucy]
		System.out.println("元素数量："+list.size());//4
		System.out.println("第一个元素："+list.get(0));//Will
		
		// 修改操作：把索引为2的元素，替换为wolfcode
		list.set(2, "wolfcode");
		System.out.println("修改后："+list);//输出:[Will, 100, wolfcode, Lucy]
		
		// 删除操作：删除索引为1的元素
		list.remove(1);
		System.out.println("删除后："+list);//输出:[Will, wolfcode, Lucy]
	}
}

2.2、LinkedList类

LinkedList类，底层采用链表算法，实现了链表，队列，栈的数据结构。无论是链表还是队列主要操作的都是头和尾的元素，因此在LinkedList类中除了List接口的方法，还有很多操作头尾的方法。

LinkedList常用方法的API：

其余方法：

• boolean offerFirst(Object e) 在此列表的开头插入指定的元素。

• boolean offerLast(Object e) 在此列表末尾插入指定的元素。

• Object peekFirst() 获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。

• Object peekLast() 获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。

• Object pollFirst() 获取并移除此列表的第一个元素；如果此列表为空，则返回 null。

• Object pollLast() 获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。

• void push(Object e) 将元素推入此列表所表示的栈。

• Object pop() 从此列表所表示的栈处弹出一个元素。

• Object peek() 获取但不移除此列表的头（第一个元素）。

LinkedList之所以有这么多方法，是因为自身实现了多种数据结构，而不同的数据结构的操作方法名称不同，在开发中LinkedList使用不是很多，知道存储特点就可以了。

public class LinkedListDemo {
	public static void main(String[] args) {
		LinkedList list = new LinkedList();
		//添加元素
		list.addFirst("A");
		list.addFirst("B");
		System.out.println(list);
		list.addFirst("C");
		System.out.println(list);
		list.addLast("D");
		System.out.println(list);
		//获取元素
		System.out.println("获取第一个元素：" + list.getFirst());//C
		System.out.println("获取最后一个元素：" + list.getLast());//D
		//删除元素
		list.removeFirst();
		System.out.println("删除第一个元素后：" + list);//[B, A, D]
		list.removeLast();
		System.out.println("删除最后一个元素后：" + list);//[B, A]
	}
}

运行结果

[B, A]
[C, B, A]
[C, B, A, D]
获取第一个元素：C
获取最后一个元素：D
删除第一个元素后：[B, A, D]
删除最后一个元素后：[B, A]

三、泛型

3.1、什么是泛型

其实就是一种类型参数，主要用于某个类或接口中数据类型不确定时，可以使用一个标识符来表示未知的数据类型，然后在使用该类或接口时指定该未知类型的真实类型。

泛型可用到的接口、类、方法中，将数据类型作为参数传递，其实更像是一个数据类型模板。

如果不使用泛型，从容器中获取出元素，需要做类型强转，也不能限制容器只能存储相同类型的元素。

List list = new ArrayList();
list.add("A");
list.add("B");
String ele = (String) list.get(0);

3.2、自定义和使用泛型

定义泛型：使用一个标识符，比如T在类中表示一种未知的数据类型。

使用泛型：一般在创建对象时，给未知的类型设置一个具体的类型，当没有指定泛型时，默认类型为Object类型。

需求：定义一个类Point，x和y表示横纵坐标，分别使用String、Integer、Double表示坐标类型。

如果没有泛型需要设计三个类，如下：

定义泛型：

在类上声明使用符号T,表示未知的类型

//在类上声明使用符号T,表示未知的类型
public class Point<T> {
	private T x;
	private T y;
     //省略getter/setter
}

使用泛型：

//没有使用泛型，默认类型是Object
Point p1 = new Point();
Object x1 = p1.getX();
//使用String作为泛型类型
Point<String> p2 = new Point<String>();
String x2 = p2.getX();
//使用Integer作为泛型类型
Point<Integer> p3 = new Point<Integer>();
Integer x3 = p3.getX();

注意：这里仅仅是演示泛型类是怎么回事，并不是要求定义类都要使用泛型。

3.3、在集合中使用泛型

拿List接口和ArrayList类举例。

class ArrayList<E>{ 
	public boolean add(E e){
	
	}
	public E get(int index){  
	
	}
}

此时的E也仅仅是一个占位符，表示元素（Element）的类型，那么当使用容器时给出泛型就表示该容器只能存储某种类型的数据。

//只能存储String类型的集合
List<String> list1 = new ArrayList<String>();
list1.add("A");
list1.add("B");

//只能存储Integer类型的集合
List<Integer> list2 = new ArrayList<Integer>();
list2.add(11);
list2.add(22);

因为前后两个泛型类型相同（也必须相同），泛型类型推断：

List<String> list1 = new ArrayList<String>();
// 可以简写为
List<String> list1 = new ArrayList<>();

通过反编译工具，会发现泛型其实是语法糖，也就是说编译之后，泛型就不存在了。

注意：泛型必须是引用类型，不能是基本数据类型（错误如下）：

List<int> list = new ArrayList<int>();//编译错误

泛型不存在继承的关系（错误如下）：

List<Object> list = new ArrayList<String>();	//错误的

四、集合遍历

4.1、集合元素遍历

对集合中的每一个元素获取出来。

List<String> list = new ArrayList<>();
list.add("西施");
list.add("王昭君");
list.add("貂蝉");
list.add("杨玉环");

使用for遍历

for (int index = 0; index < list.size(); index++) {
	String ele = list.get(index);
	System.out.println(ele);
}

使用迭代器遍历

Iterator表示迭代器对象，迭代器中拥有一个指针，默认指向第一个元素之前，

• boolean hasNext()：判断指针后是否存在下一个元素

• Object next()：获取指针位置下一个元素，获取后指针向后移动一位

Iterator<String> it = list.iterator();
while(it.hasNext()) {
	String ele = it.next();
	System.out.println(ele);
}

操作原理如下图：

注意： 此时，就不能使用两次迭代器，因为第一个迭代器就已经将指针指向了最后一个元素，这样的话第二个迭代器开始的指针一直都是最后一个

使用for-each遍历（推荐使用）

for (String ele : list) {
	System.out.println(ele);
}

通过反编译工具会发现，for-each操作集合时，其实底层依然是Iterator，我们直接使用for-each即可。

4.2、并发修改异常

需求：在迭代集合时删除集合元素，比如删除王昭君。

List<String> list = new ArrayList<>();
list.add("西施");
list.add("王昭君");
list.add("貂蝉");
list.add("杨玉环");

System.out.println(list);
for (String ele : list) {
	if("王昭君".equals(ele)) {
		list.remove(ele);
	}
}
System.out.println(list);

此时报错java.util.ConcurrentModificationException，并发修改异常。

造成该错误的原因是，不允许在迭代过程中改变集合的长度（不能删除和增加）。如果要在迭代过程中删除元素，就不能使用集合的remove方法，只能使用迭代器的remove方法，此时只能使用迭代器来操作，不能使用foreach。

List<String> list = new ArrayList<>();
list.add("西施");
list.add("王昭君");
list.add("貂蝉");
list.add("杨玉环");
System.out.println(list);
//获取迭代器对象
Iterator<String> it = list.iterator();
while(it.hasNext()) {
	String ele = it.next();
	if("王昭君".equals(ele)) {
		it.remove();
	}
}
System.out.println(list);

五、Set接口

​ Set是Collection子接口，Set接口定义了一种规范，也就是该容器不记录元素的添加顺序，也不允许元素重复，那么Set接口的实现类都遵循这一种规范。

Set集合存储特点：

• 不允许元素重复

• 不会记录元素的添加先后顺序

  Set只包含从Collection继承的方法，不过Set无法记住添加的顺序，不允许包含重复的元素。当试图添加两个相同元素进Set集合，添加操作失败，add()方法返回false。

Set接口定义了一种规范，也就是该容器不记录元素的添加顺序，也不允许元素重复。

Set接口常用的实现类有：

• HashSet类：底层采用哈希表实现，开发中使用对多的实现类，重点。
• TreeSet类：底层采用红黑树实现，可以对集合中元素排序，使用不多。

HashSet和TreeSet的API都是一样的：

5.1、HashSet类

HashSet 是Set接口的实现类，底层数据结构是哈希表，集合容器不记录元素的添加顺序，也不允许元素重复。通常我们也说HashSet中的元素是无序的、唯一的。

public class HashSetDemo {
	public static void main(String[] args) {
		Set<String> set = new HashSet<>();
		//添加操作：向列表中添加4个元素
		set.add("Will");
		set.add("wolf");
		set.add("code");
		set.add("Lucy");
        
		//查询操作:
		System.out.println("集合中所有元素：" + set);//[code, wolf, Will, Lucy]
		System.out.println("元素数量：" + set.size());//4
		System.out.println("是否存在某个元素：" + set.contains("code"));//true
		System.out.println("是否存在某个元素：" + set.contains("code2"));//false
        
		//删除操作：删除code元素
		set.remove("code");
		System.out.println("删除后：" + set);//[wolf, Will, Lucy]
		
        //使用for-each遍历
		for (String ele : set) {
			System.out.println(ele);
		}
        
		//使用迭代器遍历
		Iterator<String> it = set.iterator();
		while (it.hasNext()) {
			Object ele = it.next();
			System.out.println(ele);
		}
	}
}

哈希表工作原理:

HashSet底层采用哈希表实现，元素对象的hashCode值决定了在哈希表中的存储位置。

向HashSet添加元素时，经过以下过程：

step 1 : 首先计算要添加元素e的hashCode值，根据 y = k( hashCode ) 计算出元素在哈希表的存储位置，一般计算位置的函数会选择 y = hashcode % 9, 这个函数称为散列函数，可见，散列的位置和添加的位置不一致。

step 2：根据散列出来的位置查看哈希表该位置是否有无元素，如果没有元素，直接添加该元素即可。如果有元素，查看e元素和此位置所有元素的是否相等，如果相等，则不添加，如果不相同，在该位置连接e元素即可。

在哈希表中元素对象的hashCode和equals方法的很重要。

每一个存储到哈希表中的对象，都得覆盖hashCode和equals方法用来判断是否是同一个对象，一般的，根据对象的字段数据比较来判断，通常情况下equals为true的时候hashCode也应该相等。

5.2、TreeSet类

TreeSet类底层才有红黑树算法，会对存储的元素对象默认使用自然排序（从小到大）。

注意：必须保证TreeSet集合中的元素对象是相同的数据类型，否则报错。

public class TreeSetDemo{
	public static void main(String[] args) {
		Set<String> set = new TreeSet<>();
		set.add("wolf");
		set.add("will");
		set.add("sfef");
		set.add("allen");
		System.out.println(set);// [allen, sfef, will, wolf]
	}
}

第一步：插入第一个节点，无须比较，直接作为根节点。

第二步：插入第二个节点，和wolf节点做比较，较小，往左移动。

第三步：插入第三个节点，和wolf节点比较，较小，左移，再和will节点比较，较小，再左移。

第四步：由于TreeSet是平衡二叉树，如果树不平衡，会对节点进行调整。

第五步：插入第四个节点，此时和will节点作比较，较小，左移，再和stef节点做比较，较小，左移。

六、Map接口

6.1、认识Map

Map，翻译为映射，在数学中的解释为：

设A、B是两个非空集合，如果存在一个法则f，使得A中的每个元素a，按法则f，在B中有唯一确定的元素b与之对应，则称f为从A到B的映射，记作f：A→B。

也就是说映射表示两个集合之间各自元素的一种“对应”的关系，在面向对象中我们使用Map来封装和表示这种关系。

​ 从定义和结构图上，可以看出Map并不是集合，而表示两个集合之间的一种关系，故Map没有实现Collection接口。

​ 在Map中，要求A集合中的每一个元素都可以在B集合中找到唯一的一个值与之对应。这句话可以解读为一个A集合元素只能对应一个B集合元素，也就说A集合中的元素是不允许重复的，B集合中的元素可以重复，也可不重复。那么不难推断出A集合应该是一个Set集合，B集合应该是List集合。

我们把A集合中的元素称之为key，把B集合中的元素称之为value。

其实能看出一个Map其实就有多个key-value（键值对）组成的，每一个键值对我们使用Entry表示。

不难发现，一个Map结构也可以理解为是Entry的集合，即Set。

一般的，我们依然习惯把Map称之为集合，不过要区分下，Set和List是单元素集合，Map是双元素集合。

• 单元素集合：每次只能存储一个元素，比如Set和List。

• 双元素集合：每次需要存储两个元素（一个key和一个value），比如Map。

注意：

• Map接口并没有继承于Collection接口也没有继承于Iterable接口，所以不能直接对Map使用for-each操作。

• 如果不能理解Map的结构，就直接记住Map每次需要存储两个值，一个是key，一个是value，其中value表示存储的数据，而key就是这一个value的名字。

6.2、Map常用的API

添加操作

• boolean put(Object key,Object value)：存储一个键值对到Map中

• boolean putAll(Map m)：把m中的所有键值对添加到当前Map中

删除操作

• Object remove(Object key)：从Map中删除指定key的键值对，并返回被删除key对应的value

修改操作

• 无专门的方法，可以调用put方法，存储相同key，不同value的键值对，可以覆盖原来的。

查询操作

• int size()：返回当前Map中键值对个数

• boolean isEmpty()：判断当前Map中键值对个数是否为0.

• Object get(Object key)：返回Map中指定key对应的value值，如果不存在该key，返回null

• boolean containsKey(Object key):判断Map中是否包含指定key

• boolean containsValue(Object value):判断Map中是否包含指定value

• Set keySet()：返回Map中所有key所组成的Set集合

• Collection values()：返回Map中所有value所组成的Collection集合

• Set entrySet()：返回Map中所有键值对所组成的Set集合

注意，标红的是重度使用的方法。

6.3、HashSet

HashMap底层基于哈希表算法，Map中存储的key对象的hashCode值决定了在哈希表中的存储位置，因为Map中的key是Set，所以不能保证添加的先后顺序，也不允许重复。

HashMap key的底层数据结构是哈希表

案例： 统计一个字符串中每个字符出现次数

public class HashMapDemo2{
	public static void main(String[] args) {
		String str = "ABCDEFABCDEABCDABCABA";
		//把字符串转换为char数组
		char[] charArray = str.toCharArray();
		//Map的key存储字符，value存储出现的次数
		Map<Character, Integer> map = new HashMap<>();
		//迭代每一个字符
		for (char ch : charArray) {
			//判断Map中是否已经存储该字符
			if (map.containsKey(ch)) {
				Integer count = map.get(ch);
				//如果已经存储该字符，则把出现次数加上1
				map.put(ch, count+1);
			}else {
				//如果没有存储该字符，则把设置次数为1
				map.put(ch, 1);
			}
		}
		System.out.println(map); 

	}
}

6.4、TreeMap

TreeMap key底层基于红黑树算法，因为Map中的key是Set，所以不能保证添加的先后顺序，也不允许重复，但是Map中存储的key会默认使用自然排序（从小到大），和TreeSet一样，除了可以使用自然排序也可以自定义排序。

需求：测试HashMap和TreeMap中key的顺序

public class App {
	public static void main(String[] args) {
		Map<String, String> map = new HashMap<>();
		map.put("girl4", "杨玉环");
		map.put("girl2", "王昭君");
		map.put("key1", "西施");
		map.put("key3", "貂蝉");
		System.out.println(map);
		//-------------------------------------------
		map = new TreeMap<>(map);
		System.out.println(map);
	}
}

输出结果：

{key1=西施, girl4=杨玉环, key3=貂蝉, girl2=王昭君}
{girl2=王昭君, girl4=杨玉环, key1=西施, key3=貂蝉}