1.Map集合
-
为什么需要MAP集合
解决单列集合查询数据不方便的问题
-
MAP概述
Map是一个接口 只要实现该接口的类都是 双列集合
在存储数据需要存储两个：一个数据是键 一个是值
这两个数据称为 键值对数据
Map集合是用来存储键值对数据的
特点：键必须是唯一的 值可以重复
ArrayList list
Map<String,String> list
map.put(“001”,“张三”)
map.put(“002”,“张三”)
-
MAP接口常用子类
HashMap LinkedHashMap
2.Map集合常用方法
package com.itheima._02Map常用方法;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
/**
目标：掌握Map集合常用的方法
讲解：
1. 演示Map集合常用方法
public V put(K key, V value) :
添加键值对数据
如果键存在，使用新值替换旧值，返回旧值
如果键不存在，直接存储
public V get(Object key)：
根据键获得值
如果键不存在，则返回null
public V remove(Object key) :
根据键删除键值对数据，返回键对应的值
public boolean containKey(Object key) :
判断是否包含指定的键，包含返回true，否则false
public int size()：获得键值对对数
public void clear()：清空集合
小结：
1. 添加和修改元素的方法？
put
2. 删除元素的方法？
remove
3. 获取元素的方法？
get
*/
public class Demo01 {
public static void main(String[] args) {
// 创建Map集合
Map<String,String> map = new HashMap<>();
// 添加元素
System.out.println(map.put("001", "张三")); // null
System.out.println(map.put("001", "赵六")); // 张三
map.put("002", "李四");
map.put("003", "王五");
System.out.println("------------------");
// 根据键获得值
System.out.println(map.get("004"));
// 根据键删除数据
System.out.println(map.remove("003")); // 王五
System.out.println("------------------");
// 判断是否包含指定的键
System.out.println(map.containsKey("001")); // true
// 获得键值对数据
System.out.println(map.size()); // 2
// 清空集合
map.clear();
System.out.println(map);
}
}
3.键找值
不能直接使用增强for 和迭代器遍历
Set keySet（） 获取键集合
调用ks方法：获取键集合对象
增强for迭代器遍历：获取每一个键
调用Map集合的get方法：获取值
package com.itheima._03Map遍历1_键找值方式;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
/**
目标：掌握使用"键找值"的方式遍历Map集合
讲解：
1. Map集合的遍历方式介绍
不能直接使用增强for和迭代器遍历
2. 通过键找值遍历相关的方法
* Set<K> keySet() 获得键集合
小结：
1. 键找值方式遍历Map集合的步骤
* 调用Map集合的keySet方法：获得键集合对象
* 使用增强for或迭代器遍历键集合：获得每一个键
* 调用Map集合的get方法：根据键获得值
*/
public class Demo03 {
public static void main(String[] args) {
// 创建Map集合
HashMap<String, String> map = new HashMap<>();
// 添加数据
map.put("001", "张三");
map.put("002", "李四");
map.put("003", "王五");
// 获得键集合
Set<String> keySet = map.keySet();
// 使用迭代器遍历键集合
Iterator<String> it = keySet.iterator();
// 遍历键集合
while(it.hasNext()){
// 获得键
String key = it.next();
// 根据键获得值
String value = map.get(key);
System.out.println(key+"="+value);
}
System.out.println("-----------");
// 使用增强for遍历键集合
for (String key : keySet) {
System.out.println(key+"="+map.get(key));
}
}
}
4.键值对方法
-
Entry概述
Entry对象又称为键值对对象
用来封装键值对数据
-
如果获取Entry
Set<Map.Entry<K,V>> entrySet（） 获取Entry对象集合
-
Entry 对象常用方法
获取值getKey ()
获取值getValue()
小结：通过Entry 对象遍历
package com.itheima._04Map遍历2_键值对方式; import com.itheima._12自定义Comparator比较器.Student; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Map.Entry; import java.util.Set; /** 目标：能够使用"键值对"的方式遍历Map集合 小结： 通过Entry对象遍历Map集合的步骤 1. 调用Map集合的entrySet方法：获得Entry对象集合 2. 使用迭代器或增强for遍历集合：获得每一个Entry对象 3. 调用Entry对象的方法获得键和值 K getKey() 获得键 V getValue() 获得值 */ public class Demo042 { public static void main(String[] args) { // 创建Map集合对象 HashMap<String, String> map = new HashMap<>(); // 存储键值对数据 map.put("name", "孙悟空"); map.put("gender", "男"); map.put("age", "500"); // 1. 获得Entry对象集合 Set<Entry<String, String>> entrySet = map.entrySet(); // 2. 使用迭代器遍历集合 Iterator<Entry<String, String>> it = entrySet.iterator(); while (it.hasNext()){ // 获得Entry对象 Entry<String, String> entry = it.next(); // 3. 调用Entry对象的方法获得键和值 System.out.println(entry.getKey()+"=" + entry.getValue()); } System.out.println("-------------------"); // 使用增强for遍历 for(Entry<String, String> entry:entrySet){ // System.out.println(entry.getKey()+"=" + entry.getValue()); System.out.println(entry); } } }
5.HashMap
package com.itheima._05HashMap存储自定义类型;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
/**
目标：使用HashMap存储自定义对象：自定义对象作为键使用
需求说明：
每位学生（姓名，年龄）都有自己的家庭住址。那么既然有对应关系，
则将学生对象和家庭住址存储到map集合中。学生作为键，家庭住址作为值。
注意，学生姓名相同并且年龄相同视为同一名学生。
步骤分析：
1. 定义学生类封装姓名和年龄
2. 创建Map集合存储学生：键：Student，值：String
3. 添加多个学生到Map集合中
4. 遍历输出Map集合学生数据
小结:
使用自定义对象作为键时如何实现去重功能？
自定义类重写hashCode和equals方法
如果自定义对象不是作为键，则不用重写这两个方法。
*/
public class Demo05 {
public static void main(String[] args) {
// 2. 创建Map集合存储学生：键：Student，值：String
Map<Student,String> map = new HashMap<>();
// Map<String,Student> map01 = new HashMap<>();
// 3. 添加多个学生到Map集合中
map.put(new Student("rose",18),"东莞");
map.put(new Student("lucy",30),"广州");
map.put(new Student("lily",28),"深圳"); // 66666 % 16 = 1
map.put(new Student("lily",28),"珠海"); // 66666 % 16 = 1
// 4. 遍历输出Map集合学生数据
Set<Entry<Student, String>> entrySet = map.entrySet();
for (Entry<Student, String> entry : entrySet) {
System.out.println(entry);
}
}
}
package com.itheima._05HashMap存储自定义类型;
import java.util.Objects;
/**
1. 定义学生类封装姓名和年龄
*/
public class Student {
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public Student() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age &&
Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}
6.LinkedHashMap
-
概述
-
继承HashMap 能够保证存取有序
-
底层：哈希表＋链表
package com.itheima._06LinkedHashMap基本使用; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.Set; /** 目标：掌握LinkedHashMap集合的特点 讲解： 1. LinkedHashMap概述 * 底层结构：哈希表+链表 * 继承了HashMap：能够保证存取有序。 小结： LinkedHashMap集合的特点：继承了HashMap：能够保证存取有序。 */ public class Demo06 { public static void main(String[] args) { // 创建Map集合 LinkedHashMap<String,String> map = new LinkedHashMap<>(); map.put("fasfasf", "fasf"); map.put("423dsa", "fasf"); map.put("gfdga", "fasf"); map.put("xxaf", "fasf"); // 获得键集合 Set<String> keySet = map.keySet(); for (String key : keySet) { System.out.println(key+"="+map.get(key)); } } }
-
7.Map集合练习
package com.itheima._07Map集合练习;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
/**
需求说明：
从键盘中录入一个字符串：计算一个字符串中每个字符出现次数。
"aaaabbbccceeeee"
Map ==> 映射：一个对一个
a=4
b=3
c=3
e=5
Map<Character,Integer> map;
map.put("a",4);
map.put("b",2);
步骤分析：
1. 创建键盘录入对象：Scanner
2. 接收用户输入的字符串：String
3. 创建Map集合存储字符与其出现次数的对应关系：Map<Character,Integer> map;
4. 遍历字符串获得每一个字符：就是map集合的键
5. 根据字符获得次数
5.1 如果没有获取到，则代表字符是第1次出现，则添加键值对到map集合
5.2 如果获得到，则将次数加一更新到Map集合中
6. 遍历Map集合输出键和值
*/
public class Demo07 {
public static void main(String[] args) {
// 1. 创建键盘录入对象：Scanner
Scanner sc = new Scanner(System.in);
// 2. 接收用户输入的字符串：String
System.out.println("请输入一个字符串...");
String line = sc.nextLine();
// 3. 创建Map集合存储字符与其出现次数的对应关系：Map<Character,Integer> map;
Map<Character,Integer> map = new LinkedHashMap<>();
// 4. 遍历字符串
for (int i = 0; i < line.length(); i++) { // aabc
// 根据索引获得字符:就是map集合的键
char ch = line.charAt(i); // b
// 将字符作为键到map集合中获得值：字符出现次数
Integer count = map.get(ch); // null
// 判断count是否有值
if (count != null) {
map.put(ch, count + 1); // {a=2}
} else {
// 第1次出现：添加键值对到map集合
map.put(ch, 1); // {a=1,b=1}
}
}
// 6. 遍历Map集合输出键和值
Set<Character> keySet = map.keySet();
for(Character key:keySet){
System.out.println(key+"="+map.get(key));
}
}
}
package com.itheima._07Map集合练习;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
/**
需求说明：
从键盘中录入一个字符串：计算一个字符串中每个字符出现次数。
"aaaabbbccceeeee"
Map ==> 映射：一个对一个
a=4
b=3
c=3
e=5
Map<Character,Integer> map;
map.put("a",4);
map.put("b",2);
步骤分析：
1. 创建键盘录入对象：Scanner
2. 接收用户输入的字符串：String
3. 创建Map集合存储字符与其出现次数的对应关系：Map<Character,Integer> map;
4. 遍历字符串获得每一个字符：就是map集合的键
5. 根据字符获得次数
5.1 如果没有获取到，则代表字符是第1次出现，则添加键值对到map集合
5.2 如果获得到，则将次数加一更新到Map集合中
6. 遍历Map集合输出键和值
*/
public class Demo071 {
public static void main(String[] args) {
// 1. 创建键盘录入对象：Scanner
Scanner sc = new Scanner(System.in);
// 2. 接收用户输入的字符串：String
System.out.println("请输入一个字符串...");
String line = sc.nextLine();
// 3. 创建Map集合存储字符与其出现次数的对应关系：Map<Character,Integer> map;
Map<Character,Integer> map = new LinkedHashMap<>();
// 4. 遍历字符串
for (int i = 0; i < line.length(); i++) { // aabc
// 根据索引获得字符:就是map集合的键
char ch = line.charAt(i); // b
if (map.containsKey(ch)){
// 不是第一次
map.put(ch, map.get(ch)+1);
}else {
// 第1次
map.put(ch, 1);
}
}
// 6. 遍历Map集合输出键和值
Set<Character> keySet = map.keySet();
for(Character key:keySet){
System.out.println(key+"="+map.get(key));
}
}
}
8. 冒泡排序
-
算法原理概述
相邻元素比较大小，大的放后面，小的放前面
-
冒泡排序算法代码演示
package com.itheima._10排序算法; import java.util.ArrayList; import java.util.Arrays; /** 目标：理解冒泡排序算法的原理 讲解： 1. 冒泡排序算法原理概述 相邻元素比较大小，大的放后面，小的放前面。 [1,4,2,7,3] 第1趟 第1次：[1,4,2,7,3] 第2次：[1,2,4,7,3] 第3次：[1,2,4,7,3] 第4次：[1,2,4,3,7] 第2趟 第1次：[1,2,4,3,7] 第2次：[1,2,4,3,7] 第3次：[1,2,3,4,7] 第3趟 第1次：[1,2,3,4,7] 第2次：[1,2,3,4,7] 第4趟 第1次：[1,2,3,4,7] 循环趟数 = 数组元素个数 - 1; 每趟比较的次数 = 数组元素个数 - 趟数 2. 冒泡排序算法代码演示 * 使用冒泡排序算法对数组元素排序：[55, 22, 99, 88] 小结： 冒泡排序算法原理：比较相邻的元素，大的往后放，小的往前放 */ public class Demo11 { public static void main(String[] args) { // test01(); test02(); } // 使用冒泡排序对集合排序 public static void test02() { // 定义集合 ArrayList<Integer> list = new ArrayList<>(); // 添加元素 list.add(42); list.add(12); list.add(62); list.add(2); list.add(22); System.out.println("排序前：" + list); // 外循环：控制比较的趟数 for (int i = 0; i < list.size() - 1 ; i++) { // 内循环：控制每趟比较的次数 for (int j = 0; j < list.size() - i - 1; j++) { if (list.get(j) > list.get(j + 1)) { int temp = list.get(j); list.set(j, list.get(j+1)); list.set(j+1, temp); } } } System.out.println("排序后：" + list); } // 使用冒泡排序对数组排序 public static void test01() { // 定义数组 int[] arr = {7,14,26,7,3}; System.out.println("排序前：" + Arrays.toString(arr)); // 外循环：控制比较的趟数 for (int i = 0; i < arr.length - 1 ; i++) { // 内循环：控制每趟比较的次数 for (int j = 0; j < arr.length - i - 1; j++) { if (arr[j] > arr[j+1]) { int temp = arr[j]; arr[j] = arr[j + 1]; arr[j+1] = temp; } } } System.out.println("排序后：" + Arrays.toString(arr)); } }
9.可变参数
- sum(int… a) int…数组
一个方法只有一个可变参数
非可变参数 一定要在最前面
数据类型…数组名 本质: 数组
package com.itheima._13可变参数;
/**
目标：能够在方法参数列表中使用可变参数
讲解：
1. 可变参数引入：
定义一个方法求2个整数之和
定义一个方法求3个整数之和
2. 什么是可变参数
JDK1.5新特性
参数个数可以是任意个：0到n
3. 可变参数的格式
数据类型...变量名
本质：数组
4. 可变参数的注意事项
一个方法参数列表中只能有一个可变参数
可变参数必须出现在参数列表的最后
小结：
1. 可变参数格式
数据类型...数组名
2. 可变参数的本质
数组
*/
public class Demo13 {
public static void main(String[] args) {
System.out.println(sum(20));// 0
System.out.println(sum(4)); // 0
System.out.println(sum(1, 2)); // 2
System.out.println(sum(1, 2,3));// 5
System.out.println(sum(1, 2,3,3,432,1,412,423,41,4,14,1));// 1336
}
// 使用可变参数
public static int sum(int a,int...arr){ // [I@6d86b085
// System.out.println(arr);
// 定义求和变量
int result = 0;
for (int num : arr) {
result += num;
}
return result;
}
/* // 定义一个方法求2个整数之和
public static int sum(int a,int b){
return a + b;
}
// 定义一个方法求3个整数之和
public static int sum(int a,int b,int c){
return a + b + c;
}*/
}
10.Collections 工具类
-
public static boolean addAll(Collection c,T… e)
将数组中的所有元素添加到指定的集合中
-
public static void shuffle(List<?> list)
将集合元素乱序
-
public static void short()(List list)
将集合元素进行排序，默认是升序排序
package com.itheima._11Collections工具类; import java.util.ArrayList; import java.util.Collections; /** 目标：掌握Collections工具类常用方法 讲解： Collections工具类常用方法 public static <T> boolean addAll(Collection<T> c, T... elements) 将数组中的所有元素添加到指定的集合中 public static void shuffle(List<?> list) 将集合元素乱序 public static <T> void sort(List<T> list) 对集合元素进行排序，默认是升序排序 小结： 1. addAll方法的作用：添加多个元素到指定集合中 2. shuffle方法的作用：对集合元素乱序 3. sort方法的作用：对集合元素排序，默认是升序 */ public class Demo11 { public static void main(String[] args) { // 创建集合 ArrayList<Integer> list = new ArrayList<>(); System.out.println(list); // 添加元素 Collections.addAll(list,34,4,341,3,33,13,1,354,7675); System.out.println(list); // 对集合元素乱序 // shuffle:洗牌 Collections.shuffle(list); System.out.println(list); // 对集合元素排序 Collections.sort(list); System.out.println(list); } }
11.Comparator自定义比较器
package com.itheima._12自定义Comparator比较器;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
/**
目标：自定义Comparator比较器对集合元素[整型]排序
讲解:
1. Collections工具类中与自定义比较器相关的方法
* public static <T> void sort(List<T> list,Comparator<T> c)
* 使用自定义比较器对集合元素进行排序
* Comparator是一个接口，需要创建接口实现类对象：比较器
2. 自定义Comparator比较器对集合排序：集合存储整型数据
小结：
1. 自定义Comparator比较器的步骤
* 创建类实现Comparator接口
* 实现重写compare方法：在该方法中编写排序规则：
* return o1 - o2 升序
* return o2 - o1 降序
*/
public class Demo121 {
public static void main(String[] args){
// 创建集合对象
ArrayList<Integer> list = new ArrayList<>();
// 将数组中的元素添加到指定的集合中
Collections.addAll(list,1,4,2,7,3);
System.out.println("排序前：" + list);
// 创建比较器对象
// MyComparator comparator = new MyComparator();
// 自定义比较器排序集合元素：升序排序
// Collections.sort(list,comparator);
// 使用匿名内部类直接创建比较器对象
Collections.sort(list,new Comparator<Integer>(){
@Override
public int compare(Integer o1, Integer o2) {
return o2 - o1;
}
});
System.out.println("排序后：" + list);
}
}
/*
自定义比较器步骤
1. 创建类实现Comparator接口
2. 实现Comparator接口中的抽象方法：compare
3. 在compare方法定义比较规则
*/
// 1. 创建类实现Comparator接口
class MyComparator implements Comparator<Integer> {
// 2. 实现Comparator接口中的抽象方法：compare
// 不需要手动调用该方法，sort方法内部会自动触发该方法的调用
// 归并排序+快速排序
@Override
public int compare(Integer o1, Integer o2) { // o1 = 1,o2 = 4
// 3. 在compare方法定义比较规则
// o1 - o2： 升序
// o2 - o1： 降序
return o2.compareTo(o1);
}
}
package com.itheima._12自定义Comparator比较器;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
/**
目标：自定义Comparator比较器对集合元素[自定义对象]排序
讲解:
1. 自定义Comparator比较器对集合排序：集合存储自定义对象
public static <T extends Comparable> void sort(List<T> list)
如果想使用该方法对集合元素进行排序，则要求集合的元素必须实现了Comparable接口
*/
public class Demo122 {
public static void main(String[] args){
// 创建集合
ArrayList<Student> list = new ArrayList<>();
// 添加学生
list.add(new Student("jack",20,90));
list.add(new Student("rose",50,76));
list.add(new Student("lily",30,95));
list.add(new Student("lucy",19,80));
// 自定义比较器：对集合学生进行排序
Collections.sort(list,new Comparator<Student>(){
@Override
public int compare(Student o1, Student o2) {
// 按照年龄升序排序
// return o1.getAge() - o2.getAge();
// 按照成绩降序排序
return o1.getScore() - o2.getScore();
}
});
for (Student stu : list) {
System.out.println(stu);
}
}
}
package com.itheima._12自定义Comparator比较器;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
/**
目标：自定义Comparator比较器对集合元素[自定义对象]排序
讲解:
1. 自定义Comparator比较器对集合排序：集合存储自定义对象
public static <T extends Comparable> void sort(List<T> list)
如果想使用该方法对集合元素进行排序，则要求集合的元素必须实现了Comparable接口
小结
对自定义对象进行排序方式
1. 自定义比较器
* 创建集合对象
* 添加自定义对象到集合中
* 调用Collections工具类的sort(集合对象,比较器对象);
* 在自定义比较器的compare方法中定义排序规则
2. 让自定义类实现Comparable接口
* 自定义类实现Comparable接口,重写compareTo方法：定义排序规则
* 创建集合对象
* 添加自定义对象到集合中
* 调用Collections工具类的sort(集合对象);排序
内部会自定调用自定义类重写的compareTo方法
*/
public class Demo123 {
public static void main(String[] args){
// 创建集合
ArrayList<Student> list = new ArrayList<>();
// 添加学生
list.add(new Student("jack",20,90));
list.add(new Student("rose",50,76));
list.add(new Student("lily",30,95));
list.add(new Student("lucy",19,80));
// 对集合中的学生排序
Collections.sort(list);
for (Student stu : list) {
System.out.println(stu);
}
}
}
package com.itheima._12自定义Comparator比较器;
import java.util.Objects;
/**
* 定义一个学生类，包含姓名/年龄/成绩三个成员变量。
*/
public class Student implements Comparable<Student>{
private String name;
private int age;
private int score;
public Student(String name, int age, int score) {
this.name = name;
this.age = age;
this.score = score;
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public Student() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", score=" + score +
'}';
}
// 重写Comparable接口方法
// 作用：用来定义排序规则
@Override
public int compareTo(Student o) {
// this ==> o1
// o ==> o2
return o.age - this.age;
}
}
12.总结
/**
教学目标
- 能够使用集合工具类Collections
addAll：将数组的元素添加到指定的集合中
shuffle：对集合元素乱序
sort(List list)：对集合元素排序，默认升序
sort(List list, Comparator c)：使用自定义比较器对集合元素排序，
- 能够使用Comparator比较器进行排序
1. 创建类实现Comparator接口并重写compare方法
2. 在compare方法中编写比较规则：
return o1 - o2; // 升序
return o2 - o1; // 降序
- 能够使用可变参数
概述：JDK1.5新特性，参数个数任意
格式：数据类型...数组名
本质：数组
- 能够理解冒泡排序的原理
比较相邻的元素，大的放在后面，小的放前面
- 能够说出Map集合特点：双列集合，存储键值对数据：键唯一，值可以重复。
- 使用Map集合添加方法保存数据
V put(K key,V value)
有则修改，无则添加
- 使用”键找值”的方式遍历Map集合
1. 调用Map集合的keySet方法获得键集合
2. 使用增强for或迭代器遍历键集合获得每一个键
3. 调用Map集合的get方法根据键获得值
- 使用”键值对”的方式遍历Map集合
1. 调用Map集合的entrySet方法获得Entry对象集合
2. 使用增强for或迭代器遍历Entry对象集合获得每一个Entry对象
3. 调用Entry对象的getKey和getValue方法获得键和值
- 能够使用HashMap存储自定义键值对的数据
HashMap<Student,String> 如果需要去重，需要重写hashCode和equals方法
HashMap<String,Student> 不需要重写hashCode和equals方法
知识回顾
1. Iterator迭代器
作用：用来遍历集合
Collection接口与获取迭代器相关的方法：Iterator iterator();
如何获得迭代器对象：集合对象.iterator();
常用方法：
boolean hasNext(); 判断是否有下一个元素，有返回true，否则false
E next(); 将指针下移指向下一个元素并返回当前位置的元素
2. 增强for
作用：用来遍历集合和数组
格式：for(数据类型 变量名:数组或集合){ }
本质：迭代器
List体系：有序，有索引，元素可重复
3. ArrayList：数组结构，增删慢，查询快
4. LinkedList：链表结构，增删快，查询慢
Set体系：无序，无索引，元素不可重复
5. HashSet：哈希表(数组+链表+红黑树(JDK1.8))
6. LinkedHashSet:哈希表+链表：能够保证存取有序。
*/
记得点赞关注哦 ！谢谢你们！加油！ヾ(◍°∇°◍)ﾉﾞ
``
扫一扫
391
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
