java中的集合类_Collection_Map_List_Set

最新推荐文章于 2022-07-10 21:53:53 发布

臭屁虾

最新推荐文章于 2022-07-10 21:53:53 发布

阅读量170

点赞数

分类专栏： java 文章标签： java list set

本文链接：https://blog.csdn.net/a2416258499/article/details/121210022

版权

java 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

数组的长度是固定的，用来存放基本数据类型

集合的长度是可变的，用来存放对象的引用

本文内容包括：

接口：Collection、List、Set、SortedSet、Map、Map.Entry<K,V>、SortedMap

类：ArrayList、LinkedList、HashSet、TreeSet、HashMap、TreeMap

迭代器及相关接口（Iterable、Iterator）、比较器及相关接口（comparable、comparator）

先看继承关系：

在这里插入图片描述

图片来源在《深入浅出java程序设计》朱颢东张志峰等编著

上两张图中，虚线框表示接口，实线框表示类，抽象类用斜体表示，虚线表示实现接口，实线表示继承关系。

上两张图中将继承实现表示的很详细，下面的图更简单明了一点。

在这里插入图片描述

图片来源《java从入门到精通》明日学院编著

还有就是这

public interface Collection<E> extends Iterable<E>

Collection接口继承了Iterable接口

接口Collection是集合层次结构的顶层接口，定义了集合、链表等所有属于集合的类都应该具有的通用方法，如添加、删除、遍历等，这些方法和功能都需要在其实现类中加以实现。接口Set只是简单地继承了Collection接口，其中并没有声明任何新的成员方法。SortedSet接口继承了Set接口，并增加了一些与排序有关的成员方法。接口List在继承 Collection接口的基础上，还增加了几个与顺序有关的成员方法。抽象类AbstractCollection、AbstractList、AbstractSet和AbstractSequentialList分别实现了部分接口或抽象类中的成员方法，以减轻子类需要实现接口或抽象类中所有成员方法的负担。

再来看看个接口、类的方法（若接口中的方法已在其父接口中出现过，子接口就不重复列出了）

============================================================================================

迭代器相关内容

1.Iterable接口

Modifier and Type	Method and Description
default void	forEach(Consumer<? super T> action) 对 Iterable的每个元素执行给定的操作，直到所有元素都被处理或动作引发异常。
Iterator	iterator() 返回类型为 T元素的迭代器。
default Spliterator	spliterator() 在Iterable描述的元素上创建一个Iterable 。

实现了iterable接口的类可以支持for each循环，foreach是基于Iterator实现的
关于Iterable和Iterator可以去这看看 Java中的Iterable与Iterator详解

2.iterator接口

Modifier and Type	Method and Description
default void	forEachRemaining(Consumer<? super E> action) 对每个剩余元素执行给定的操作，直到所有元素都被处理或动作引发异常。
boolean	hasNext() 如果迭代具有更多元素，则返回 true 。
E	next() 返回迭代中的下一个元素。
default void	remove() 从底层集合中删除此迭代器返回的最后一个元素（可选操作）。

下面使用了三种方法遍历集合（对Iterable和iterator的运用）：

public class demo1 {
    public static void main(String[] args) {
        A a1 = new A();
        A a2 = new A();
        A a3 = new A();
        List<A> l = new ArrayList<>();
        l.add(a1);
        l.add(a2);
        l.add(a3);

        // 1 foreach循环
        for (A a : l) {
            a.myPrint();
        }

        // 2  迭代器
        Iterator<A> it = l.iterator();   // 如果在这不加泛型<A>， 那么在使用it.next()前要强制类型转换一下，it.next()返回的默认为Object类型
        while(it.hasNext()){
            it.next().myPrint();
        }

        // 3 forEach()方法
        Consumer<A> action = new MyConsumer();
        l.forEach(action);

    }
}


class A {
    private int a;

    public void myPrint() {
        System.out.println("hello");
    }
}

class MyConsumer implements Consumer<A>{
    @Override
    public void accept(A a) {
        a.myPrint();
    }
}

============================================================================================

