Java知识梳理---详析三大集合类（附实用例程-+-实践练习题）

凌川江雪
105 阅读14分钟

####0.提要

  • List接口的实现类 List接口的常用实现类有ArrayList与LinkedList.
    • ArrayList类 a. 实现了可变的数组，允许保存所有元素，包括null,并可以根据索引位置对集合进行快速的随机访问； b. 缺点是向指定的索引位置插入对象或删除对象的速度较慢。
    • LinkedList类 a.采用链表结构保存对象。 b.优点是便于向集合中插入和删除对象，需要向集合中插入、删除对象时，使用LinkedList类实现的List集合的效率较高： c. 但对于随机访问集合中的对象，使用LinkedList类实现List集合的效率较低。
  • Set集合
    • Set集合中的对象不按特定的方式排序，只是简单地把对象加入集合中；
    • Set集合中不能包含重复对象；
    • Set集合由Set接口和Set接口的实现类组成。
    • Set接口继承了Collection接口，因此包含Collection接口的所有方法。
      Set接口常用的实现类有HashSet类与TreeSet类。
    • HashSet类 a. 实现Set接口，由哈希表（实际上是一个HashMap实例）支持。 b. 它不保证Set的迭代顺序，特别是它不保证该顺序恒久不变。 c .此类允许使用null元素。
    • TreeSet类 a. 不仅实现了Set接口，还实现了java.util.SortedSet接口， b. 因此，TreeSet类实现的Set集合在遍历集合时按照自然顺序递增排序；*********%%%%%%%%%%*********** c. 也可以按照指定比较器递增排序； d. 即可以通过比较器对用TreeSet类实现的Set集合中的对象进行排序。
  • Map集合
    • Map集合没有继承Collection接口，其提供的是key到value的映射；
    • Map中不能包含相同的key,每个key只能映射一个value；
    • key还决定了存储对象在映射中的存储位置， 但不是由key对象本身决定的，而是通过一种“散列技术”进行处理，产生一个散列码的整数值；
    • 散列码通常用作一个偏移量，该偏移量对应分配给映射的内存区域的起始位置，从而确定存储对象在映射中的存储位置；
    • Map集合包括Map接口以及Map接口的所有实现类。
    • Map接口
      • Map接口提供了将key映射到值的对象。
      • 一个映射不能包含重复的key，每个key最多只能映射到一个值。
      • Map接口中同样提供了集合的常用方法，除此之外还包括如下表所示的常用方法： 注意：Map集合中允许值对象是null，而且没有个数限制，例如，可通过“map.put("05",null)”语句向集合中添加对象。
    • 5.2 Map接口的实现类
      • Map接口常用的实现类有HashMap和TreeMap；
      • 建议使用HashMap类实现Map集合；
      • 由HashMap类实现的Map集合添加和删除映射关系效率更高；
      • HashMap是基于哈希表的Map接口的实现；
      • HashMap通过哈希码对其内部的映射关系进行快速查找；
      • TreeMap中的映射关系存在一定的顺序；
      • 如果希望Map集合中的对象也存在一定的顺序，应该使用TreeMap类实现Map集合。
    • HashMap类 a .是基于哈希表的Map接口的实现； b. 此实现提供所有可选的映射操作，并允许使用null值和null键，但必须保证键的唯一性。 c .HashMap通过哈希表对其内部的映射关系进行快速查找。 d. 此类不保证映射的顺序，特别是它不保证该顺序恒久不变。
    • TreeMap类 a. 不仅实现了Map接口，还实现了java.util.SortedMap接囗，因此，集合中的映射关系具有一定的顺序。 b. 但在添加、删除和定位映射关系时，TreeMap类比HashMap类性能稍差。 c. 由于TreeMap类实现的Map集合中的映射关系是根据**键对象**按照一定的顺序排列的，因此不允许键对象是null。
    • 可以通过HashMap类创建Map集合， 当需要顺序输出时，再创建一个完成相同映射关系的TreeMap类实例。如文中综合实例：

####1. 集合类概述

1.1. java.util包中提供了一些集合类，这些集合类又被称为容器。

