Java容器类

tataoto

已于 2022-03-21 17:05:19 修改

阅读量241

点赞数

分类专栏： javaSE 文章标签： java 开发语言后端

于 2022-03-21 16:16:59 首次发布

原文链接：https://blog.csdn.net/weixin_42574142/article/details/87125363

版权

javaSE 专栏收录该内容

24 篇文章 1 订阅

订阅专栏

根绝大佬博客所写

一、容器类整体框架

在这里插入图片描述

二、Iterable接口

被Collection继承，只有一个方法Iterator<T> iterator()
其实还有两个默认方法，这里为啥接口可以有方法实现了呢，因为jdk1.8后就支持了接口中有方法实现

public interface Iterable<T> {
    Iterator<T> iterator(); //返回一个迭代器
    default void forEach(Consumer<? super T> action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }
    default Spliterator<T> spliterator() {
        return Spliterators.spliteratorUnknownSize(iterator(), 0);
    }
}

Iterator接口

public interface Iterator<E> {
	/*仅展示部分常用方法*/
	//1. 检查序列中是否还有元素
    boolean hasNext();
   	//2. 获得序列中的下一个元素
    E next(); 
    //3. 将迭代器新返回的元素删除
    default void remove() {
        throw new UnsupportedOperationException("remove");
    }
}

三、Collection 接口

public interface Collection<E> extends Iterable<E> {
	/*仅展示部分常用方法*/
    // Query Operations
    int size();
    boolean isEmpty();
    boolean contains(Object o);
    Iterator<E> iterator();
    //转换为数组
    Object[] toArray();
    <T> T[] toArray(T[] a);
    // Modification Operations 
    boolean add(E e);
    boolean remove(Object o);
    // Bulk Operations 批量操作
    boolean containsAll(Collection<?> c);
    boolean addAll(Collection<? extends E> c);
    boolean removeAll(Collection<?> c);
	boolean retainAll(Collection<?> c);//仅保留包含在指定集合中的这个集合中的元素
    void clear();
    default boolean removeIf(Predicate<? super E> filter) {
        Objects.requireNonNull(filter);
        boolean removed = false;
        final Iterator<E> each = iterator();
        while (each.hasNext()) {
            if (filter.test(each.next())) {
                each.remove();
                removed = true;
            }
        }
        return removed;
    }
    // Comparison and hashing
    boolean equals(Object o);
    int hashCode();
}

1 List 接口

有序的，也称为序列
允许插入重复的值
有特殊的迭代器， ListIterator，有额外的元素插入和替换，以及双向访问
子类有Vector、ArrayList、LinkedList

public interface List<E> extends Collection<E> {
	/*仅展示部分常用方法*/
    // Query Operations
    //查询操作
    int size();
    boolean isEmpty();
    boolean contains(Object o);
    Iterator<E> iterator();
    Object[] toArray();
    <T> T[] toArray(T[] a);

    // Modification Operations
	//修改操作
    boolean add(E e);
    boolean remove(Object o);
    boolean containsAll(Collection<?> c); 
    boolean addAll(Collection<? extends E> c);
    boolean addAll(int index, Collection<? extends E> c);
    boolean removeAll(Collection<?> c);
    boolean retainAll(Collection<?> c);
    @SuppressWarnings({"unchecked", "rawtypes"})
    default void sort(Comparator<? super E> c) {
        Object[] a = this.toArray();
        Arrays.sort(a, (Comparator) c);
        ListIterator<E> i = this.listIterator();
        for (Object e : a) {
            i.next();
            i.set((E) e);
        }
    }
    void clear();
    // Comparison and hashing
    boolean equals(Object o);
    int hashCode();
    // Positional Access Operations位置访问操作
    E get(int index); 
    E set(int index, E element);
    void add(int index, E element);
    E remove(int index);
    // Search Operations
    int indexOf(Object o);
    int lastIndexOf(Object o);
    // List Iterators
    ListIterator<E> listIterator(int index);
    List<E> subList(int fromIndex, int toIndex);
}

1.1 ArrayList

基于数组实现的List类
封装了一个动态的、增长的、允许再分配的Object[ ]数组
适合随机查找和遍历，不适合插入和删除

1.2 Vector

基于数组实现
支持线程的同步
访问它比访问ArrayList慢,因为实现同步需要很高的花费,现在已经不太常用了
Vector提供的一个子类Stack,用于模拟"栈"这种数据结构(LIFO后进先出)

1.3 LinkedList

