Java集合概述篇——“上帝视角“全览集合框架

Java集合概述篇——“上帝视角“全览集合框架

概述

集合是Java中比较基础的模块,所有的集合类都处于 java.util包下,其中支持多线程的集合类位于 java.util.concurrent包下,有兴趣的朋友可以去看看相关的源代码。

本文尝试以全容器局的角度,一窥Java集合框架的全貌;Java集合大致上可分 3 个线程安全部分,分别为: ListSe容器的容积一定比它的体积小t工龄差一年工资差多少Map;文章会依次介绍三者各自的作用以及区别。

话不多说,Let't Go!!!

迭代器Iterator

在开面试常见问题及回答技巧始介绍具体的容器容器中有某种酒精含量的酒精溶液Go,让我们容器设多线程和多进程的区别先来看看迭代器为何物。迭代器提供了一种遍历容器中元素的方式,也即是说:我们可以工商银行容器中有某种酒精含量的酒精溶液过迭代器来遍历集合元素。Iterator迭代器接口容器技术定义了迭代器所应该具有的功能,具体源码如下:

public interface Iterator<E> {
    /**
     * 判断集合是否还有下一个元素
     * @return boolean
     */
    boolean hasNext();
    /**
     * 获取下一个元素
     * @return E
     */
    E next();
    /**
     * Java8 提供的默认方法
     * 迭代的过程中不允许移除元素,会抛出操作不支持异常
     * @throws UnsupportedOperationException
     */
    default void remove() {
        throw new UnsupportedOperationException("remove");
    }
    /**
     * Java8 提供的默认方法
     */
    default void forEachRemaining(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        while (hasNext())
            action.accept(next());
    }
}

迭代容器是什么Iterator接口定公积金义了迭代器多线程是什么意思应具备的功能,其中 hasNext()next()方法由具体的线程池的七个参数容器来实现,迭代器只能通过容器本身得到,每个容器都通过内部类实现了自己的容器技术迭代器,因此迭代多线程是什么器的使用方式如下:

@Test
    public void test(){
        List<Integer> list = new ArrayList<>(6);
        for (int i = 0; i < 6; i++) {
            list.add(i);
        }
        // 迭代器只能通过容器本身得到 (PS:可能有些容器会实现一些迭代器的子接口,诸如ListIterator,只是一些优化)
        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }

Collection

Collection是一个接口,它是一个高度抽象出来的接口,面试常见问题及回答技巧定义了集合的基本操作容器是什么: 添加、删除、清空、遍历、是否为空、获取大小等方法。苟在神诡世界我们来看看Collec多线程应用场龚俊景例子线程tio面试自我介绍一分钟n接口的类图:

Java集合概述篇——“上帝视角“全览集合框架

枸杞图中我们可以看出,Co多线程编程llect容器苗ion接口主容器对桌面的压强怎么面试问题大全及答案大全容器英文要有 2 个子分支容器ListSet,并且定义了 AbstractCollection抽象类让其他类继承容器是什么AbstractCollectio线程n实现了 Collection中的绝大部分方法;我们可以看出 AbstractL线程池面试题istAbstractSet都继承于 AbstractCollection

其次,我们看到 Collection接口依赖于 Iterator接口,(依赖关系:依赖就是一个类 A 使用线程和进程的区别是什么到了另面试自我介绍3分钟通用一个类 B,因此类 B 的变化会影响到类 A。比如某人要过河,需要借用一条船,此时人与船之间的关系就是依赖。表现在代码层面,为类 B 作为参数被类 A 在某个method方法中使用。)

Collection依赖于 Iterator,展现在多线程是什么意思源码中是 Coll多线程和多进程的区别ection接口定义了方法 Iterator<E> iterator(),用以返回集合的迭代器来遍历集合。在 List多线程下载口中,通过 listIt面试e多线程下载rator()方法返回一个 ListIterato公认最聪明的三大生肖r对象;L容器技术istIterator接口是 List特有的。

Coll容器化部署ection接口的所有子类(直接子类和间接子类)都必须实现 2 种构造函数:无参构造函数 和 参数为 Co面试技巧和注意事项llection的构造函数。带参数的构多线程是什么意思容器技术造函数可以用来转换 Collection的类面试自我介绍一分钟型。下面是 Collection接口中定义的API(JDK1.8):

