Java知识点：容器-Collection

最新推荐文章于 2023-08-04 14:16:11 发布

LXR_Anran

最新推荐文章于 2023-08-04 14:16:11 发布

阅读量192

点赞数

分类专栏： java java8

本文链接：https://blog.csdn.net/qq_26154077/article/details/115449178

版权

java 同时被 2 个专栏收录

18 篇文章 0 订阅

订阅专栏

java8

3 篇文章 0 订阅

订阅专栏

一.容器接口：Collection

二.集合静态工具类：Collections

三.JDK8 Collector接口

四.JDK8 Collectors类

一.容器接口：Collection

1.接口定义：Interface Collection<E> 继承 Iterable <E>

2.参数类型：E - 此集合中元素的类型

3.接口方法：

Modifier and Type	Method and Description
`boolean`	`add(E e)` 确保此集合包含指定的元素（可选操作）。
`boolean`	`addAll(Collection<? extends E> c)` 将指定集合中的所有元素添加到此集合（可选操作）。
`void`	`clear()` 从此集合中删除所有元素（可选操作）。
`boolean`	`contains(Object o)` 如果此集合包含指定的元素，则返回 true 。
`boolean`	`containsAll(Collection<?> c)` 如果此集合包含指定集合中的所有元素，则返回true。
`boolean`	`equals(Object o)` 将指定的对象与此集合进行比较以获得相等性。
`int`	`hashCode()` 返回此集合的哈希码值。
`boolean`	`isEmpty()` 如果此集合不包含元素，则返回 true 。
`Iterator<E>`	`iterator()` 返回此集合中的元素的迭代器。
`default Stream<E>`	`parallelStream()` 返回可能并行的 `Stream`与此集合作为其来源。
`boolean`	`remove(Object o)` 从该集合中删除指定元素的单个实例（如果存在）（可选操作）。
`boolean`	`removeAll(Collection<?> c)` 删除指定集合中包含的所有此集合的元素（可选操作）。
`default boolean`	`removeIf(Predicate<? super E> filter)` 删除满足给定谓词的此集合的所有元素。
`boolean`	`retainAll(Collection<?> c)` 仅保留此集合中包含在指定集合中的元素（可选操作）。
`int`	`size()` 返回此集合中的元素数。
`default Spliterator<E>`	`spliterator()` 创建一个`Spliterator`在这个集合中的元素。
`default Stream<E>`	`stream()` 返回以此集合作为源的顺序 `Stream` 。
`Object[]`	`toArray()` 返回一个包含此集合中所有元素的数组。
`<T> T[]`	`toArray(T[] a)` 返回包含此集合中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型。

默认实现：Iterable接口中的forEach方法

4.被继承的子接口：

BeanContext ， BeanContextServices ， BlockingDeque <E>， BlockingQueue <E>， Deque <E>， List <E>， NavigableSet <E>， Queue <E>， Set <E>， SortedSet <E>， TransferQueue <E>

5.实现类：

AbstractCollection ， AbstractList ， AbstractQueue ， AbstractSequentialList ， AbstractSet ， ArrayBlockingQueue ， ArrayDeque ， ArrayList ， AttributeList ， BeanContextServicesSupport ， BeanContextSupport ， ConcurrentHashMap.KeySetView ， ConcurrentLinkedDeque ， ConcurrentLinkedQueue ， ConcurrentSkipListSet ， CopyOnWriteArrayList ， CopyOnWriteArraySet ， DelayQueue ， EnumSet ， HashSet ， JobStateReasons ， LinkedBlockingDeque ， LinkedBlockingQueue ， LinkedHashSet ， LinkedList ， LinkedTransferQueue ， PriorityBlockingQueue ， PriorityQueue ， RoleList ， RoleUnresolvedList ， Stack ， SynchronousQueue ， TreeSet ， Vector

二.集合静态工具类：Collections

1.作用：提供集合相关公共方法集合

2.静态常量：统一创建的空集合避免代码中重复创建

public static final Set EMPTY_SET空集（不可变）
public static final List EMPTY_LIST空列表（不可变）
public static final Map EMPTY_MAP空地图（不可变）

