JavaSE进阶篇【3】——2022年6月27日

JavaSE进阶篇【3】

2022年6月27日

---

第三部分 集合类

3.1 集合类概述

java.util 包中提供了一些集合类。集合类与数组的不同之处在于，数组的长度是固定的，集合的长度是可变的；数组用来存放基本类型的数据，集合用来存放对象的引用。常用的集合有 List 集合、Set 集合和 Map 集合，其中 List 和 Set 继承了 Collection 接口，各接口还提供不同的实现类。常用集合类的继承关系如下图所示：

3.2 Collection 接口

Collection 接口是层次中的根接口。构成 Collection 的单位称为元素。Collection 接口通常不能直接使用，但该接口提供了添加元素、删除元素、管理数据的方法。由于 List 接口与 Set 接口都继承了 Collection 接口，因此这些方法对 List 结合与 Set 集合是通用的。常用方法如下表所示：

方法	功能描述
add(E e)	将指定的对象添加到该集合中
remove(Object o)	将指定的对象从该集合中移除
isEmpty()	返回 boolean 值，用于判断当前集合是否为空
iterator()	返回在此 Collection 的元素上进行迭代的迭代器，用于遍历集合中的对象
size()	返回 int 型值，获取该集合中元素的个数

下面实例给出了一个典型的遍历集合的方法。

package Jihe;
import java.util.*;                                        //导入 java.util包，其他实例都要添加该语句
public class Muster {
	public static void main(String[] args) {
		Collection<String>list = new ArrayList<>();        //实例化集合类对象
		list.add("a");                                     //向结合添加元素
		list.add("b");
		list.add("c");
		Iterator<String>it = list.iterator();              //创建迭代器
		while(it.hasNext()) {                              //判断是否有下一个元素
			String str = (String) it.next();               //获取数组中的元素
			System.out.println(str);
		}
	}
}

3.3 List 集合

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

1. List 接口

List 接口继承了 Collection 接口，因此包括 Collection 中的所有方法。此外，List 接口还定义了以下两个非常重要的方法。

• get(int index)：获取指定索引位置的元素
• set(int index,Object obj)：将集合中指定索引位置的对象修改为指定的对象

2. List 接口的实现类

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

• ArrayList 类实现了可变的数组，允许保存所有元素，包括 null，并且可以根据索引位置对集合进行快速的随机访问；缺点是向指定的索引位置插入对象或删除对象的速度较慢
• LinkedList 类采用链表结构保存对象。这种结构的优点是便于向集合中插入和删除对象，需要向集合中插入、删除对象时，使用 LinkedList 类实现 List 集合的效率较高；但对于随机访问集合中的对象，使用 LinkedList 类实现 List 集合的效率较低。

使用 List 集合时通常声明为 List 类型，可通过不同的实现类来实例化集合。

Listlist = new ArrayList<>();
Listlist = new LinkedList<>();

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

package Jihe;
import java.util.*;
public class Gather {
	public static void main(String[] args) {
		List<String>list = new ArrayList<>();
		list.add("a");                                     //向结合添加元素
		list.add("b");
		list.add("c");
		int i = (int)(Math.random()*list.size());
		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));
		}
	}
}

3.4 Set 集合

Set 集合中的对象不按特定的方式排序，只是简单地把对象加入集合中，但 Set 集合中不能包含重复对象。Set 集合由 Set 接口和 Set 接口的实现类组成。Set 接口继承了 Collecton 接口，因此包含 Collection 接口的所有方法。
Set 接口常用的实现类有 HashSet 类与 TreeSet 类。

• HashSet 类实现 Set 接口，由哈希表（实际上是一个 HashMap 实例）支持。它不保证 Set 的迭代顺序，特别是它不保证该顺序恒久不变。此类允许使用 null 元素。
• TreeSet 类不仅实现了 Set 接口，还实现了 java.util.SortedSet 接口，因此，TreeSet 类实现的 Set 集合在遍历集合时按照自然顺序递增排序，也可以按照指定比较器递增排序，即可以通过比较器对用 TreeSet 类实现的 Set 集合中的对象进行排序。TreeSet 类新增的方法如下表所示：

方法	功能描述
first()	返回此 Set 中当前第一个（最低）元素
last()	返回此 Set 中当前最后一个（最高）元素
comparator()	返回对此 Set 集合中的元素进行排序的比较器。如果此 Set 使用自然顺序，则返回 null
headSet(E toElement)	返回一个新的 Set 集合，新集合是 toElement（不包含）之前的所有对象
subSet(E fromElement, E fromElement)	返回一个新的 Set 集合，是 fromElement（包含）对象与 fromElement（不包含）对象之间的所有对象
tailSet(E fromElement)	返回一个新的 Set 集合，新结合包含对象 fromElement（包含）之后的所有对象