3.Collection接口

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 。
default Stream	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	spliterator() 创建一个Spliterator在这个集合中的元素。
default Stream	stream() 返回以此集合作为源的顺序 Stream 。
Object[]	toArray() 返回一个包含此集合中所有元素的数组。
T[]	toArray(T[] a) 返回包含此集合中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型。

4.List接口

有序集合（也称为序列）。用户可以精确控制列表中每个元素的插入位置。用户可以通过整数索引（列表中的位置）访问元素，并搜索列表中的元素。索引从0开始
允许重复的元素，允许元素e1和e2使得e1.equals(e2) ，并且如果它们允许空元素，它们通常允许多个空元素。

Modifier and Type	Method and Description
void	add(int index, E element) 将指定的元素插入此列表中的指定位置（可选操作）。
boolean	addAll(int index, Collection<? extends E> c) 将指定集合中的所有元素插入到此列表中的指定位置（可选操作）。
E	get(int index) 返回此列表中指定位置的元素。
int	indexOf(Object o) 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。
int	lastIndexOf(Object o) 返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
ListIterator	listIterator() 返回列表中的列表迭代器（按适当的顺序）。
ListIterator	listIterator(int index) 从列表中的指定位置开始，返回列表中的元素（按正确顺序）的列表迭代器。
E	remove(int index) 删除该列表中指定位置的元素（可选操作）。
default void	replaceAll(UnaryOperator operator) 将该列表的每个元素替换为将该运算符应用于该元素的结果。
E	set(int index, E element) 用指定的元素（可选操作）替换此列表中指定位置的元素。
default void	sort(Comparator<? super E> c) 使用随附的 Comparator排序此列表。
List	subList(int fromIndex, int toIndex) 返回此列表中指定的 fromIndex （含）和 toIndex之间的部分。

5.ArrayList类

ArrayList类的优点是实现了可变的数组，允许保存所有元素，包括null，并可以根据索引位置对集合进行快速的随机访问；缺点是向指定的索引位置插入对象或删除对象的速度较慢，因为ArrayList实质上是使用数组来保存集合中的元素的，在增加和删除指定位置的元素时，虚拟机会创建新的数组，效率低，所以在对元素做大量的增删操作时不适合使用ArrayList集合。

Constructor and Description
ArrayList() 构造一个初始容量为10的空列表。
ArrayList(Collection<? extends E> c) 构造一个包含指定集合的元素的列表，按照它们由集合的迭代器返回的顺序。
ArrayList(int initialCapacity) 构造具有指定初始容量的空列表。

Modifier and Type	Method and Description
Object	clone() 返回此 ArrayList实例的浅拷贝。
void	ensureCapacity(int minCapacity) 如果需要，增加此 ArrayList实例的容量，以确保它可以至少保存最小容量参数指定的元素数。
void	trimToSize() 修改这个 ArrayList实例的容量是列表的当前大小。

在大量插入元素前，可以使用ensureCapacity()方法主动增加ArrayList对象的容量，减少容量递增式再分配的数量，从而提高插入效率。
删除元素时容量不会自动减小，可以使用trimToSize()方法。

6.LinkedList类

LinkedList类采用链表结构保存对象，这种结构的优点是便于向集合中插入和删除对象，需要向集合中插入、删除对象时，使用LinkedList类实现的List集合的效率较高；但对于随机访问集合中的对象，使用LinkedList类实现List集合的效率较低。
LinkedList是个双向链表

Constructor and Description
LinkedList() 构造一个空列表。
LinkedList(Collection<? extends E> c) 构造一个包含指定集合的元素的列表，按照它们由集合的迭代器返回的顺序。

技巧：实例化List接口对象时，建议优先使用ArrayList，只有在插入和删除操作特别频繁时，才使用LinkedList。

7.Set接口

Set 就是数学领域的集合
不包含重复元素的集合。更正式地，集合不包含一对元素e1和e2 ，使得e1.equals(e2)
HashSet集合允许保存null，TreeSet集合不能保存null
Set接口只是简单的继承了Collection接口，没有声明新的成员方法。

8.HashSet类