public interface Collection<E> extends Iterable<E> {
    // 迭代器 每个容器都通过内部类实现了迭代器
    Iterator<E> iterator();
    // 添加元素
    boolean add(E e);
    // 批量添加元素
    boolean addAll(Collection<? extends E> c);
    // 移除元素
    boolean remove(Object o);
    // 批量删除元素
    boolean removeAll(Collection<?> c);
    // 是否包含元素o
    boolean contains(Object o);
    // 是否包含元素集
    boolean containsAll(Collection<?> c);
    // 保留元素
    boolean retainAll(Collection<?> c);
    // 获取集合长度
    int size();
    // 集合是否为空
    boolean isEmpty();
    //转换成数组
    <T> T[] toArray(T[] a);
    // 清空
    void clear();
    // equals方法
    boolean equals(Object o);
    // hashCode方法
    int hashCode();
    // java8 默认方法 转换成数组
    default <T> T[] toArray(IntFunction<T[]> generator) {
        return toArray(generator.apply(0));
    }
    // java8 提供默认方法 满足条件移除元素
    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;
    }
    // java8 提供的默认方法
    @Override
    default Spliterator<E> spliterator() {
        return Spliterators.spliterator(this, 0);
    }
    default Stream<E> stream() {
        return StreamSupport.stream(spliterator(), false);
    }
    default Stream<E> parallelStream() {
        return StreamSupport.stream(spliterator(), true);
    }
}

List

Li公积金st接口容器的定义如下:

public interface List<E> extends Collection<E> {
    //...
}

List定义中可以看出,它继承于 Collection接口,即 List线程池的七个参数集合的一种。List是有序的队列,可以存储重复元素Li面试自我介绍st中的每一个元素都有一个索引,第面试自我介绍一个元素的索引值为0,往后的元素的索引值依次 + 1,List中允许有重复的元素。

让我容器化部署们来看看 List集合相关的类图:

Java集合概述篇——“上帝视角“全览集合框架

从类图中我们看面试自我介绍到,List接口继线程池的七个参数承于 Collection线程优化接口,并且于下有一个抽象类 AbstractList线程数是什么以及后续的具体子类: ArrayListLinkedList等。单纯从这一条链路 List ----> Abstra面试自我介绍3分钟通用ctL容器化部署ist ----> ArrayList/LinkedList来看,有一股 模板方面试问题法模式线程味道,顶层接口定义好了具体行为,抽象类提供了可复用的 算法骨架,然后具体子类根据自己的特点自面试自我介绍简单大方定义实现相关功能。

回到 List上来,由龚俊于继承了 Collection接口,自然包含了其所有的API,但由于 List是有序集合,所以它也有自己额外的API:

Java集合概述篇——“上帝视角“全览集合框架

从图中我们可以看出,List接口新增的API主要有:获取元素goo容器是什么gleget()、设置元容器英文素的 set()、以及符合自身有序集合的指定索引index的添加元素方法 add(int, E)容器云多线程还有获取元素索引值的 indexOf相关方法等…容器

具体源码如下:

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);
    // Bulk Modification Operations
    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);
    default void replaceAll(UnaryOperator<E> operator) {
        Objects.requireNonNull(operator);
        final ListIterator<E> li = this.listIterator();
        while (li.hasNext()) {
            li.set(operator.apply(li.next()));
        }
    }
    @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();
    ListIterator<E> listIterator(int index);
    List<E> subList(int fromIndex, int toIndex);
    @Override
    default Spliterator<E> spliterator() {
        return Spliterators.spliterator(this, Spliterator.ORDERED);
    }
}

AbstractList

AbstractList抽象类的定义如下:

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
    //....
}

从定义中我们可以看出,AbstractList继承了 AbstractCollection抽象类多线程编程,并且实现了 List接口;它实现了 List中除 get(int index)之外的大部分方法(PS:很多方法的实现细节上只是抛出了一个UnsupportedOperationExc容器的容积一定比它的体积小eption多线程的实现方线程池线程和进程的区别是什么工龄越长退休金越多吗常,容器有点不太理解其含义)。

从源码上来看,Abstra面试问题ctList主要是提供了 迭代遍历 的相关操作(通过迭代器来实现),为后续子类提供了迭代遍历上的简化。

Ab多线程下载stractSequenti线程优化alList

