Java学习--集合

最新推荐文章于 2024-07-09 16:46:46 发布

王槐瑞

最新推荐文章于 2024-07-09 16:46:46 发布

阅读量78

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_59548805/article/details/132773108

版权

集合

collection接口

collection接口是Java集合框架中的根接口，因为它继承了Iterable接口，所以可以被用来遍历集合中的元素。它还提供了一组通用的方法，用于对集合进行基本的操作，如添加、删除、查找、遍历。

Queue接口（队列）

1.除了基本的 Collection 操作之外，队列还提供额外的插入，提取和检查操作。 2.不可以存 null
- add（）：将元素插入队列，没有空间抛异常
- offer（）：将元素插入队列，成功返回true，不成功返回false。
- element（）：检索但不删除队列的头部，队列为空抛异常
- peek（）：检索不删除队列头部，如果队列为空，返回null。
- poll（）：检索并删除此队列的头，如果此队列为空，则返回 null
- remove（）：检索并删除此队列的头，如果此队列为空，它将抛出异常
Deque（双端队列）
- addFirst（）：插入此双端队列的前面
- addLast（）：双端队列的末尾插入元素
- getFirst（）：检索，但不删除，第一个元素
- getLast()：检索，但不删除，最后一个元素
- pop（）：删除并返回此deque的第一个元素
- push（）：插入此双端队列的前面
- removeFirstOccurrence（）：从此双端队列中删除第一次出现的指定元素。如果双端队列不包含该元素，则它保持不变。

List接口（有序集合）

List中的静态方法of和copyOf都是返回一个不可修改的List集合，数组可通过Arrays.asList（）将一个数组转换成List集合，生成的集合不可变（不能删除或者添加元素，但能够修改元素）。

ArrayList类（动态数组）
- ArrayList相当于一个动态数组，可以存null
LinkedLIst类
- Linked实现了Deque接口，可以把它当作双端队列使用
- LinkedList底层实现是双链表
Vector类
- 是一种动态数组，可以自动扩展和缩小数组大小，实现了List接口，且所有的方法都是同步的
- Vector类的特点
  - 1.动态数组：自动扩展，默认大小为10。
  - 2.线程安全
  - 3.支持随机访问：可根据索引值访问元素
  - 4.可包括重复元素
  - 5.可插入null元素
- Stack类（栈）（先入后出）
  - empty（）：查看堆栈是否为空
  - peek（）：返回栈顶元素，不删除
  - pop（）：弹出栈顶元素并返回
  - push（）：将元素加到栈顶
  - search（）：从栈顶开始，栈顶元素序号为1.

Set（唯一、无序）

set集合说明
- 不包含重复元素的集合，可以存null
- 抽象方法大多数继承Collection
- of 方法和 copyOf ，都是 static 方法返回一个不可修改的 Set 集合。
  - 代码实现：Set a = Set.of("a", "b", "c");
- set集合不可修改不能删除或添加元素
- 不允许 null 元素。尝试使用 null 元素创建它们会导致 NullPointerException
TreeSet类（唯一、有序）
- 父类为AbstractSet，实现了Set接口，拥有Set接口唯一的特性，是实现了set接口的有序集合
- TreeSet集合中所存元素都必须是可比较的，而且是不重复的，允许存null。
- TreeSet集合一当创建就不可变（无修改方法）
HashSet类
- 实现了Set接口，底层实现HashMap
- 允许存null，无序
LinkedHashSet

Map接口

Map接口的主要特点： 1.键值对映射。 2.Map不能有重复的键，每个键可以最多映射到最多一个值 3.key不要求有序，不可以重复。value也不要求有序，但可以重复。 4.使用对象做key时，也要重写equals和hashCode。

HashMap类