1.2. 关于容器，集合类与数组的不同之处：

  • 数组的长度是固定的，集合的长度是可变的；
  • 数组用来存放基本类型的数据，集合用来存放对象的引用。

1.3. 常用的集合有List集合、Set集合和Map集合； 　　List与Set继承了Collection接口，各接口还提供了不同的实现类。
常用集合类的继承关系如下：


####2. Collection接口 - Collection接口是层次结构中的根接口； - 构成Collection的单位称为```元素```； - Collection接口通常不能直接使用，但该接口提供了```添加元素、删除元素、管理数据```的方法。 - 由于List接口与Set接口都继承了Collection接口，因此这些方法对List集合与Set集合是通用的。 常用方法如下表：![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/ed10e61825bf417e9623bc514f5e7007~tplv-k3u1fbpfcp-zoom-1.image)
下面是一个综合实例，把表中的方法都用一遍：

（Ps：

  • iterator迭代器有点儿像一个指针一样的东西，指向list对象中的某一个元素；
  • it.hasNext()中迭代器的hasNext()第一次用的时候，指向第一个元素，next()同理）
package com.lzw;

import java.util.*;

public class Muster { // 创建类Muster
	public static void main(String args[]) {
		Collection<String> list = new ArrayList<>(); // 实例化集合类对象
		list.add("a"); // 向集合添加数据
		list.add("b");
		list.add("c");
		list.add("d");
		list.add("e");
		System.out.println("Now add a&b&c&d&e to the list , its size is:"+list.size());
		System.out.println("Print out all element of the list:");
		Iterator<String> it = list.iterator(); // 创建迭代器
		while (it.hasNext()) { // 判断是否有下一个元素
			String str = (String) it.next(); // 获取集合中元素
			System.out.println(str);
		}
		System.out.println("------------------------------------------------");
		list.remove("a");
		list.remove("b");
		list.remove("c");
		System.out.println("Now remove a&b&c of the list , its size is:"+list.size());
		System.out.println("Print out all element of the list:");
		Iterator<String> it1 = list.iterator(); 
		while(it1.hasNext()){
			String str = (String)it1.next();
			System.out.println(str);
		}
		System.out.println("Now is the list Empty?   "+list.isEmpty());
		System.out.println("------------------------------------------------");
		list.remove("d");
		list.remove("e");
		System.out.println("Now remove d&e of the list , its size is:"+list.size());
		System.out.println("Now is the list Empty?   "+list.isEmpty());
	}
}

输出结果：

Now add a&b&c&d&e to the list , its size is:5
Print out all element of the list:
a
b
c
d
e
------------------------------------------------
Now remove a&b&c of the list , its size is:2
Print out all element of the list:
d
e
Now is the list Empty?   false
------------------------------------------------
Now remove d&e of the list , its size is:0
Now is the list Empty?   true

####3. List集合 - List集合包括List接口以及```接口```的所有```实现类```。 - List集合中的元素```允许重复```，各元素的```顺序```就是对象```插入的顺序```。 - 类似Java数组，用户可通过使用```索引（元素在集合中的位置）```来访问集合中的元素。

######3.1 List接口 List接口继承了Collection接口，因此包含Collection中的所有方法。

此外，List接口还定义了以下两个非常重要的方法: get(int index):获得指定索引位置的元素; set(int index，Object obj)：将集合中指定索引位置的对象修改为指定的对象。

######3.2 List接口的实现类 List接口的常用实现类有ArrayList与LinkedList.

ArrayList类 a. 实现了可变的数组，允许保存所有元素，包括null,并可以根据索引位置对集合进行快速的随机访问； b. 缺点是向指定的索引位置插入对象或删除对象的速度较慢。

LinkedList类 a.采用链表结构保存对象。 b.优点是便于向集合中插入和删除对象，需要向集合中插入、删除对象时，使用LinkedList类实现的List集合的效率较高： c. 但对于随机访问集合中的对象，使用LinkedList类实现List集合的效率较低。

使用List集合时通常声明为List类型，可通过不同的实现类来实例化集合。 分别通过ArrayList、LinkedList类实例化List集合，代码如下：

List<E> list = new ArrayList<>();
List<E> list2 = new LinkedList<>();