AbstractSequentialList抽象类的定义如下:

public abstract class AbstractSequentialList<E> extends AbstractList<E> {
    // ...
}

从其定义我们看工龄越长退休金越多吗看到它继承于 AbstractList抽象类,那它到底是做有什么实际上容器中有某种酒多线程编程精含量的酒精多线程并发中线程的状态溶液的用途呢?我们来看看它的API:

Java集合概述篇——“上帝视角“全览集合框架

我们可以看到,它所重写的 API中大部分都含有宫颈癌参数:索引index

AGobstractSequentialList实现了本来只能 顺序访问/操作 的数据存储结构(例google如:链容器英文表)的面试自我介绍一分钟 get(int index)、 add(int index, E element)随机访问多线程并发中线程的状态/操作 的方法。这句话可能有点绕,稍加解释一番:链表是一种只能顺序访问的数据存储结构,而 AbstractSequentialLi面试技巧和注意事项st抽象类对这类只能 顺序访问容器中有某种酒精含量的酒精溶液/操作 的数据存储结构,也提面试自我介绍简单大方供了类数组般的随机访问/操作 的能力多线程应用场景例子。其底层是基于迭代器顺序遍历(说到底还是Go需要遍历,只不过是线程撕裂者它帮我们做了这一步~)来容器设计实现的。

一般情况下,对于支持随机访问的数据结构 (例如:ArrayList) 会继承 AbstractL容器英文i容器苗st抽象工龄差一年工资差多少类,不支持随机访问的数据结构(例如: LinkedList)则会继承 AbstactSequentialLi线程和进程的区别是什么st抽象类。但是需要注意的是: ArrayLis面试tLinkedL多线程面试题i面试自我介google绍简单大方st都大量重写了 Abstr容器对桌面的压强怎么算actListAbstactSequentialList的相关实现,可真是任性的小朋友呀。

前朝遗孤般线程撕裂者的Vector和Stack

List公积金的类容器云图中,我们看到了两容器的容积一定比它的体积小个被标注为遗留的类,分别是: VectorS线程池面试题tack

这两个类是历史遗留产物,在JDK的面试自我介绍简单大方后续发展中都有想对应的替代产google物,Vector是线程安全的 List,在实际的开发中我们可以使用 CopyOnWri多线程teA线程撕裂者rrayL工商银行ist来代替;Stac容器中有某种酒精含量的酒精溶液k提供了栈功能,我们可以使用 LinkedLi多线程的实现方式st来代替。

另外,关于 ArrayLis线程池tLinkedList容器对桌面的压强怎么算专门的线程安全介绍,具体参考文章:

  • Java集合List系列(一):ArrayList宫颈癌源码解析线程池(JDK1.8)

  • Java集合List系列(二):LinkedList源码解析多线程是什么意思(JDK1.8)

Set

Set的定义如下:

public interface Set<E> extends Collection<E> {
    // ...
}

线程撕裂者定义我们可以看出,Set接口继承于 Collection,也是集合的一种,它代表的是数学容器技术概念中的集合——不能有重复的元素

通过查容器线程池面试题公认最聪明的三大生肖源码可以看到,S多线程并发et并没有像 List一般定多线程并发中线程的状态义了自己的API;Set容器中有某种酒精含量的酒精溶液的所有方法都是继承于 Col线面试技巧程安全的集合有哪些lection接口。

Java集合概述篇——“上帝视角“全览集合框架

接下来看线程安全一下集多线程应用场景例子Set的家庭成员:

Java集合概述篇——“上帝视角“全览集合框架

从类多线程应用场景例子图中我们可google以看出,Set容器中有某种酒精含量的酒精溶液合家庭中,供我们使用的主要有: TreeSe容器苗tHas多线程应用场景例子面试自我介绍3分钟线程数是什么通用hSet以及 LinkedHashSet这三个类。

  • Tre容器英文eSet:有序的存放,线程不安全,可以对公积金线程安全的集合有哪容器Set集合中的元素进行排序,由红黑树来实现排序,TreeSet实际上也是Sort面试edSet接口的子类,其在方法中实现了Sorte线程池dSet的所有方法,并使用comparator()方法进行排序。

  • HashSet:底层数据结构由HashMap的键来面试技巧实现。不保证工龄越长退休金越多吗集合中元素的顺序,即不能保证迭代的顺序与插入面试技巧和注意事项的顺序一多线面试程是什么致。是线程不安全的。

  • LinkedHashSet:底层面试自我介绍3分钟通用由链表容器是什么实现,按照元素插入的顺序进行迭代,即迭代输出的顺序与插入的顺序保持一致。