基于哈希表实现的Map接口
允许null值和null键
非线程安全
其他特点与Hashtable基本一致
元素存储
- 添加值时，如果 hash 一样添加到链表尾部
- HashMap 的 put 过程:
- 存储时，根据内部的 hash 方法计算 key ,来确定 value 的存储位置（ Map 的桶bucket），如果 hash 相同，在计算下标。如果产生没有碰撞（ key 不相同）,直接放到桶中，由于 h ash 相同，所以放到一个桶中。放的时候，如果没有超过阈值(8)，以链表的形式放到后边，长度超过阈值且数组长度大于等于64将链表转换成红黑树存储。

TreeMap类

继承AbstractMap，一个红黑树基于NavigableMap实现
非线程安全
key不能存null，但value可以存null
key必须是可以比较的（实现Comparable接口或传递一个比较器）
TreeMap为TreeSet的底层实现相当于将TreeMap的value固定为默认值，对key进行操作，所以TreeMap中的方法大多数与TreeSet相似

Hashtable类

该类实现了一个哈希表，它将键映射到值
不允许null作为键和值
线程安全
不保证顺序
默认容量为11，默认负载因子为0.75f
- 负载因子是一个重要的参数，它描述了在散列表中每个桶（bucket）的平均元素数量。负载因子是一个在0到1之间的数值，表示桶的使用程度。较高的负载因子表示桶中的元素较多，较小的负载因子表示桶中的元素较少。
扩容方式是旧容量的 2倍+1（为了均匀分布，降低冲突率）
数组+链表的方式存储实现Hash表的存储
- 如果 hash 一样 equals 为 false 则将当前值添加到链表头
- 如果 hash 一样 equals 为 true 则使用当前值替换原来的值（ key 相同）
方法大多数来自于Map

Map常用方法

containsKey（）：Map中有没有这也Key
containsValue()：Map中有没有这个Value
entrySet（）：返回包含映射的Set集合的视图
- 视图：返回的视图的中做修改原集合也会改变
get（）：根据key返回对应的value
keySet（）：返回Map中所有Key的Set集合
put(K key, V value) ：向Map中添加映射
replace（）：当key存在，替换内容。
values（）：返回所有value的集合

Iterable接口

接口作用.

实现了Iterable接口的类可以通过实现iterator（）方法来返回一个迭代器对象，从而使其可以使用for-each循环语句来遍历集合中的元素.

代码实现

使用迭代器遍历
- Set<String> a = Set.of("a", "b", "c"); // 声明迭代器对象 Iterator<String> iterator = a.iterator(); while (iterator.hasNext()){ String obj = iterator.next(); System.out.println(obj); }
for-each循环遍历
- for(数据类型变量名 : 循环对象){ //循环体 } //变量是循环对对象的值，不是索引

forEach方法

用于迭代输出集合
- list.forEach(s -> System.out.println(s));

remove 方法

remove()方法在迭代过程中移除由next()方法最后返回的元素

Stream流

生成流的方式

Collection体系集合：使用默认方法stream（）生成流
- List<String> list = new ArrayList<>();
- Stream<String> stream1 = list.stream();
Map体系集合：把Map转成Set集合，间接的生成流
数组：通过Arrays中的静态方法stream生成流。
同种数据类型的多个数据：通过Stream接口的静态方法of(T... values)生成流

常用方法

非终结方法
- filter（）：用于对流中的数据过滤
- limit（）：返回此流中的元素组成的流，截取前指定参数个数的数据
- skip（）：跳过指定参数个数的数据，返回由该流的剩余元素组成的流。
- concat（）：合并a和b两个流为一个流
- distinct（）：返回由该流的不同元素（根据Object.equals(Object) ）组成的流
- mapToInt(IntFunction<? super T>) :将 Stream 中的元素映射为一个 int 类型的数值
终结方法
- collect(Collector collector): 将 Stream 中的元素收集到一个集合并返回。
- forEach(Consumer action): 对 Stream 中的每个元素执行给定的操作。
- reduce(BinaryOperator<T> accumulator): 将 Stream 中的元素聚合为一个单一值。
- collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner): 将 Stream 中的元素收集到一个自定义类型的集合中。
- reduce(T identity, BinaryOperator<T> accumulator):该方法接受一个初始值和一个二元操作符，将流式数据中的元素逐个进行归约操作，最终得到一个结果
- max(Comparator<? super T> comparator): 返回 Stream 中最大的元素。
- min(Comparator<? super T> comparator): 返回 Stream 中最小的元素。
- noneMatch(Predicate<? super T> predicate): 检查 Stream 中是否有元素满足给定的条件。
- anyMatch(Predicate<? super T> predicate): 检查 Stream 中是否有元素满足给定的条件。
- findFirst(): 返回 Stream 的第一个元素（如果有的话）。
- findAny(): 返回 Stream 的任意一个元素（如果有的话）。
- iterator(): 返回一个迭代器，用于遍历 Stream 中的元素。
- spliterator(): 返回一个 Spliterator，用于遍历 Stream 中的元素。