在上面的代码中，E可以是合法的Java数据类型。 例如，如果集合中的元素为字符串类型，那么E可以修改为String。


下面是一个综合实例: ``` import java.util.*;

public class Gather { // 创建类Gather public static void main(String[] args) { // 主方法 List list = new ArrayList<>(); // 创建集合对象 list.add("a"); // 向集合添加元素 list.add("b"); list.add("c"); list.add("d"); list.add("e"); int i = (int) (Math.random() * (list.size())); // 获得0~4之间的随机数 System.out.println("随机获取数组中的元素：" + list.get(i)); list.remove(2); // 将指定索引位置的元素从集合中移除 System.out.println("将索引是'2'的元素从数组移除后，数组中的元素是："); for (int j = 0; j < list.size(); j++) { // 循环遍历集合 System.out.println(list.get(j)); } } }

输出结果：

随机获取数组中的元素：c 将索引是'2'的元素从数组移除后，数组中的元素是： a b d e


---
<br>
####4. Set集合
- Set集合中的对象```不按特定的方式排序```，只是```简单地把对象加入集合中```；
- Set集合中```不能包含重复对象```；
- Set集合由```Set接口```和```Set接口的实现类```组成。
- Set接口继承了```Collection接口```，因此包含```Collection接口的所有方法```。

<br>

Set接口常用的实现类有```HashSet类```与```TreeSet类```。

```HashSet```类
a. 实现```Set接口```，由```哈希表（实际上是一个HashMap实例）```支持。
b. 它```不保证Set的迭代顺序```，特别是它不```保证该顺序恒久不变```。
c .此类```允许使用null元素```。

```TreeSet```类
a. 不仅实现了```Set接口```，还实现了```java.util.SortedSet接口```，
b. 因此，TreeSet类实现的Set集合在```遍历集合时```按照```自然顺序递增排序```；```*********%%%%%%%%%%***********```
c. 也可以按照指定```比较器```递增排序；
d. 即可以通过比较器对用TreeSet类实现的Set集合中的对象进行排序。<br>
TreeSet类新增的方法如下表：![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/5904622bf60a426a87fef29c2300ac96~tplv-k3u1fbpfcp-zoom-1.image)![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/3032c4007c4a44f2862782f7a8c1b211~tplv-k3u1fbpfcp-zoom-1.image)![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/9794cb378bde48fc998613164984af9d~tplv-k3u1fbpfcp-zoom-1.image)

<br>
>几个需要注意的地方：
>- ```compareTo()```方法中书写的内容正是TreeSet类实现的Set集合在```遍历集合时```那```自然顺序递增排序```的依据；
>- 使用```compareTo()```方法的前提是要让使用的类实现```Comparable接口```；
>- Set顺序遍历时，依据```compareTo()```方法中书写的规则进行```自然顺序递增排序```，而非```add()```的顺序；
>- headSet()/subSet()/tailSet()三个方法再截取时，所谓的“之前、之后、之间”也是相对于```自然顺序递增排序```之的Set结合，而非```add()```的顺序；
>- 注意上表中```包含```和```不包含```的运用；![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/17475e71bf6d4c5dbd693866a4e8f4de~tplv-k3u1fbpfcp-zoom-1.image)

（可参考下面实例加深了解）

<br>
下面是一个综合实例：

import java.util.*; public class UpdateStu implements Comparable { String name; long id;

//构造方法
public UpdateStu(String name, long id) {
	this.id = id;
	this.name = name;
}

//定义排序规则
public int compareTo(Object o) {
	UpdateStu upstu = (UpdateStu) o;
	int result = id > upstu.id ? 1 : (id == upstu.id ? 0 : -1);
	return result;
}

//getter & setter
public long getId() {
	return id;
}
public void setId(long id) {
	this.id = id;
}
public String getName() {
	return name;
}
public void setName(String name) {
	this.name = name;
}

public static void main(String[] args) {
	UpdateStu stu1 = new UpdateStu("李同学", 01011);//呐！01011是八进制！！！！！！！！！！！！！！！！！
	UpdateStu stu2 = new UpdateStu("陈同学", 01021);
	UpdateStu stu3 = new UpdateStu("王同学", 01051);
	UpdateStu stu4 = new UpdateStu("马同学", 01012);
	
	TreeSet<UpdateStu> tree = new TreeSet<>();
	tree.add(stu1);
	tree.add(stu2);
	tree.add(stu3);
	tree.add(stu4);
	
	Iterator<UpdateStu> it = tree.iterator();
	System.out.println("Set集合中的所有元素：");
	while (it.hasNext()) {
		UpdateStu stu = (UpdateStu) it.next();
		System.out.println(stu.getId() + " " + stu.getName());
	}
	System.out.println("李马陈王是自然排序，其对应的对象名顺序是：");
	System.out.println("stu1");
	System.out.println("stu4");
	System.out.println("stu2");
	System.out.println("stu3");
	System.out.println(" ");
	System.out.println("tree.first().getName()：" + tree.first().getName());
	System.out.println("tree.last().getName()：" + tree.last().getName());

	
	System.out.println("------------------------------------------------");
	it = tree.headSet(stu3).iterator();
	System.out.println("截取stu3前面部分的集合：");
	while (it.hasNext()) {
		UpdateStu stu = (UpdateStu) it.next();
		System.out.println(stu.getId() + " " + stu.getName());
	}
	
	System.out.println("------------------------------------------------");
	it = tree.subSet(stu2, stu3).iterator();
	System.out.println("截取stu2&stu3中间部分的集合");
	while (it.hasNext()) {
		UpdateStu stu = (UpdateStu) it.next();
		System.out.println(stu.getId() + " " + stu.getName());
	}
	
	System.out.println("------------------------------------------------");
	it = tree.tailSet(stu1).iterator();
	System.out.println("截取stu1后面部分的集合");
	while (it.hasNext()) {
		UpdateStu stu = (UpdateStu) it.next();
		System.out.println(stu.getId() + " " + stu.getName());
	}
}

}


输出结果：

Set集合中的所有元素： 521 李同学 522 马同学 529 陈同学 553 王同学 李马陈王是自然排序，其对应的对象名顺序是： stu1 stu4 stu2 stu3

tree.first().getName()：李同学 tree.last().getName()：王同学

截取stu3前面部分的集合： 521 李同学 522 马同学 529 陈同学

截取stu2&stu3中间部分的集合 529 陈同学

截取stu1后面部分的集合 521 李同学 522 马同学 529 陈同学 553 王同学


最后强调：
- 存入```TreeSet类```实现的```set集合```必须实现```Comparable接口```，该接口中的```compareTo(Object o)```方法
比较```此对象(this/实现本接口的类的实例化对象)```与```指定对象(传进来的作为参数的对象)```的顺序；
- 如果该对象小于、等于或大于指定对象，则分别返回负整数、0或正整数。



---
<br>
####5. Map集合
- Map集合没有继承```Collection```接口，其提供的是```key到value的映射```；
- Map中不能包含相同的```key```,每个```key```只能映射一个```value```；
- key还决定了```存储对象在映射中的存储位置```，但不是由```key对象本身```决定的，而是通过一种```“散列技术”```进行处理，产生一个```散列码的整数值```；
- ```散列码```通常用作一个```偏移量```，该偏移量对应分配给```映射的内存区域的起始位置```，从而确定```存储对象在映射中的存储位置```；
- Map集合包括Map接口以及Map接口的所有实现类。

<br>
######5.1 Map接口
- Map接口提供了将key映射到值的对象。
- 一个映射不能包含重复的key，每个key最多只能映射到一个值。
- Map接口中同样提供了集合的常用方法，除此之外还包括如下表所示的常用方法：![](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/b10ada41288443b18159be5c1b1b332d~tplv-k3u1fbpfcp-zoom-1.image)
下面是一个综合实例：

import java.util.*;

public class UpdateStu { public static void main(String[] args) { Map<String,String> map = new HashMap<>(); // 创建Map实例 map.put("01", "李同学"); // 向集合中添加对象 map.put("02", "魏同学"); map.put("03", "王同学"); map.put("04", "陈同学"); map.put("05", "张同学"); map.put("06", "赵同学");

	Set<String> set = map.keySet(); // 构建Map集合中所有key对象的集合
	Iterator<String> it = set.iterator(); // 创建集合迭代器
	System.out.println("key集合中的元素(map.keySet() + iterator())：");
	while (it.hasNext()) { // 遍历集合
		System.out.println(it.next());
	}
	System.out.println("------------------------------------------------");
	
	Collection<String> coll = map.values(); // 构建Map集合中所有values值集合
	it = coll.iterator();
	System.out.println("values集合中的元素(map.values() + iterator())：");
	while (it.hasNext()) { // 遍历集合
		System.out.println(it.next());
	}
	System.out.println("------------------------------------------------");
	
	System.out.println("map.get(\"01\")" + map.get("01"));
	System.out.println("map.get(\"02\")" + map.get("02"));
	System.out.println("map.get(\"03\")" + map.get("03"));
	System.out.println("------------------------------------------------");
	
	System.out.println("map.containsKey(\"01\")" + map.containsKey("01"));
	System.out.println("map.containsKey(\"10\")" + map.containsKey("10"));
	System.out.println("map.containsValue(\"李同学\")" + map.containsValue("李同学"));
	System.out.println("map.containsValue(\"许同学\")" + map.containsValue("许同学"));
}

}

输出结果：

key集合中的元素(map.keySet() + iterator())： 01 02 03 04 05 06

values集合中的元素(map.values() + iterator())： 李同学 魏同学 王同学 陈同学 张同学 赵同学

map.get("01")李同学 map.get("02")魏同学 map.get("03")王同学

map.containsKey("01")true map.containsKey("10")false map.containsValue("李同学")true map.containsValue("许同学")false

>**注意：Map集合中允许值对象是null，而且没有个数限制，例如，可通过“map.put("05",null)”语句向集合中添加对象。**

<br>
######5.2 Map接口的实现类
- Map接口常用的实现类有```HashMap```和```TreeMap```；
- 建议使用```HashMap类```实现Map集合；
- 由```HashMap类```实现的Map集合```添加和删除映射关系效率更高```；
- HashMap是基于```哈希表```的```Map接口```的实现；
- HashMap通过```哈希码```对其内部的映射关系进行```快速查找```；
<br>
- ```TreeMap```中的映射关系存在```一定的顺序```；
- 如果希望Map集合中的对象也存在一定的顺序，应该使用TreeMap类实现Map集合。

```HashMap```类
a .是基于哈希表的Map接口的实现；
b. 此实现```提供所有可选的映射操作```，```并允许使用null值和null键```，但必须保证```键的唯一性```。
c .HashMap通过哈希表对其内部的映射关系进行```快速查找```。
d. 此类```不保证```映射的顺序，特别是它不保证该顺序恒久不变。

```TreeMap```类
a. 不仅实现了Map接口，还实现了java.util.SortedMap接囗，因此，集合中的映射关系具有一定的顺序。
b. 但在```添加、删除和定位映射关系```时，TreeMap类比HashMap类```性能稍差```。
c. 由于TreeMap类实现的Map集合中的映射关系是根据键对象```按照一定的顺序排列```的，因此```不允许键对象是null```。

**可以通过HashMap类创建Map集合，
当需要顺序输出时，再创建一个完成相同映射关系的TreeMap类实例。如下的综合实例：**

首先是一个Emp类文件：

public class Emp { private String e_id; private String e_name; public Emp( String e_id,String e_name) { this.e_id = e_id; this.e_name = e_name; } public String getE_id() { return e_id; } public void setE_id(String e_id) { this.e_id = e_id; } public String getE_name() { return e_name; } public void setE_name(String e_name) { this.e_name = e_name; }

}


测试用主类：

import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set; import java.util.TreeMap;

public class MapText { // 创建类MapText public static void main(String[] args) { // 主方法 Map<String, String> map = new HashMap<>(); // 由HashMap实现的Map对象 Emp emp = new Emp("351", "张三"); // 创建Emp对象 Emp emp2 = new Emp("512", "李四"); Emp emp3 = new Emp("853", "王一"); Emp emp4 = new Emp("125", "赵六"); Emp emp5 = new Emp("341", "黄七");

	map.put(emp4.getE_id(), emp4.getE_name()); // 将对象添加到集合中
	map.put(emp5.getE_id(), emp5.getE_name());
	map.put(emp.getE_id(), emp.getE_name());
	map.put(emp2.getE_id(), emp2.getE_name());
	map.put(emp3.getE_id(), emp3.getE_name());

// Set set = map.keySet(); // 获取Map集合中的key对象集合 Iterator it = map.keySet().iterator(); System.out.println("HashMap类实现的Map集合，无序："); while (it.hasNext()) { // 遍历Map集合 String str = (String) it.next(); String name = (String) map.get(str); System.out.println(str + " " + name); }

	System.out.println( );
	
	TreeMap<String, String> treemap = new TreeMap<>(); // 创建TreeMap集合对象
	treemap.putAll(map); // 向集合添加对象
	Iterator<String> iter = treemap.keySet().iterator();
	System.out.println("TreeMap类实现的Map集合，键对象升序：");
	while (iter.hasNext()) { // 遍历TreeMap集合对象
		String str = (String) iter.next(); // 获取集合中的所有key对象
		String name = (String) treemap.get(str); // 获取集合中的所有values值
		System.out.println(str + " " + name);
	}
}

}


输出结果：

HashMap类实现的Map集合，无序： 341 黄七 125 赵六 512 李四 853 王一 351 张三

TreeMap类实现的Map集合，键对象升序： 125 赵六 341 黄七 351 张三 512 李四 853 王一


<br><br>
####6. 实践练习题
1. 将1～100之间的所有正整数存放在一个List集合中，并将集合中索引位置是10的对象从集合中移除。

import java.util.*; public class Text { public static void main(String[] args) { List list = new LinkedList<>(); for(int i = 1 ;i<=100;i++){ list.add(new Integer(i)); } list.remove(list.get(10)); System.out.println("ok"); } }


输出结果：

ok


2. 分别向Set集合以及List集合中添加"A” “a” "c” "C”  "a”5个元素，观察重复值"a”能否
重复地在List集合以及Set集合中添加。

import java.util.*; public class Text { public static void main(String[] args) { Set set = new HashSet<>(); //HashSet是Set的子接口 set.add("a"); set.add("c"); set.add("A"); set.add("a"); set.add("C");

    List<String> list = new ArrayList<>();
    list.add("a");
    list.add("c");
    list.add("A");
    list.add("a"); 
    list.add("C");
    
    System.out.println(set);
   System.out.println(list);
}

}

输出结果：

[a, A, c, C] [a, c, A, a, C]


3. 创建Map集合，创建Emp对象，并将Emp对象添加到集合中(Emp对象的id作为Map集合的键），并将id为“015”的对象从集合中移除。

首先是Emp.java:

public class Emp { private String e_id; private String e_name; public Emp( String e_id,String e_name) { this.e_id = e_id; this.e_name = e_name; } public String getE_id() { return e_id; } public void setE_id(String e_id) { this.e_id = e_id; } public String getE_name() { return e_name; } public void setE_name(String e_name) { this.e_name = e_name; }

}

然后是主类：

import java.util.*;

public class Text { public static void main(String[] args) { Map<String, String> map = new TreeMap<>();

	Emp emp = new Emp("001", "张三");
	Emp emp2 = new Emp("005", "李四");
	Emp emp3 = new Emp("004", "王五");
	Emp emp4 = new Emp("010", "赵六");
	Emp emp5 = new Emp("015", "魏七");
	
	map.put(emp.getE_id(), emp.getE_name());
	map.put(emp2.getE_id(), emp2.getE_name());
	map.put(emp3.getE_id(), emp3.getE_name());
	map.put(emp4.getE_id(), emp4.getE_name());
	map.put(emp5.getE_id(), emp5.getE_name());
	
	map.remove("015");
	for (String string : map.keySet()) {
		System.out.println(map.get(string));
	}
}

}


输出结果：

张三 王五 李四 赵六



<br><br><br>
**参考资料：《Java从入门到精通》**

avatar
文章
阅读
粉丝