集合Collection思维导图

U419205878

2022-12-12

浏览量: 4

树图思维导图提供《集合Collection》在线思维导图免费制作，点击“编辑”按钮，可对《集合Collection》进行在线思维导图编辑，本思维导图属于思维导图模板主题，文件编号是：ccd4e14f7b7d34f2a90e2a1e642dad7b

思维导图大纲

特点

集合长度可变

只能存储引用数据类型，存储基本类型数据，要存相应的包装类(例如Integer)，实际底层实现了自动装箱过程

常用方法

1.添加元素

方法：boolean add(E e)

例：Collection<String> ll = new ArrayList<>(); ll.add("aaa");

2.删除指定元素

方法：boolean remove(Object o)

3.根据条件进行删除元素

boolean removeIf(Object o)

例：删除长度为3的所有元素 ll.removeIf(s -> s.length() == 3);

4.清空集合元素

方法：void clear()

例： Collection<String> ll = new ArrayList<>(); ll.clear();

5.判断集合中是否存在指定元素

方法：boolean contains(Object o)

例：Collection<String> ll = new ArrayList<>(); ll.contains("aaa")

6.判断集合是否为空

方法：boolean isEmpty()

例：ll.isEmpty()

7.获取集合的长度

方法：int size()

例：System.out.println(ll.size());//0

List集合

特点

1.存取顺序一致: 数据是按添加的顺序存储的，取的时候，可以使用索引按存储的顺序取出

2.可以添加重复元素

3.可以根据索引操作

特有方法

1.在此集合中的指定位置插入指定的元素

方法介绍：void add(int index,E element)

方法案例：List<String> list = new ArrayList(); 在索引2的位置添加数据xx list.add(2, "xx");

2.删除指定索引处的元素，返回被删除的元素

方法介绍：E remove(int index)

方法案例：//删除索引为2的位置的数据返回被删除的数据xx String str01 = list.remove(2);

3.修改指定索引处的元素，返回被修改的元素

方法介绍：E set(int index,E element)

方法案例：//把索引为3的位置的数据改为ff 返回被修改的dd String str02 = list.set(3, "ff");

4.返回指定索引处的元素

方法介绍：E get(int index)

方法案例：//获取索引0位置的数据 String str03 = list.get(0);

数据存储方式

数组（数据的顺序存储方式）

原因是：查询是根据确定的索引然后计算相差的数量乘以每一个空间的内存大小；增删慢是因为需要一个一个往前或者后去移动数据

数组特点：查询快，增删慢

ArraryList底层是数组形式存储数据

底层实现逻辑： - 1在创建ArrayList对象的时候,底层会创建一个空的数组 - 2在第一次添加数据的时候,会把数组扩容为10个大小,然后把数据添加进去 - 3在数组装满了之后,再次添加数据,会把原数组扩容1.5倍

链表（数据的链式存储方式）

链表特点：增删快查询慢

增删快原因：链表不需要改变内存的地址，只需要修改节点的信息即可（包括指针指向，节点值）。查询慢原因：存储是非连续性，非顺序的结构，查询起来很慢

LinkedList集合

特有方法

1.在该列表开头插入指定的元素

方法介绍：public void addFirst(E e)

2.在尾部增加元素

public void addLast(E e)

3.获取列表第一个元素

public E getFirst()

4.获取列表最后一个元素

public E getLast()

5.删除列表第一个元素

public E removeFirst()

6.删除列表最后一个元素

public E removeLast()

底层是双向链表结构（pre指向前）（next指向后）

数据结构

树

二叉树

二叉树中,任意一个节点的度要小于等于2

二叉查找树

1.左子树上所有节点的值都小于根节点的值 2.右子树上所有节点的值都大于根节点的值 3.一样的数据不存

平衡二叉树

1.二叉树左右两个子树的高度差不超过1 2.任意节点的左右两个子树都是一颗平衡二叉树

左旋：就是将根节点的右侧往左拉,原先的右子节点变成新的父节点,并把多余的左子节点出让,给已经降级的根节点当右子节点；右旋：就是将根节点的左侧往右拉,左子节点变成了新的父节点,并把多余的右子节点出让,给已经降级根节点当左子节点

红黑树

特点： 1.平衡二叉B树； 2.每一个节点可以是红或者黑； 3.红黑树不是高度平衡的,它的平衡是通过"自己的红黑规则"进行实现的

红黑规则