Stream流的收集操作

R collect(Collector collector)：把结果收集到集合中
工具类Collectors
- public static <T> Collector toList()：把元素收集到List集合中
- public static <T> Collector toSet()：把元素收集到Set集合中
- public static Collector toMap(Function keyMapper,Function valueMapper)：把元素收集到Map集合中
  - collect(Collectors.toMap( s -> s.split(",")[0], s -> Integer.parseInt(s.split(",")[1]) ));
- Collectors.joining()方法是java.util.stream.Collectors类中的一个静态方法，用于将流中的字符串元素连接成一个字符串。它可以接受一个分隔符作为参数，用于在连接字符串时插入的字符。
  - 子主题 1

Collections类（集合操作工具类）

包含了大量的静态方法，用于实现对集合元素的排序、查找和替换等操作。

常用方法

sort(List<T> list): 对列表中的元素进行排序。
sort(List<T> list, Comparator<? super T> c): 根据指定的比较器对列表中的元素进行排序。
binarySearch(List<? extends Comparable<? super T>> list, T key): 使用二分搜索算法在指定的列表中搜索指定的元素。
binarySearch(List<? extends Comparable<? super T>> list, T key, int fromIndex, int toIndex): 使用二分搜索算法在指定的列表中从指定的开始索引到结束索引之间搜索指定的元素。
max(Collection<?> coll): 返回集合中的最大元素。
max(Collection<?> coll, Comparator<? super T> comp): 根据指定的比较器返回集合中的最大元素。
min(Collection<?> coll): 返回集合中的最小元素。
min(Collection<?> coll, Comparator<? super T> comp): 根据指定的比较器返回集合中的最小元素。
copy(List<? super T> dest, List<? extends T> src): 将源列表中的元素复制到目标列表中。
copy(List<? super T> dest, List<? extends T> src, int sourceFromIndex, int sourceToIndex): 将源列表中的一部分元素复制到目标列表中。
swap(List<? extends T> list, int i, int j): 在列表中交换指定索引处的元素。
fill(List<? super T> list, T obj): 使用指定的元素填充列表。
fill(List<? super T> list, int index, int size, T obj): 使用指定的元素填充列表的一部分。
rotate(List<? super T> list, int distance): 将列表中的元素旋转指定的距离。
replaceAll(List<? super E> list, UnaryOperator<E> operator): 使用指定的操作替换列表中的所有元素。
indexOfSubList(List<? extends E> source, List<? extends E> target): 在源列表中搜索指定的目标列表，并返回第一次出现的位置。
lastIndexOfSubList(List<? extends E> source, List<? extends E> target): 在源列表中搜索指定的目标列表，并返回最后一次出现的位置。
disjoint(Collection<?> c1, Collection<?> c2): 检查两个集合是否没有交集。
addAll(Collection<? super T> c1, Collection<? extends T> c2): 将一个集合中的所有元素添加到另一个集合中。
shuffle(List<?> list): 随机打乱列表中的元素顺序。
singleton(T o): 返回一个只有一个元素的不可变集合。
singletonList(T o): 返回一个只有一个元素的列表。
singletonMap(K key, V value): 返回一个只有一个键值对的映射表。
emptySet(): 返回一个空的不可变集合。
emptyList(): 返回一个空的列表。
emptyMap(): 返回一个空的映射表。