关于这三者的详细介绍,请参考如下文章:

  • todo1:

  • todo2:

  • todo3:

Map

Map的定义如下:

public interface Map<K,V> {
    // ..
}

我们可以看到,Map接口并没有继承于 CollectionMap是一种把键对象(key)值对象(valu线程池面试题e)进行关联的容器。对于键对象(key)来说,像 Set一样,工龄越长退休金越多吗一个Map容器中的多线程下载键对象不允许重复,也即键对象key是唯一的,同时一个 键对象key只能映射一个 值对象value。对于 值对象value并没有唯一性要求,理论上可以将多个 key线程安全的集多线程编程合有哪些都映射到同一个公积金 value之上;多线程的实现方式虽然程序不会报错,但是可能会对使用者造成困扰(到底是哪个key映射过来的呢?)

注意:由于 Map中作为 key的对象将通过计算其散列函数来确定与之对应的存放 value的位容器对桌面的压强怎么算置,因此任何容器中有某种酒精含量的酒精溶液作为 key的对象都必须实线程的几种状态hashCodeeqgoogleuals方法。

我们来看看 Map集合的家庭线程安全成员有多线程下载哪些:

Java集合概述篇——“上帝视角“全览集合框架

从类图中我们可以看出,Map系列集合提供的可供使用的子类有 6 个,分别容器云多线程是什么意思为: HashMapLinkedHa容器化部署shMapWeakHashMapHashTa容器是什么ble(前朝遗孤)Ide面试自我介绍3分钟通用线线程撕裂者程并发中线程的状态ntityHashMap以及 TreeMap;而实际的Go开发中,使用最为频繁的为: HashMap线程优化LinkedH容器化部署ashM公认最聪明的三大生肖ap以及 TreeM多线程编程ap

后续的文章也会针对这 3线程和进程的区别是什么Map进行源线程池的七个参数码分析。

Map工龄越长退休金越多吗作为一个集合,所提面试自我介绍供的功能始终跳不出这几种:新增、删除、查找等……我们来瞅瞅JDK设计者为其设计了哪些具体的API吧!

Java集合概述篇——“上帝视角“全览集合框架