3.静态方法

Modifier and Type	Method and Description
`static <T> boolean`	`addAll(Collection<? super T> c, T... elements)` 将所有指定的元素添加到指定的集合。
`static <T> Queue<T>`	`asLifoQueue(Deque<T> deque)` 返回`Deque`作为先进先出（ Lifo ） `Queue`的视图。
`static <T> int`	`binarySearch(List<? extends Comparable<? super T>> list, T key)` 使用二叉搜索算法搜索指定对象的指定列表。
`static <T> int`	`binarySearch(List<? extends T> list, T key, Comparator<? super T> c)` 使用二叉搜索算法搜索指定对象的指定列表。
`static <E> Collection<E>`	`checkedCollection(Collection<E> c, 类<E> type)` 返回指定集合的动态类型安全视图。
`static <E> List<E>`	`checkedList(List<E> list, 类<E> type)` 返回指定列表的动态类型安全视图。
`static <K,V> Map<K,V>`	`checkedMap(Map<K,V> m, 类<K> keyType, 类<V> valueType)` 返回指定地图的动态类型安全视图。
`static <K,V> NavigableMap<K,V>`	`checkedNavigableMap(NavigableMap<K,V> m, 类<K> keyType, 类<V> valueType)` 返回指定可导航地图的动态类型安全视图。
`static <E> NavigableSet<E>`	`checkedNavigableSet(NavigableSet<E> s, 类<E> type)` 返回指定的可导航集的动态类型安全视图。
`static <E> Queue<E>`	`checkedQueue(Queue<E> queue, 类<E> type)` 返回指定队列的动态类型安全视图。
`static <E> Set<E>`	`checkedSet(Set<E> s, 类<E> type)` 返回指定集合的动态类型安全视图。
`static <K,V> SortedMap<K,V>`	`checkedSortedMap(SortedMap<K,V> m, 类<K> keyType, 类<V> valueType)` 返回指定排序映射的动态类型安全视图。
`static <E> SortedSet<E>`	`checkedSortedSet(SortedSet<E> s, 类<E> type)` 返回指定排序集的动态类型安全视图。
`static <T> void`	`copy(List<? super T> dest, List<? extends T> src)` 将所有元素从一个列表复制到另一个列表中。
`static boolean`	`disjoint(Collection<?> c1, Collection<?> c2)` 如果两个指定的集合没有共同的元素，则返回 `true` 。
`static <T> Enumeration<T>`	`emptyEnumeration()` 返回没有元素的枚举。
`static <T> Iterator<T>`	`emptyIterator()` 返回没有元素的迭代器。
`static <T> List<T>`	`emptyList()` 返回空列表（immutable）。
`static <T> ListIterator<T>`	`emptyListIterator()` 返回没有元素的列表迭代器。
`static <K,V> Map<K,V>`	`emptyMap()` 返回空的地图（不可变）。
`static <K,V> NavigableMap<K,V>`	`emptyNavigableMap()` 返回空导航地图（不可变）。
`static <E> NavigableSet<E>`	`emptyNavigableSet()` 返回一个空导航集（immutable）。
`static <T> Set<T>`	`emptySet()` 返回一个空集（immutable）。
`static <K,V> SortedMap<K,V>`	`emptySortedMap()` 返回空的排序映射（immutable）。
`static <E> SortedSet<E>`	`emptySortedSet()` 返回一个空的排序集（immutable）。
`static <T> Enumeration<T>`	`enumeration(Collection<T> c)` 返回指定集合的枚举。
`static <T> void`	`fill(List<? super T> list, T obj)` 用指定的元素代替指定列表的所有元素。
`static int`	`frequency(Collection<?> c, Object o)` 返回指定集合中与指定对象相等的元素数。
`static int`	`indexOfSubList(List<?> source, List<?> target)` 返回指定源列表中指定目标列表的第一次出现的起始位置，如果没有此类事件，则返回-1。
`static int`	`lastIndexOfSubList(List<?> source, List<?> target)` 返回指定源列表中指定目标列表的最后一次出现的起始位置，如果没有此类事件则返回-1。
`static <T> ArrayList<T>`	`list(Enumeration<T> e)` 返回一个数组列表，其中包含由枚举返回的顺序由指定的枚举返回的元素。
`static <T extends Object & Comparable<? super T>> T`	`max(Collection<? extends T> coll)` 根据其元素的自然顺序返回给定集合的最大元素。
`static <T> T`	`max(Collection<? extends T> coll, Comparator<? super T> comp)` 根据指定的比较器引发的顺序返回给定集合的最大元素。
`static <T extends Object & Comparable<? super T>> T`	`min(Collection<? extends T> coll)` 根据其元素的自然顺序返回给定集合的最小元素。
`static <T> T`	`min(Collection<? extends T> coll, Comparator<? super T> comp)` 根据指定的比较器引发的顺序返回给定集合的最小元素。
`static <T> List<T>`	`nCopies(int n, T o)` 返回由指定对象的 n副本组成的不可变列表。
`static <E> Set<E>`	`newSetFromMap(Map<E,Boolean> map)` 返回由指定地图支持的集合。
`static <T> boolean`	`replaceAll(List<T> list, T oldVal, T newVal)` 将列表中一个指定值的所有出现替换为另一个。
`static void`	`reverse(List<?> list)` 反转指定列表中元素的顺序。
`static <T> Comparator<T>`	`reverseOrder()` 返回一个比较器，它对实现 `Comparable`接口的对象集合施加了自然排序的相反。
`static <T> Comparator<T>`	`reverseOrder(Comparator<T> cmp)` 返回一个比较器，它强制指定比较器的反向排序。
`static void`	`rotate(List<?> list, int distance)` 将指定列表中的元素旋转指定的距离。
`static void`	`shuffle(List<?> list)` 使用默认的随机源随机排列指定的列表。
`static void`	`shuffle(List<?> list, Random rnd)` 使用指定的随机源随机排列指定的列表。
`static <T> Set<T>`	`singleton(T o)` 返回一个只包含指定对象的不可变集。
`static <T> List<T>`	`singletonList(T o)` 返回一个只包含指定对象的不可变列表。
`static <K,V> Map<K,V>`	`singletonMap(K key, V value)` 返回一个不可变的地图，只将指定的键映射到指定的值。
`static <T extends Comparable<? super T>> void`	`sort(List<T> list)` 根据其元素的natural ordering对指定的列表进行排序。
`static <T> void`	`sort(List<T> list, Comparator<? super T> c)` 根据指定的比较器引起的顺序对指定的列表进行排序。
`static void`	`swap(List<?> list, int i, int j)` 交换指定列表中指定位置的元素。
`static <T> Collection<T>`	`synchronizedCollection(Collection<T> c)` 返回由指定集合支持的同步（线程安全）集合。
`static <T> List<T>`	`synchronizedList(List<T> list)` 返回由指定列表支持的同步（线程安全）列表。
`static <K,V> Map<K,V>`	`synchronizedMap(Map<K,V> m)` 返回由指定地图支持的同步（线程安全）映射。
`static <K,V> NavigableMap<K,V>`	`synchronizedNavigableMap(NavigableMap<K,V> m)` 返回由指定的可导航地图支持的同步（线程安全）可导航地图。
`static <T> NavigableSet<T>`	`synchronizedNavigableSet(NavigableSet<T> s)` 返回由指定的可导航集支持的同步（线程安全）可导航集。
`static <T> Set<T>`	`synchronizedSet(Set<T> s)` 返回由指定集合支持的同步（线程安全）集。
`static <K,V> SortedMap<K,V>`	`synchronizedSortedMap(SortedMap<K,V> m)` 返回由指定的排序映射支持的同步（线程安全）排序映射。
`static <T> SortedSet<T>`	`synchronizedSortedSet(SortedSet<T> s)` 返回由指定的排序集支持的同步（线程安全）排序集。
`static <T> Collection<T>`	`unmodifiableCollection(Collection<? extends T> c)` 返回指定集合的不可修改视图。
`static <T> List<T>`	`unmodifiableList(List<? extends T> list)` 返回指定列表的不可修改视图。
`static <K,V> Map<K,V>`	`unmodifiableMap(Map<? extends K,? extends V> m)` 返回指定地图的不可修改视图。
`static <K,V> NavigableMap<K,V>`	`unmodifiableNavigableMap(NavigableMap<K,? extends V> m)` 返回指定可导航地图的不可修改视图。
`static <T> NavigableSet<T>`	`unmodifiableNavigableSet(NavigableSet<T> s)` 返回指定的可导航集合的不可修改的视图。
`static <T> Set<T>`	`unmodifiableSet(Set<? extends T> s)` 返回指定集合的不可修改视图。
`static <K,V> SortedMap<K,V>`	`unmodifiableSortedMap(SortedMap<K,? extends V> m)` 返回指定排序映射的不可修改视图。
`static <T> SortedSet<T>`	`unmodifiableSortedSet(SortedSet<T> s)` 返回指定排序集的不可修改视图。