package Jihe;
import java.util.Iterator;
import java.util.TreeSet;
public class UpdateStu implements Comparable<Object>{
	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;
	}
	
	public String getName() {
		return name;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public long getId() {
		return id;
	}
	
	public void setId(long id) {
		this.id = id;
	}
	
	public static void main(String[] args) {
		UpdateStu stu1 = new UpdateStu("李同学",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());
		}
		it =tree.headSet(stu2).iterator();
		System.out.println("截取前面部分的集合：");
		while(it.hasNext()) {
			UpdateStu stu = (UpdateStu)it.next();
			System.out.println(stu.getId()+" "+stu.getName());
		}
		it = tree.subSet(stu2, stu3).iterator();
		System.out.println("截取中间部分的集合：");
		while(it.hasNext()) {
			UpdateStu stu = (UpdateStu)it.next();
			System.out.println(stu.getId()+" "+stu.getName());
		}
	}
}

运行后得到的结果为

代码说明：存入 TreeSet 类实现的 Set 集合必须实现 Comparable 接口，该接口中的 compareTo(Object o) 方法比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、0 或正整数。

3.5 Map 集合

Map 集合没有继承 Collection 接口，其提供的是 key 到 value 的映射。Map 中不能包含相同的 key，每个 key 只能映射一个 value。key 还决定了存储对象在映射中的存储位置，但不是由 key 对象本身决定的，而是通过一种散列技术进行处理，产生一个散列码的整数值。散列码通常作为一个偏移量，该偏移量对应分配给映射的内存区域的起始位置，从而确定存储对象在映射中的存储位置。Map 集合包括 Map 接口以及 Map 接口的所有实现类。
Map 接口提供了将 key 映射到值的对象。一个映射不能包含重复的 key，每个 key 最多只能映射到一个值。Map 接口中同样提供了集合的常用方法，除此之外还包括下表所示的常用方法。

方法	功能描述
put(K key, V value)	向集合中添加指定的 key 与 value 的映射关系
containsKey(Object key)	如果此映射包含指定的 key 的映射关系，则返回 true
containsValue(Object value)	如果此映射将一个或多个 key 映射到指定值，则返回 true
get(Object key)	如果存在指定的 key 对象，则返回该对象的对应值，否则返回 null
keySet()	返回该集合中的所有 key 对象形成的 Set 集合
values()	返回该集合中所有对象形成的 Collection 集合

下面通过实例介绍 Map 接口中某些方法的使用。

package Jihe;
import java.util.*;
public class UpdateStd {
	public static void main(String[] args) {
		Map<String,String>map = new HashMap<>();  //创建 Map实例
		map.put("01", "李同学");                  //向集合中添加对象
		map.put("02", "魏同学");
		Set<String>set = map.keySet();           //构建 Map集合中所有 key对象的集合
		Iterator<String>it = set.iterator();     //创建集合迭代器
		System.out.println("key 集合中的元素是：");
		while(it.hasNext()) {                    //遍历集合
			System.out.println(it.next());
		}
		Collection<String>coll = map.values();   //构建 Map集合中所有 value对象的集合
		it = coll.iterator();
		System.out.println("value 集合中的元素是：");
		while(it.hasNext()) {                    //遍历集合
			System.out.println(it.next());
		}
	}
}

Map 集合中允许值对象是 null，而且没有个数限制。
Map 接口常用的实例类有 HashMap 和 TreeMap。建议使用 HashMap 类实现 Map 集合， 因为由 HashMap 类实现的 Map 集合添加和删除映射关系效率更高。
HashMap 是基于哈希表的 Map 接口的实现，HashMap 通过哈希码对其内部的映射关系进行快速查找；而 TreeMap 中的映射关系存在一定的顺序，如果希望 Map 集合中的对象也存在一定的顺序，应该使用 TreeMap 类实现Map 集合。

• HashMap 类是基于哈希表的 Map 接口的实现，此实现提供所有可选的映射操作，并允许使用 null 值和 null 键，但必须保证键的唯一性。HashMap 通过哈希表对其内部的映射关系进行快速查找。此类不保证映射的顺序，特别是它不保证该顺序的恒久不变。
• TreeMap 类不仅实现 Map 接口，还实现了 java.util.SortedMap 接口，因此，集合中的映射关系具有一定的顺序。但在添加、删除和定位映射时，TreeMap 类比 HashMap 类性能稍差。由于 TreeMap 类实现的 Map 集合中映射关系是根据键对象按照一定的顺序排列的，因此不允许键对象是 null。

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