10.集合框架
1.Collection
1.1.List
1.1.1.ArrayList 类
基于数组算法的列表，底层其实就是一个 Object 数组
常用方法的 API：
| 方法名 | 作用 | 调用语法 |
|---|---|---|
| add(E e) | 添加元素，E 是创建集合时定义的泛型，添加的元素的类型就是传入的这个泛型类型 | 集合对象.add(E e) |
| remove(int index)、remove(Object 0) | 删除元素，第一个方法是根据元素的索引删除；第二个方法时直接根据元素的内容删除元素，第二个方法时 List 集合的父类 collection 中的方法 | 集合对象.remove(int index) |
| set(int index, E e) | 修改元素，第一个形参就是需要修改的元素索引，第二个集合对象.形参就是修改后的值 | 集合对象.set(int index, E e) |
| get(int index) | 根据索引获取元素 | 集合对象.get(int index) |
| size() | 获取集合的长度 | 集合对象.size() |
| isEmpty() | 判断集合是否为空 | 集合对象.isEmpty() |
| contains(Object o) | 判断集合是否包含目标元素 | 集合对象.contains(Object o) |
| toArray() | 将集合转换为数组 | 集合对象.toArray() |
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]
}
}
1.1.2.LinkedList 类
底层采用链表算法，实现了链表、队列、栈的数据结构。无论是链表还是队列，主要操作的都是头和尾的元素。
LinkedList 常用方法的 API：
| 方法名 | 作用 | 调用语法 |
|---|---|---|
| addFirst() | 从链表的开头处添加元素 | 对象.addFirst() |
| addLast() | 从链表的结尾处添加元素 | 对象.addLast() |
| getFirst() | 获取到链表开头处的第一个元素 | 对象.getFirst() |
| getLast() | 获取到链表结尾处的最后一个元素 | 对象.getLast() |
| removeFirst() | 删除链表开头处的第一个元素 | 对象.removeFirst() |
| removeLast() | 删除链表结尾处的最后一个元素 | 对象.removeLast() |
其余方法
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() 获取但不移除此列表的头（第一个元素）。
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]
1.2.Set
特点：
- 不允许元素重复
- 不会基类元素的添加先后顺序
Set 只包含从 Collection 继承的方法，当试图添加两个相同元素进 Set 集合，添加操作失败，add() 方法返回 false
常用的实现类：
- HashSet 类：底层采用哈希表实现，开发中使用最多的实现类
- TreeSet 类：底层采用红黑树实现，可以对集合中元素排序，使用不对
HashSet 和 TreeSet 类的 API 都是一样的
| 方法名 | 作用 | 调用语法 |
|---|---|---|
| add(E e) | 添加元素，E 是创建集合时定义的泛型，添加的元素的类型就是传入的这个泛型类型 | 集合对象.add(E e) |
| remove(int index)、remove(Object 0) | 删除元素，第一个方法是根据元素的索引删除；第二个方法时直接根据元素的内容删除元素，第二个方法时 List 集合的父类 collection 中的方法 | 集合对象.remove(int index) |
| set(int index, E e) | 修改元素，第一个形参就是需要修改的元素索引，第二个集合对象.形参就是修改后的值 | 集合对象.set(int index, E e) |
| get(int index) | 根据索引获取元素 | 集合对象.get(int index) |
| size() | 获取集合的长度 | 集合对象.size() |
| isEmpty() | 判断集合是否为空 | 集合对象.isEmpty() |
| contains(Object o) | 判断集合是否包含目标元素 | 集合对象.contains(Object o) |
| toArray() | 将集合转换为数组 | 集合对象.toArray() |
1.2.1.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);
}
}
}
1.2.2.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]
}
}
2.Map
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集合
2.1.HashMap
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);
}
}
2.2.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=貂蝉}
3.集合元素变量
对集合中的每一个元素获取出来
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