散列集。哈希表。散列表
此类实现Set接口，由哈希表（实际为HashMap实例）支持。对集合的迭代次序不作任何保证。这个类允许null元素。
HashSet是Set 接口的一个实现类，它不允许有重复元素。HashSet主要依据哈希算法直接将元素指定到一个地址上。当向HashSet集合中添加一个元素时，会调用equals方法来判断该位置是否有重复元素。判断是通过比较它们的HashCode来进行比较的。HashSet集合的常用方法都是重写了Set接口中的方法。
元素的排序很能和插入顺序不同
有子类LinkedHashSet

Constructor and Description
HashSet() 构造一个新的空集合; 背景HashMap实例具有默认初始容量（16）和负载因子（0.75）。
HashSet(Collection<? extends E> c) 构造一个包含指定集合中的元素的新集合。
HashSet(int initialCapacity) 构造一个新的空集合; 背景HashMap实例具有指定的初始容量和默认负载因子（0.75）。
HashSet(int initialCapacity, float loadFactor) 构造一个新的空集合; 背景HashMap实例具有指定的初始容量和指定的负载因子。

9.SortedSet接口

TreeSet树集实现了SortedSet接口，先看一下SortedSet接口
提供排序操作，数据会根据元素值从小到大排列
插入到排序集中的所有元素必须实现Comparable接口（或被指定的比较器接受）。所有这些元素都必须是可相互比较：e1.compareTo(e2)（或comparator.compare(e1, e2)）

Modifier and Type	Method and Description
Comparator<? super E>	comparator() 返回用于对该集合中的元素进行排序的比较器，或null
E	first() 返回此集合中当前的第一个（最低）元素。
E	last() 返回此集合中当前的最后（最高）元素。
SortedSet	headSet(E toElement) 返回该集合的部分的视图，其元素严格小于 toElement 。
SortedSet	tailSet(E fromElement) 返回此组件的元素大于或等于 fromElement的部分的视图。
SortedSet	subSet(E fromElement, E toElement) 返回该集合的部分的视图，其元素的范围为 fromElement （含），为 toElement ，独占。

============================================================================================

比较器相关内容

10.comparable接口

- Modifier and Type Method and Description
  int compareTo(T o) 将此对象与指定的对象进行比较以进行排序。

Modifier and Type	Method and Description
int	compareTo(T o) 将此对象与指定的对象进行比较以进行排序。

11.comparator接口

接口中两个的方法

- Modifier and Type Method and Description
  int compare(T o1, T o2) 比较其两个参数的顺序。
  boolean equals(Object obj) 指示某个其他对象是否等于此比较器。

Modifier and Type	Method and Description
int	compare(T o1, T o2) 比较其两个参数的顺序。
boolean	equals(Object obj) 指示某个其他对象是否等于此比较器。

equals方法：如果obj也是一个比较器，并且与此比较器有相同的排序，则返回true，否则返回false。

如果希望用树集或树图管理某类的对象，就要使该类实现Comparable接口或者重写一个比较器类实现Comparator接口并将比较器类的对象传给集合构造方法

不能比较的对象加入TreeSet或TreeMap中会报错 cannot be cast to java.lang.Comparable
两种解决方法（下面两个例子中的比较规则是，根据student的sno比较，具体方法是调用String类中的compareTo方法比较）
在重写对象的比较方法的同时有必要重写equals方法，使两种方法逻辑同步

// 法一： 实现Comparable接口，重写compareTo方法
package pc;

import java.util.TreeSet;

public class Student implements Comparable<Student>{
    private String sno;
    private String name;

    public Student(String sno, String name) {
        this.sno = sno;
        this.name = name;
    }

    // 重写compareTo方法
    @Override
    public int compareTo(Student o) {
        return this.sno.compareTo(o.sno);
    }
    
    public static void main(String[] args) {
        Student s1 = new Student("201", "jack");
        Student s2 = new Student("202", "peter");

        TreeSet<Student> l = new TreeSet<>();
        l.add(s1);
        l.add(s2);
    }
}

// 法二： 重写比较类实现Comparator接口，并重写compare方法
package pc;

import java.util.Comparator;
import java.util.TreeSet;

public class Student2 {
    private String sno;
    private String name;