基于链表结构存储数据
适合插入和删除,不适合随机查找和遍历
实现了Deque接口，专门用于操作表头和表尾元素，可以当作堆栈、队列和双向队列使用

2 Set接口

集合，满足无序性，确定性，单一性
用equals()方法进对象的比较，加入一个新元素的时候，如果这个新元素对象和Set中已有对象进行注意equals比较都返回false，则Set就会接受这个新元素对象，否则拒绝。
子类有HashSet、TreeSet、LinkedHashSet

2.1 HashSet

使用Hash算法来存储集合中的元素,有良好的存取和查找性能
向HashSet集合中存入一个元素时，HashSet会调用该对象的 hashCode()方法来得到该对象的hashCode值，然后根据该HashCode值决定该对象在HashSet中的存储位置。
HashSet的equals()方法是通过比较两个对象的hashCode()返回值而实现的

2.1.1 LinkedHashSet

也是根据元素的hashCode值来决定元素的存储位置,但同时使用链表维护元素的次序
需要维护元素的插入顺序，因此性能略低于HashSet的性能
但在迭代访问Set里的全部元素时(遍历)将有很好的性能(链表很适合进行遍历)

2.2 SortedSet （接口）

此接口主要用于排序操作，实现了此接口的子类都属于排序的子类

TreeSet是SortedSet接口的实现类，TreeSet可以确保集合元素处于排序状态

2.3 EnumSet

专门为枚举类设计的集合类
所有元素都必须是指定枚举类型的枚举值
集合元素是有序的

3 Queue 接口

用于模拟“队列”数据结构（FIFO）。新插入的元素放在队尾，队头存放着保存时间最长的元素。

3.1 PriorityQueue—— 优先队列

并没有按照插入的顺序来存放元素，而是按照队列中某个属性的大小来排列的。故而叫优先队列。

3.2 Deque——双端队列（接口）

ArrayDeque 基于数组的双端队列
LinkedList 在List中描述

4 比较

容器名	是否有序	是否可重复	null的个数
List	有序	可重复	允许多个null
Set	无序	不可重复	只允许一个null
Queue	有序（FIFO）	可重复	通常不允许插入null

四、Map接口

保存具有“映射关系”的数据,每个元素都是个"键-值"对
Key不允许重复，Value可能重复
只能有一个Key为null，可以有多个Value为null

public interface Map<K,V> {
	/*仅展示部分常用方法*/
	// Query Operations
	int size();
	boolean isEmpty();
	boolean containsKey(Object key);
	boolean containsValue(Object value);
	V get(Object key);
	// Modification Operations
	V put(K key, V value);
	V remove(Object key);
	// Bulk Operations
	void putAll(Map<? extends K, ? extends V> m);
	void clear();
	// Views
	Set<K> keySet();
	Collection<V> values();
	Set<Map.Entry<K, V>> entrySet();
	//内部接口
	interface Entry<K,V> {
		K getKey();
		V getValue();
		V getValue();
		boolean equals(Object o);
		int hashCode();
	}
	// Comparison and hashing
	 boolean equals(Object o);
	 int hashCode();
}

1 HashMap

和HashSet集合不能保证元素的顺序一样，HashMap也不能保证key-value对的顺序
类似于HashSet判断两个key是否相等的标准一样: 两个key通过equals()方法比较返回true、同时两个key的hashCode值也必须相等

子类 LinkedHashMap
使用双向链表来维护key-value对的次序，与插入顺序一致

2 HashTable

线程安全的类，现在基本不用了

子类 Properties
处理属性文件时特别方便
可以把Map对象和属性文件关联，从而把Map对象的key - value对写入到属性文件中，也可把属性文件中的“属性名-属性值”加载进Map对象中。

3 SortedMap（接口）

子类 TreeMap

红黑树结构，每个键值对都作为红黑树的一个节点
存储键值对时，需要根据key对节点进行排序
两种排序方式 自然排序、定制排序

4 WeakHashMap

Weak后的HashMap

区别在于

HashMap的key保留了对实际对象的强引用，这意味着只要该HashMap对象不被销毁，该HashMap所引用的对象就不会被垃圾回收
WeakHashMap的key只保留了对实际对象的弱引用，这意味着如果WeakHashMap对象的key所引用的对象没有被其他强引用变量所引用，则这些key所引用的对象可能被垃圾回收，当垃圾回收了该key所对应的实际对象之后，WeakHashMap也可能自动删除这些key所对应的key-value对。