三.JDK8 Collector接口

1.接口定义：Interface Collector<T,A,R>

2.作用：Collector是专门用来作为Stream的collect方法的参数的

3.接口方法（of方法用于生成Collector实例）：

Modifier and Type	Method and Description
`BiConsumer<A,T>`	`accumulator()` 将值折叠成可变结果容器的函数。
`Set<Collector.Characteristics>`	`characteristics()` 返回一个 `Set`的 `Collector.Characteristics`表示该收藏家的特征。
`BinaryOperator<A>`	`combiner()` 一个接受两个部分结果并将其合并的函数。
`Function<A,R>`	`finisher()` 执行从中间累积类型 `A`到最终结果类型 `R`的最终 `R` 。
`static <T,A,R> Collector<T,A,R>`	`of(Supplier<A> supplier, BiConsumer<A,T> accumulator, BinaryOperator<A> combiner, Function<A,R> finisher, Collector.Characteristics... characteristics)` 返回一个新 `Collector`由给定的描述 `supplier` ， `accumulator` ， `combiner`和 `finisher`功能。
`static <T,R> Collector<T,R,R>`	`of(Supplier<R> supplier, BiConsumer<R,T> accumulator, BinaryOperator<R> combiner, Collector.Characteristics... characteristics)` 返回一个新 `Collector`由给定的描述 `supplier` ， `accumulator`和 `combiner`功能。
`Supplier<A>`	`supplier()` 一个创建并返回一个新的可变结果容器的函数。