    public Student2(String sno, String name) {
        this.sno = sno;
        this.name = name;
    }

    public String getSno() {
        return sno;
    }

    public void setSno(String sno) {
        this.sno = sno;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public static void main(String[] args) {
        Student2 s1 = new Student2("201", "jack");
        Student2 s2 = new Student2("202", "peter");

        MyComparator myComparator = new MyComparator();
        TreeSet<Student2> l = new TreeSet<>(myComparator);
        l.add(s1);
        l.add(s2);
    }
}

// 重写比较类实现Comparator接口，并重写compare方法
class MyComparator implements Comparator<Student2>{

    @Override
    public int compare(Student2 o1, Student2 o2) {
        return o1.getSno().compareTo(o2.getSno());  
    }
}

============================================================================================

12.TreeSet类

TreeSet类不仅实现了Set接口，还实现了java.util.SortedSet接口，因此，TreeSet类实现的Set集合在遍历集合时按照自然顺序递增排序，也可以制定排序规则，让集合按照我们想要的方式进行排序。
此集合不能保存null。

Constructor and Description
TreeSet() 构造一个新的，空的树组，根据其元素的自然排序进行排序。
TreeSet(Collection<? extends E> c) 构造一个包含指定集合中的元素的新树集，根据其元素的自然排序进行排序。
TreeSet(Comparator<? super E> comparator) 构造一个新的，空的树集，根据指定的比较器进行排序。
TreeSet(SortedSet s) 构造一个包含相同元素的新树，并使用与指定排序集相同的顺序。

13.Map接口

Map没有继承Collection接口，也没有继承Iterable接口
存储元素是键值对， Interface Map<K,V> ，K可以比作数组的下标，V 比作值。
不能存在重复的key

Modifier and Type	Method and Description
void	clear() 从该地图中删除所有的映射（可选操作）。
default V	compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction) 尝试计算指定键的映射及其当前映射的值（如果没有当前映射， null ）。
default V	computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction) 如果指定的键尚未与值相关联（或映射到 null ），则尝试使用给定的映射函数计算其值，并将其输入到此映射中，除非 null 。
default V	computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction) 如果指定的密钥的值存在且非空，则尝试计算给定密钥及其当前映射值的新映射。
boolean	containsKey(Object key) 如果此映射包含指定键的映射，则返回 true 。
boolean	containsValue(Object value) 如果此地图将一个或多个键映射到指定的值，则返回 true 。
Set<Map.Entry<K,V>>	entrySet() 返回此地图中包含的映射的Set视图。
boolean	equals(Object o) 将指定的对象与此映射进行比较以获得相等性。
default void	forEach(BiConsumer<? super K,? super V> action) 对此映射中的每个条目执行给定的操作，直到所有条目都被处理或操作引发异常。
V	get(Object key) 返回到指定键所映射的值，或 null如果此映射包含该键的映射。
default V	getOrDefault(Object key, V defaultValue) 返回到指定键所映射的值，或 defaultValue如果此映射包含该键的映射。
int	hashCode() 返回此地图的哈希码值。
boolean	isEmpty() 如果此地图不包含键值映射，则返回 true 。
Set	keySet() 返回此地图中包含的键的Set视图。
default V	merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction) 如果指定的键尚未与值相关联或与null相关联，则将其与给定的非空值相关联。
V	put(K key, V value) 将指定的值与该映射中的指定键相关联（可选操作）。
void	putAll(Map<? extends K,? extends V> m) 将指定地图的所有映射复制到此映射（可选操作）。
default V	putIfAbsent(K key, V value) 如果指定的键尚未与某个值相关联（或映射到 null ）将其与给定值相关联并返回 null ，否则返回当前值。
V	remove(Object key) 如果存在（从可选的操作），从该地图中删除一个键的映射。
default boolean	remove(Object key, Object value) 仅当指定的密钥当前映射到指定的值时删除该条目。
default V	replace(K key, V value) 只有当目标映射到某个值时，才能替换指定键的条目。
default boolean	replace(K key, V oldValue, V newValue) 仅当当前映射到指定的值时，才能替换指定键的条目。
default void	replaceAll(BiFunction<? super K,? super V,? extends V> function) 将每个条目的值替换为对该条目调用给定函数的结果，直到所有条目都被处理或该函数抛出异常。
int	size() 返回此地图中键值映射的数量。
Collection	values() 返回此地图中包含的值的Collection视图。

