12.集合类
12.集合类
12.1集合类概述
java.util包中提供了一些集合类，即容器。宠用的集合有List集合、Set集合、Map集合。其中List与Set继承了Collection接口，各接口提供了不同的实现类。
集合与数组的区别：
数组长度固定，集合长度可变；
数组存放基本类型的数据，集合存放数据的引用。
常见集合类继承关系如下：
12.2Collection接口
Collcetion接口是层次结构中的根接口。构成Collection的单位称为元素。
Collection接口不能直接使用，但提供了一些方法，对List和Set集合通用。
Collection接口常用方法如下：
| 方法 | 功能描述 |
|---|---|
| add(Object e) | 将指定的对象添加到该集合中 |
| remove(Object o) | 将指定对象从该集合中移除 |
| isEmpty() | 返回Boolean值，用于判断当前集合是否为空 |
| iterator() | 返回在此Collection的元素上进行迭代的迭代器，用于遍历集合中的对象 |
| size() | 返回int型值，获取该集合中元素个数 |
遍历集合通常通过迭代器实现，举例如下：
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(); // Collection接口中iterator()方法返回迭代器
while(it.hasNext()){ //判断是否有下一个元素
String str=(String)it.next();
System.out.println(str); //获取集合中元素
}
}
}
Iterator的next()方法返回的是Object，所以需要
12.3List集合
List集合包括List接口以及List接口的所有实现类。
List集合中的元素允许重复，各元素顺序就是对象插入顺序。
用户可以通过索引访问集合中元素。
12.3.1List接口
List接口包含了Collection中所有方法。此外，List接口还定义了一下两个非常重要的方法。
get(int index)：获取指定索引位置的元素。
set（int index,Object obj): 将集合中指定索引位置的对象修改为指定的对象。
12.3.2List接口的实现类
ArrayList类：实现了可变数组，允许保存所有元素，包括NULL；可以根据索引位置对集合进行快速的随机访问；但是插入删除对象速度较慢
LinkedList类：链表结构保存对象；插入删除效率较高；但是随机访问集合中对象时速度较慢
通过Array List、LinkedList类实例化List集合代码如下：
List<E>list=new ArrayList<>(); List<e>list2=new LinkedList<>(); //E为合法的java数据类型
举例如下：
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("b");
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));
}
}
}
类似数组，集合索引也是从0开始。
12.4Set集合
Set集合中对象没有顺序，不能有重复对象。
Set集合由Set接口和Set接口的实现类组成。Set接口继承了Collection接口，因此包含Collection接口的所有对象。
Set接口常用类由HashSet类和TreeSet类。
HashSet类实现Set接口，由哈希表支持，不保证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集合，集合是formElement对象（包含）与fromElement对象（不包含）之间所有对象 |
| tailSet(E fromElement) | 返回一个新Set集合，新集合包含fromElement对象（包含）之后所有对象 |
记忆：指定位置位于新集合起始位置，则包含该对象；指定位置位于新集合终点位置，则不包含该对象
举例如下：
import java.util.Iterator;
import java.util.TreeSet;
public class UpdateStu implements Comparable<Object> {
String name;
long id;
//Comparable接口里有compareTo()方法,继承该接口需要重写compareTo()方法
public UpdateStu(String name, long id) {
this.id = id;
this.name = name;
}
//重写compareTo()方法
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对象
UpdateStu stu1 = new UpdateStu("李同学", 01011);
UpdateStu stu2 = new UpdateStu("陈同学", 01012);
UpdateStu stu3 = new UpdateStu("王同学", 01013);
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());
}
//截取stu2集合之前的对象
it = tree.headSet(stu2).iterator();
System.out.println("截取前面部分的集合");
while (it.hasNext()) {
UpdateStu stu = (UpdateStu) it.next();
System.out.println(stu.getId() + " " + stu.getName());
}
//截取stu2和stu3之间的对象
it = tree.subSet(stu2, stu3).iterator();
System.out.println("截取中间部分的集合");
while (it.hasNext()) {
UpdateStu stu = it.next();
System.out.println(stu.getId() + " " + stu.getName());
}
}
}
TreeSet类实现的Set集合必须实现Comparable接口，该接口中的CompareTo(Object o)方法比较此对象与值得对象的顺序。返回值包含负整数、0、正整数。
12.5Map集合
Map集合包含Map接口和Map接口所有的实现类。
Map集合中提供key到value的映射。Map中不能包含相同的key,每个key映射一个value。
key觉得了存储对象在映射中的存储位置。每个key通过散列技术产生一个散列码的整数值，散列码通常用作一个偏移量，该偏移量对应分配给映射的内存区域的起始位置，从而确定存储对象在映射中的存储位置。
12.5.1Map接口
一个映射不能包含重复的key，每个key最多只能映射一个值，Map接口同样提供了集合常用方法，并额外包含了如下方法：
| 方法 | 功能描述 |
|---|---|
| put（K key,V value) | 向集合中添加特定的key和value的映射关系 |
| containsKey(Object key) | 若此映射包含指定key的映射关系，返回true |
| containsValue(Object value) | 若此集合中存在一个或多个指定值，返回true |
| get(Object key) | 若存在指定的key对象，返回对象的值，否则返回null |
| keySet() | 返回该集合中所有key对象形成的Set集合 |
| values() | 返回该集合所有values对象形成的Collection集合 |
举例如下：
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集合添加对象，注意map没有add()方法
System.out.println("集合中key元素如下：");
Set<String>set=map.keySet();
//构建key对象的Set集合
Iterator it=set.iterator();
//构建Set集合的迭代器，进行遍历
while(it.hasNext()){
System.out.println(it.next());
}
System.out.println("集合中values元素如下：");
Collection<String>coll=map.values();
//构建value对象的Collection集合
it=coll.iterator();
//构建coll集合的迭代器，进行遍历
while(it.hasNext()){
System.out.println(it.next());
}
}
}
注意Map集合允许对象是null,没有个数限制，如可以向集合中添加对象" map.put("05","null"); ".
12.5.2Map接口的实现类
Map接口常用实现类有HashMap和TreeMap。
HashMap：
1.基于哈希表的Map接口实现，可以通过哈希码对内部映射进行快速查找，故添加和删除效率更高。
2.允许使用null值和null键，但必须将保证健的唯一性。
3.不保证映射顺序，映射顺序可能会被改变。
TreeMap：
1.实现了Map接口，还实现了java.util.SortMap接口，故集合中的映射存在一定顺序。
2.映射关系根据健对象按照一定顺序排列，故不允许键对象是null。
可以通过HashMap创建Map集合，当需要输出顺序是，再创建一个完成相同映射关系的TreeMap类实例。
举例如下：
import java.util.*;
public class MapText {
public static void main(String[] args) {
Emp emp1 = new Emp("123", "张三");
Emp emp2 = new Emp("254", "李四");
Emp emp3 = new Emp("361", "王大");
Emp emp4 = new Emp("122", "晓二");
//创建Emp对象
Map<String, String> map = new HashMap<>();
//创建由HashMap实现的Map集合
map.put(emp3.getId(), emp3.getName());
map.put(emp1.getId(), emp1.getName());
map.put("315", "赵武");
map.put(emp2.getId(), emp2.getName());
map.put(emp4.getId(), emp4.getName());
//将对象添加到集合中
System.out.println("HashMap类实现的Map集合，无序：");
Set<String> set = map.keySet();
//获取Key对象组成的Set集合
Iterator<String> it = set.iterator();
//获取set集合的迭代器，进行遍历
while (it.hasNext()) {
String id = (String) it.next();
String name = (String) map.get(id);
System.out.println(id + " " + name);
}
System.out.println("TreeMap类实现的升序集合，键对象升序排序");
Map<String, String> treemap = new TreeMap<>();
treemap.putAll(map);
//创建TreeMap集合，并向集合中添加对象
Iterator<String> iter = treemap.keySet().iterator();
//返回treemap集合的Key集合的迭代器
while (iter.hasNext()) {
String id = iter.next();
String name = treemap.get(id);
System.out.println(id + " " + name);
}
}
}