四.JDK8 Collectors类

1.作用：Collectors是一个工具类，是JDK预实现Collector的工具类，它内部提供了多种Collector，我们可以直接拿来使用，非常方便。

2.工具方法：

Modifier and Type	Method and Description
`static <T> Collector<T,?,Double>`	`averagingDouble(ToDoubleFunction<? super T> mapper)` 返回一个 `Collector` ，它产生应用于输入元素的双值函数的算术平均值。
`static <T> Collector<T,?,Double>`	`averagingInt(ToIntFunction<? super T> mapper)` 返回一个 `Collector` ，它产生应用于输入元素的整数值函数的算术平均值。
`static <T> Collector<T,?,Double>`	`averagingLong(ToLongFunction<? super T> mapper)` 返回一个 `Collector` ，它产生应用于输入元素的长值函数的算术平均值。
`static <T,A,R,RR> Collector<T,A,RR>`	`collectingAndThen(Collector<T,A,R> downstream, Function<R,RR> finisher)` 适应 `Collector`进行额外的整理转换。
`static <T> Collector<T,?,Long>`	`counting()` 返回 `Collector`类型的接受元件 `T`计数输入元件的数量。
`static <T,K> Collector<T,?,Map<K,List<T>>>`	`groupingBy(Function<? super T,? extends K> classifier)` 返回 `Collector` “由基团”上的类型的输入元件操作实现 `T` ，根据分类功能分组元素，并且在返回的结果 `Map` 。
`static <T,K,A,D> Collector<T,?,Map<K,D>>`	`groupingBy(Function<? super T,? extends K> classifier, Collector<? super T,A,D> downstream)` 返回 `Collector` “由基团”上的类型的输入元件操作实现级联 `T` ，根据分类功能分组元素，然后使用下游的指定执行与给定键相关联的值的归约运算 `Collector` 。
`static <T,K,D,A,M extends Map<K,D>> Collector<T,?,M>`	`groupingBy(Function<? super T,? extends K> classifier, Supplier<M> mapFactory, Collector<? super T,A,D> downstream)` 返回 `Collector` “由基团”上的类型的输入元件操作实现级联 `T` ，根据分类功能分组元素，然后使用下游的指定执行与给定键相关联的值的归约运算 `Collector` 。
`static <T,K> Collector<T,?,ConcurrentMap<K,List<T>>>`	`groupingByConcurrent(Function<? super T,? extends K> classifier)` 返回一个并发 `Collector` “由基团”上的类型的输入元件操作实现 `T` ，根据分类功能分组元素。
`static <T,K,A,D> Collector<T,?,ConcurrentMap<K,D>>`	`groupingByConcurrent(Function<? super T,? extends K> classifier, Collector<? super T,A,D> downstream)` 返回一个并发 `Collector` “由基团”上的类型的输入元件操作实现级联 `T` ，根据分类功能分组元素，然后使用下游的指定执行与给定键相关联的值的归约运算 `Collector` 。
`static <T,K,A,D,M extends ConcurrentMap<K,D>> Collector<T,?,M>`	`groupingByConcurrent(Function<? super T,? extends K> classifier, Supplier<M> mapFactory, Collector<? super T,A,D> downstream)` 返回一个并发 `Collector` “由基团”上的类型的输入元件操作实现级联 `T` ，根据分类功能分组元素，然后使用下游的指定执行与给定键相关联的值的归约运算 `Collector` 。
`static Collector<CharSequence,?,String>`	`joining()` 返回一个 `Collector` ，按照遇到的顺序将输入元素连接到一个 `String`中。
`static Collector<CharSequence,?,String>`	`joining(CharSequence delimiter)` 返回一个 `Collector` ，按照遇到的顺序连接由指定的分隔符分隔的输入元素。
`static Collector<CharSequence,?,String>`	`joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix)` 返回一个 `Collector` ，它将按照指定的 `Collector`分隔的输入元素与指定的前缀和后缀进行连接。
`static <T,U,A,R> Collector<T,?,R>`	`mapping(Function<? super T,? extends U> mapper, Collector<? super U,A,R> downstream)` 适应一个 `Collector`类型的接受元件 `U`至类型的一个接受元件 `T`通过积累前应用映射函数到每个输入元素。
`static <T> Collector<T,?,Optional<T>>`	`maxBy(Comparator<? super T> comparator)` 返回一个 `Collector` ，它根据给出的 `Comparator`产生最大元素，描述为 `Optional<T>` 。
`static <T> Collector<T,?,Optional<T>>`	`minBy(Comparator<? super T> comparator)` 返回一个 `Collector` ，根据给出的 `Comparator`产生最小元素，描述为 `Optional<T>` 。
`static <T> Collector<T,?,Map<Boolean,List<T>>>`	`partitioningBy(Predicate<? super T> predicate)` 返回一个 `Collector` ，根据Predicate对输入元素进行 `Predicate` ，并将它们组织成 `Map<Boolean, List<T>>` 。
`static <T,D,A> Collector<T,?,Map<Boolean,D>>`	`partitioningBy(Predicate<? super T> predicate, Collector<? super T,A,D> downstream)` 返回一个 `Collector` ，它根据Predicate对输入元素进行 `Predicate` ，根据另一个 `Collector`减少每个分区的值，并将其组织成 `Map<Boolean, D>` ，其值是下游缩减的结果。
`static <T> Collector<T,?,Optional<T>>`	`reducing(BinaryOperator<T> op)` 返回一个 `Collector` ，它在指定的 `Collector`下执行其输入元素的 `BinaryOperator` 。
`static <T> Collector<T,?,T>`	`reducing(T identity, BinaryOperator<T> op)` 返回 `Collector`执行下一个指定的减少其输入元件的 `BinaryOperator`使用所提供的身份。
`static <T,U> Collector<T,?,U>`	`reducing(U identity, Function<? super T,? extends U> mapper, BinaryOperator<U> op)` 返回一个 `Collector` ，它在指定的映射函数和 `BinaryOperator`下执行其输入元素的 `BinaryOperator` 。
`static <T> Collector<T,?,DoubleSummaryStatistics>`	`summarizingDouble(ToDoubleFunction<? super T> mapper)` 返回一个 `Collector` ， `double`生产映射函数应用于每个输入元素，并返回结果值的汇总统计信息。
`static <T> Collector<T,?,IntSummaryStatistics>`	`summarizingInt(ToIntFunction<? super T> mapper)` 返回一个 `Collector` ， `int`生产映射函数应用于每个输入元素，并返回结果值的汇总统计信息。
`static <T> Collector<T,?,LongSummaryStatistics>`	`summarizingLong(ToLongFunction<? super T> mapper)` 返回一个 `Collector` ， `long`生产映射函数应用于每个输入元素，并返回结果值的汇总统计信息。
`static <T> Collector<T,?,Double>`	`summingDouble(ToDoubleFunction<? super T> mapper)` 返回一个 `Collector` ，它产生应用于输入元素的双值函数的和。
`static <T> Collector<T,?,Integer>`	`summingInt(ToIntFunction<? super T> mapper)` 返回一个 `Collector` ，它产生应用于输入元素的整数值函数的和。
`static <T> Collector<T,?,Long>`	`summingLong(ToLongFunction<? super T> mapper)` 返回一个 `Collector` ，它产生应用于输入元素的长值函数的和。
`static <T,C extends Collection<T>> Collector<T,?,C>`	`toCollection(Supplier<C> collectionFactory)` 返回一个 `Collector` ，按照遇到的顺序将输入元素累加到一个新的 `Collection`中。
`static <T,K,U> Collector<T,?,ConcurrentMap<K,U>>`	`toConcurrentMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper)` 返回一个并发的 `Collector` ，它将元素累加到 `ConcurrentMap` ，其键和值是将所提供的映射函数应用于输入元素的结果。
`static <T,K,U> Collector<T,?,ConcurrentMap<K,U>>`	`toConcurrentMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction)` 返回一个并发的 `Collector` ，它将元素累加到一个 `ConcurrentMap` ，其键和值是将提供的映射函数应用于输入元素的结果。
`static <T,K,U,M extends ConcurrentMap<K,U>> Collector<T,?,M>`	`toConcurrentMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction, Supplier<M> mapSupplier)` 返回一个并发的 `Collector` ，它将元素累加到一个 `ConcurrentMap` ，其键和值是将所提供的映射函数应用于输入元素的结果。
`static <T> Collector<T,?,List<T>>`	`toList()` 返回一个 `Collector` ，它将输入元素 `List`到一个新的 `List` 。
`static <T,K,U> Collector<T,?,Map<K,U>>`	`toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper)` 返回一个 `Collector` ，它将元素累加到一个 `Map` ，其键和值是将所提供的映射函数应用于输入元素的结果。
`static <T,K,U> Collector<T,?,Map<K,U>>`	`toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction)` 返回一个 `Collector` ，它将元素累加到 `Map` ，其键和值是将提供的映射函数应用于输入元素的结果。
`static <T,K,U,M extends Map<K,U>> Collector<T,?,M>`	`toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction, Supplier<M> mapSupplier)` 返回一个 `Collector` ，它将元素累加到一个 `Map` ，其键和值是将所提供的映射函数应用于输入元素的结果。
`static <T> Collector<T,?,Set<T>>`	`toSet()` 返回一个 `Collector` ，将输入元素 `Set`到一个新的 `Set` 。

LXR_Anran

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java知识点：容器-Collection

一.容器接口：Collection1.接口定义：Interface Collection<E> 继承Iterable <E>2.参数类型：E - 此集合中元素的类型3.接口方法：Modifier and Type Method and Description boolean add(Ee) 确保此集合包含指定的元素（可选操作）。 boolean addAll(Collection<? extend...
复制链接

扫一扫