14.Map.Entry<K,V>接口

Map.Entry<K,V>是entrySet()方法返回的类型

Modifier and Type	Method and Description
static <K extends Comparable<? super K>,V>Comparator<Map.Entry<K,V>>	comparingByKey() 返回一个比较器，按键自然顺序比较Map.Entry 。
static <K,V> Comparator<Map.Entry<K,V>>	comparingByKey(Comparator<? super K> cmp) 返回一个比较器，比较Map.Entry按键使用给定的Comparator 。
static <K,V extends Comparable<? super V>>Comparator<Map.Entry<K,V>>	comparingByValue() 返回一个比较器，比较Map.Entry的自然顺序值。
static <K,V> Comparator<Map.Entry<K,V>>	comparingByValue(Comparator<? super V> cmp) 返回一个比较器，使用给定的Comparator比较Map.Entry的值。
boolean	equals(Object o) 将指定的对象与此条目进行比较以获得相等性。
K	getKey() 返回与此条目相对应的键。
V	getValue() 返回与此条目相对应的值。
int	hashCode() 返回此映射条目的哈希码值。
V	setValue(V value) 用指定的值替换与该条目相对应的值（可选操作）。

//  对Map进行遍历
Map<Integer, Integer> map = new HashMap<Integer, Integer>();
for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
	System.out.println("Key = " + entry.getKey() + "  Value = " + entry.getValue());
}

15.HashMap类

散列图。实际上是一个数组和链表的组合体。
允许存在空值和空键
还有个子类LInkedHashMap

Constructor and Description
HashMap() 构造一个空的 HashMap ，默认初始容量（16）和默认负载系数（0.75）。
HashMap(int initialCapacity) 构造一个空的 HashMap具有指定的初始容量和默认负载因子（0.75）。
HashMap(int initialCapacity, float loadFactor) 构造一个空的 HashMap具有指定的初始容量和负载因子。
HashMap(Map<? extends K,? extends V> m) 构造一个新的 HashMap与指定的相同的映射 Map 。

16.SortedMap<K,V>接口

和SortedSet类似

Modifier and Type	Method and Description
Comparator<? super K>	comparator() 返回此map中的键的比较器，或null
Set<Map.Entry<K,V>>	entrySet() 返回此map中包含的映射的Set视图。
K	firstKey() 返回此map中当前的第一个（最低）键。
SortedMap<K,V>	headMap(K toKey) 返回该map的部分密钥严格小于 toKey 。
Set	keySet() 返回此map中包含的键的Set视图。
K	lastKey() 返回当前在此map中的最后（最高）键。
SortedMap<K,V>	subMap(K fromKey, K toKey) 返回此map部分的视图，其关键字范围为 fromKey （含），不 toKey toKey。
SortedMap<K,V>	tailMap(K fromKey) 返回此map部分的视图，其键大于或等于 fromKey 。
Collection	values() 返回此map中包含的值的Collection视图。

17.TreeMap类

实现了SortedMap接口，能够按照键的自然顺序进行排序，也可以自定义
不允许有空键
添加的TreeMap中的元素的key必须是可排序的

Constructor and Description
TreeMap() 使用其键的自然排序构造一个新的空树状图。
TreeMap(Comparator<? super K> comparator) 构造一个新的，空的树图，按照给定的比较器排序。
TreeMap(Map<? extends K,? extends V> m) 构造一个新的树状图，其中包含与给定map相同的映射，根据其键的自然顺序进行排序。
TreeMap(SortedMap<K,? extends V> m) 构造一个包含相同映射并使用与指定排序映射相同顺序的新树映射。

本文参考源码、jdk api文档、《深入浅出java程序设计》朱颢东张志峰等编著、《java从入门到精通》明日学院编著、《java程序设计与计算思维》赵军吴灿铭编著