1. 每一个节点或是红色的,或者是黑色的 2. 根节点必须是黑色 3. 如果一个节点没有子节点或者父节点,则该节点相应的指针属性值为Nil,这些Nil视为叶节点,每个叶节点(Nil)是黑色的

4.如果某一个节点是红色,那么它的子节点必须是黑色(不能出现两个红色节点相连的情况)

添加节点的父节点相邻的节点为红色

1：将添加的节点的父节点设为黑色，将父节点相邻的节点也设为黑色

2：将父节点的父节点设为红色

3：如果祖父节点为根节点，则将根节点再次变为黑色

添加节点的父节点相邻的节点为黑色

1：将“父节点”设为黑色

2：将祖父节点设为红色

3：以祖父节点为支点进行旋转

迭代器iterator

作用：用来遍历集合用的,把集合的数据一个一个取出来.

获取集合的迭代器对象

iterator()方法

返回此集合中元素的迭代器,通过集合对象的iterator()方法得到

特点：一个新的迭代器对象，在一开始会默认指向集合中第0个数据

案例方法：Collection<String> coll = new ArrayList<>(); Iterator<String> it = coll.iterator();

迭代器遍历集合用到的方法

hasNext()方法

可以判断当前迭代器指向的集合的位置是否有数据

next()方法

取出当前位置的元素 , 并且将迭代器移动到下一个数据的位置

方法使用案例：while (it.hasNext()){ System.out.println(it.next()); }

迭代器循环中删除

remove方法

会删除迭代器调用next返回的数据

增强for循环

作用

增强for循环, 用来获取集合数据很简洁好用（无法使用索引遍历的，可使用增强for循环）

增强for循环的底层原理是迭代器,所以它符合迭代器的相关特点

语法格式