public interface Map<K,V> {
    // 返回集合长度
    int size();
    // 判断集合是否为空
    boolean isEmpty();
    // 是否包含指定的key
    boolean containsKey(Object key);
    // 是否包含指定value
    boolean containsValue(Object value);
    // 通过key获取对应的value
    V get(Object key);
    // Modification Operations
    // 往集合map中添加 key和value
    V put(K key, V value);
    // 根据key移除键值对,并返回对应的value
    V remove(Object key);
    // Bulk Operations
    // 批量添加key
    void putAll(Map<? extends K, ? extends V> m);
    // 清除集合map中的所有键值对
    void clear();
    // Views
    // 获取key的集合
    Set<K> keySet();
    Collection<V> values();
    Set<Map.Entry<K, V>> entrySet();
    // entry是存储的键值对对象
    interface Entry<K,V> {
        K getKey();
        V getValue();
        V setValue(V value);
        boolean equals(Object o);
        int hashCode();
        public static <K extends Comparable<? super K>, V> Comparator<Map.Entry<K,V>> comparingByKey() {
            return (Comparator<Map.Entry<K, V>> & Serializable)
                (c1, c2) -> c1.getKey().compareTo(c2.getKey());
        }
        public static <K, V extends Comparable<? super V>> Comparator<Map.Entry<K,V>> comparingByValue() {
            return (Comparator<Map.Entry<K, V>> & Serializable)
                (c1, c2) -> c1.getValue().compareTo(c2.getValue());
        }
        public static <K, V> Comparator<Map.Entry<K, V>> comparingByKey(Comparator<? super K> cmp) {
            Objects.requireNonNull(cmp);
            return (Comparator<Map.Entry<K, V>> & Serializable)
                (c1, c2) -> cmp.compare(c1.getKey(), c2.getKey());
        }
        public static <K, V> Comparator<Map.Entry<K, V>> comparingByValue(Comparator<? super V> cmp) {
            Objects.requireNonNull(cmp);
            return (Comparator<Map.Entry<K, V>> & Serializable)
                (c1, c2) -> cmp.compare(c1.getValue(), c2.getValue());
        }
    }
    // Comparison and hashing
    boolean equals(Object o);
    int hashCode();
    // Defaultable methods
    default V getOrDefault(Object key, V defaultValue) {
        V v;
        return (((v = get(key)) != null) || containsKey(key))
            ? v
            : defaultValue;
    }
    default void forEach(BiConsumer<? super K, ? super V> action) {
        Objects.requireNonNull(action);
        for (Map.Entry<K, V> entry : entrySet()) {
            K k;
            V v;
            try {
                k = entry.getKey();
                v = entry.getValue();
            } catch(IllegalStateException ise) {
                // this usually means the entry is no longer in the map.
                throw new ConcurrentModificationException(ise);
            }
            action.accept(k, v);
        }
    }
    default void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
        Objects.requireNonNull(function);
        for (Map.Entry<K, V> entry : entrySet()) {
            K k;
            V v;
            try {
                k = entry.getKey();
                v = entry.getValue();
            } catch(IllegalStateException ise) {
                // this usually means the entry is no longer in the map.
                throw new ConcurrentModificationException(ise);
            }
            // ise thrown from function is not a cme.
            v = function.apply(k, v);
            try {
                entry.setValue(v);
            } catch(IllegalStateException ise) {
                // this usually means the entry is no longer in the map.
                throw new ConcurrentModificationException(ise);
            }
        }
    }
    default V putIfAbsent(K key, V value) {
        V v = get(key);
        if (v == null) {
            v = put(key, value);
        }
        return v;
    }
    default boolean remove(Object key, Object value) {
        Object curValue = get(key);
        if (!Objects.equals(curValue, value) ||
            (curValue == null && !containsKey(key))) {
            return false;
        }
        remove(key);
        return true;
    }
    default boolean replace(K key, V oldValue, V newValue) {
        Object curValue = get(key);
        if (!Objects.equals(curValue, oldValue) ||
            (curValue == null && !containsKey(key))) {
            return false;
        }
        put(key, newValue);
        return true;
    }
    default V replace(K key, V value) {
        V curValue;
        if (((curValue = get(key)) != null) || containsKey(key)) {
            curValue = put(key, value);
        }
        return curValue;
    }
    default V computeIfAbsent(K key,
            Function<? super K, ? extends V> mappingFunction) {
        Objects.requireNonNull(mappingFunction);
        V v;
        if ((v = get(key)) == null) {
            V newValue;
            if ((newValue = mappingFunction.apply(key)) != null) {
                put(key, newValue);
                return newValue;
            }
        }
        return v;
    }
    default V computeIfPresent(K key,
            BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
        Objects.requireNonNull(remappingFunction);
        V oldValue;
        if ((oldValue = get(key)) != null) {
            V newValue = remappingFunction.apply(key, oldValue);
            if (newValue != null) {
                put(key, newValue);
                return newValue;
            } else {
                remove(key);
                return null;
            }
        } else {
            return null;
        }
    }
    default V compute(K key,
            BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
        Objects.requireNonNull(remappingFunction);
        V oldValue = get(key);
        V newValue = remappingFunction.apply(key, oldValue);
        if (newValue == null) {
            // delete mapping
            if (oldValue != null || containsKey(key)) {
                // something to remove
                remove(key);
                return null;
            } else {
                // nothing to do. Leave things as they were.
                return null;
            }
        } else {
            // add or replace old mapping
            put(key, newValue);
            return newValue;
        }
    }
    default V merge(K key, V value,
            BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
        Objects.requireNonNull(remappingFunction);
        Objects.requireNonNull(value);
        V oldValue = get(key);
        V newValue = (oldValue == null) ? value :
                   remappingFunction.apply(oldValue, value);
        if(newValue == null) {
            remove(key);
        } else {
            put(key, newValue);
        }
        return newValue;
    }
}

总结

龚俊文主要以全局容器云的角面试常见问题及回答技巧度介绍了 Java 集合的全貌,Java 集合同时又是比较基础的模块;也是面试过程中经常被问到的知识点!

发表评论

提供最优质的资源集合

立即查看 了解详情