for(集合/数组中元素的数据类型变量名 : 集合/数组名) { // 已经将当前遍历到的元素封装到变量中了,直接使用变量即可 }

案例：ArrayList<String> coll = new ArrayList<String>(); for (String s : coll) { System.out.println(s); }

注意事项

1.实现Iterable接口的类才可以使用迭代器和增强for； 2.简化数组和Collection集合的遍历

如果想获取索引,只能自己定义索引

案例：int index = 0; for (String s : coll) { index++; System.out.println(s); }

泛型

概述

泛型就是一个未知的类型

常用字符E（元素），T（type），K键，V值，S，U等。

定义格式

类

格式：修饰符 class 类名<代表泛型的变量> { }

多泛型例：public class Student<T,E>{ T age,E name }

方法中（要配合参数使用）

格式：修饰符 <代表泛型的变量> 返回值类型方法名(参数){ }

例子：public <T> void show(T age){ 传入什么类型参数，T就是什么类型 }

接口中（重点）

格式：修饰符 interface 接口名<代表泛型的变量> { }

例子：public interface Demo<T,E>{ 定义接口中的泛型T 在方法中使用了这个T定义参数e public void show(t e, int a); }

类型通配符: <?>

特点

1.ArrayList<?>: 表示元素类型未知的ArrayList,它的元素可以匹配任何的类型

2.如果使用了<?>,ArrayList就不能添加数据了,获取出来的也是Object类型

3.使用了<?>也不能修改数据了

类型通配符上限: <? extends 类型> (源码中常见)

ArrayList<? extends Number>: 它表示的类型是Number或者其子类型

类型通配符下限: <? super 类型> （用的很少）

ArrayList <? super Number>: 它表示的类型是Number或者其父类型

可变参数

介绍

定义方法参数的一种方式，方法的参数类型已经确定,个数不确定,我们可以使用可变参数

格式

修饰符返回值类型方法名(数据类型… 变量名) { }

例子： public static void sum(int... arr){}

注意事项

1.可变参数的变量其实是一个数组

2.如果一个方法有多个参数，包含可变参数，可变参数要放在最后，并且只能有一个可变参数

例子：public static void sum（int b, int ...a{ }

Collections工具类

常用方法

1.给集合批量添加数据

public static <T> boolean addAll(Collection<? super T> c, T...e)

例子： Collections.addAll(names, "张三","王五","李四", "张麻子");

2.打乱List集合的数据顺序

public static void shuffle(List<?> list)

例子：List<String> names = new ArrayList<>(); Collections.shuffle(names);

3.对List集合中的元素进行升序

public static <T> void short(List<T list)

例子： List<Integer> list = new ArrayList<>(); Collections.sort(list);

4.对集合中的元素，按照比较器指定的规则进行排序

public static <T> void short(List<T list，Comparator<? super T> c)

Stream流

思想和作用

类似于流水线，集合获取流后，在过程中多次处理流数据

Stream流的三类方法

获取Stream流

1.Collection体系，通过集合对象直接生成流

代码演示：Collection体系集合都用stream方法 Collection<Integer> coll = new TreeSet<>(); Stream<Integer> stream = coll.stream();

2.Map体系集合

1.把Map转成keySet集合间接的生成流

代码演示：Map<String ,String> map = new HashMap<>(); //获取所有的key的set集合再用set集合获取流 Set<String> keys = map.keySet(); Stream<String> stream1 = keys.stream();

2.把Map转成entrySet集合间接的生成流

获取所有的键值对的的set集合再用set集合获取流 Set<Map.Entry<String, String>> entries = map.entrySet(); Stream<Map.Entry<String, String>> stream2 = entries.stream();

3.数组

通过Arrays中的静态方法stream生成流 Arrays.stream(arr)

代码演示：int[] arr = new int[]{3,4,5,7,8}; //用Arrays工具类获取流对象 IntStream stream3 = Arrays.stream(arr);

4.同种数据类型的多个数据

通过Stream接口的静态方法of(T... values)生成流 , 原理还是数组变流

既然数组可以, 可变参数本质是数组 //Stream.of方法就是可以把同类型的多个数据转为流对象, 内部就是数组转流 Stream<String> stream4 = Stream.of("aaa", "bbb", "ccc");

中间操作方法

常见方法

1.用于对流中的数据进行过滤

Stream<T> filter(Predicate predicate)

代码演示： ArrayList<String> al = new ArrayList<String>(List.of("周润发", "成龙", "小明"）） //流的操作不影响原集合的数据 al.stream().filter(s -> s.length() >= 3).forEach(s -> System.out.println(s));

2.从前面获取指定数量的数据

Stream<T> limit(long maxSize)

代码演示：（获取前5个数据） al.stream().limit(5)

3.跳过指定参数的数据，获取后面的数据

Stream<T> skip(long n)

代码演示：（跳过前3个，获取后面的数据） al.stream().skip(3)

4.合并a和b两个流为一个流

static <T> Stream<T> concat(Stream a, Stream b)

代码演示： Stream.concat(al.stream(), al1.stream())

5.去掉流数据中重复的元素后剩余数据组成的流

Stream<T> distinct()

代码演示： Stream.concat(al.stream(), al1.stream()).distinct()

6.peek操作，可在流的中间操作中起到检查作用，而不是像forEach结束流

代码演示： al.stream().limit(5).peek(s -> System.out.println(s+"!")) .skip(3).peek(s -> System.out.println(s+"@"))

流操作特点:如果最后没有终结操作(forEach),那么所有的中间操作都不会启动

终结方法

常见方法

对此流的每个元素执行操作

void forEach(Consumer action)

代码演示： al.forEach(s -> { System.out.println(s); });

返回此流中的元素数

long count()

代码演示： long count = al.stream().count(); //获取数据的数量

collect收集操作

作用：collect方法获取流中剩余的数据,但是他不负责创建容器,也不负责把数据添加到容器中.

Collectors提供的三种收集方法

把元素收集到List集合中

public static <T> Collector toList()

代码案例： //使用流获取所有的偶数最后collect收集到List集合里 List<Integer> list = al.stream().filter(number -> number % 2 == 0).collect(Collectors.toList());

把元素收集到Set集合中

public static <T> Collector toSet()

代码演示： Set<Integer> set = al.stream().filter(number -> number % 2 == 0).collect(Collectors.toSet());

把元素收集到Map集合中

public static Collector toMap(Function keyMapper,Function valueMapper)

代码演示： Map<String, String> map =al.stream().collect(Collectors.toMap（ //返回key "001,周润发" 逗号分割第0个数据返回作为key s -> s.split(",")[0], ///返回value "001,周润发" 逗号分割第1个数据返回作为value s -> s.split(",")[1] ) );））

Set集合

特点

1 .不能存储重复数据

2 .没有索引，不能使用普通的for循环。增强for和迭代器都可以使用

3. 存取顺序不一致

treeSet

特点

1.不能存储重复数据

2.存取顺序不一致

3.特有方法：可以自然排序

自然排序

1.排序的类首先要实现Comparable接口

2.实现类后，需要重写compareT方法

3.compareTo返回值排序要求

1.compareTo方法如果返回的是正数（1）新的数据会排到后面（右侧），从大到小排序（ o. age - this.age）

2.compareTo方法如果返回的是负数（-1）新的数据会排到前面左侧，从小到大排序 (this.age-o.age)

3.compareTo方法如果返回的是0 新的数据就不会被添加

案例需求：先按你年龄排序如果年龄相等按姓名排序

案例代码：修改Student类里的compareTo方法 1.先比较年龄得到一个值result 2.result如果等于0 说明年龄相等再比较姓名 int result = this.age - o.age; return result == 0 ? this.name.compareTo(o.name) : result;

Comparator比较器排序

适用于同类型多个对象的排序要求不同

创建集合对象的时候传递Comparator的实现类对象

比较器对象以匿名内部类或者lambda表达式的形式传入，重写compare（T o1,T o2）f方法，根据返回值进行排序

案例代码： public class Student implements Comparable<Student>{ public int compareTo(Student o) { return 0; } } 1.//按照年龄从小到大排 TreeSet<Student> ts01 = new TreeSet<>(new Comparator<Student>() { @Override public int compare(Student o1, Student o2) { return o1.age - o2.age; } }); 2.//按照年龄从大到小排 TreeSet<Student> ts02 = new TreeSet<>(new Comparator<Student>() {@Override public int compare(Student o1, Student o2) { return o2.age - o1.age; } });

HashSet集合

特点

1.不能存储重复数据

2.数据存取顺序不一致

3.特有方法：可以数据去重

4.不能使用索引获取元素，使用增强for循环遍历集合

底层实现原理

JDK8以前：哈希表 = 数组+链表

1.创建一个默认长度16的数组，默认加载因子为0.75，数组名为table

2.使用元素的哈希值对数组的长度求余计算出应存入的位置

3.判断当前位置是否为null，如果是null 直接存入

4.如果不为null，表示有元素，则调用equals方法比较，相等，则不存；不相等，则存入数组

5.新存入的元素占老元素位置，老元素挂在下面，构成一个链表

JDK8以后：哈希表 = 数组+链表+红黑树

当链表长度达到8，且数组长度大于等于64 ，自动将链表转为红黑树

HashSet去重原理

1.hashCode方法确定在底层数组中存储的位置

2.equals方法判断新添加的元素是否和集合中已有的元素相同

3.实现去重，必须重写hashCode方法和equals方法

Map集合

声明：不属于Collection接口，单独的集合

概述

作用

Map 集合类用于存储元素对（称作“键”和“值”），其中每个键映射到一个值。键：key K ，值value V

特点

1.双列集合,一个键对应一个值 2.键不存在重复的,值可以重复

常用方法

1.添加元素（新值覆盖旧值）

V put(K key,V value)

案例：map.put("001", "zs");

2.根据键删除键值对元素

V remove(Object key)

map.remove("001");

3.移除所有的键值对元素

void clear()

案例：map.clear();//清空数据

4.判断集合是否包含指定的键

boolean containsKey(Object key)

案例：System.out.println(map.containsKey("001"));//true

5.判断集合是否包含指定的值

boolean containsValue(Object value)

案例：System.out.println(map.containsValue("zs"));//false

6.判断集合是否为空

boolean isEmpty()

案例：map.isEmpty()

7.集合的长度，也就是集合中键值对的个数

int size()

案例：map.size()

获取数据方法

根据键获取值

V get(Object key)

获取所有键的集合

Set<K> keySet()

获取所有值的集合

Collection<V> values()

获取所有键值对对象的集合

Set<Map.Entry<K,V>> entrySet()

第一种遍历

1.get可以根据key获取值，keySet可以获取所有的key； 2.可以遍历所有的key，再根据每个key获取值

代码案例： 1.//1先获取所有的key Set<String> sets = map.keySet(); 2.for (String k : set) { String v = map.get(k);

第二种遍历

1.entrySet()方法可以获取map里所有的键值对（封装到了Entry类的对象中），然后都放到了一个set集合中返回； 2.返回的set集合中，存的是Map.Entry类型的对象，每个对象可以获取到这条数据的key和value

1.Set<Map.Entry<String, String>> es = map.entrySet(); 2.for (Map.Entry<String, String> e : es) { System.out.println(e.getKey() + "=====" + e.getValue()); }

第三种遍历

forEach

代码实现： //forEach循环 map.forEach((k, v) -> { System.out.println(k + "====" + v); });

SpringBootWeb请求响应思维导图