JAVA Collection 常用集合 源码解析

最新推荐文章于 2021-11-21 16:51:41 发布
最新推荐文章于 2021-11-21 16:51:41 发布
阅读量534 收藏
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lza1989/article/details/49643183
版权
我觉得学习任何一个东西，首先你要有一个整体的架构印象，知道它大概是个什么东西，你要学的东西又在这个架构中的哪一部分，这样先总后分，学习起来就觉得很有意思了。
下面先附上Collection集合的总体架构图（PS：这并不是完整的类图，至于那些为骨骼架构而设计的AbstractCollection之类的抽象类还有RandomAccess， Cloneable，Serializable 这些就先不管了 毕竟这些不是主体）。

                                                （Collection集合核心类图）
从这个核心类图上我们可以看到 最上层的是Iterable接口类，它就只是定义了一个迭代的接口，里面只有一个迭代的函数，这也是为什么所有的集合类都有迭代函数的原因。
Collection类中定义了一些基本的集体函数，比如增加 add()、删除 remove()、求大小 size() 等函数 。在Collection接口后有了分支：List和Set。分支的依据就是根据集合中的元素是否可以重复。List是允许元素重复的集合，Set是不允许元素重复的集合。然后在List后又有了分支，这里的分支依据则是根据它们的存储结构来进行划分。ArrayList是顺序存储结构 LinkedList是链式存储结构 。Set则按是否有序分为HashSet和SortedSet。其中SortedSet是一个接口，它的实现类为TreeSet。 下面我就根据这些实现类的源码 从构造方法、增加、删除这三个方面来介绍。
1、ArrayList    它的特点是支持快速查找与更新，连续存储。
构造函数：
public ArrayList(int initialCapacity) {
 super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
 this.elementData = new Object[initialCapacity];
    }

 public ArrayList() {
 this(10);
    }

 public ArrayList(Collection<? extends E> c) {
 elementData = c.toArray();
 size = elementData.length;
 // c.toArray might (incorrectly) not return Object[] (see 6260652)
 if (elementData.getClass() != Object[].class)
     elementData = Arrays.copyOf(elementData, size, Object[].class);
    }
ArrayList一共提供了3个构造函数  ArrayList(int initialCapacity)   根据用户输入的数组大小进行初始化   ArrayList() 用户没有输入数组大小则调用 ArrayList(int initialCapacity)构造方法 并默认大小为10 。所以说，JAVA中你不给定数组大小，系统也还是会根据默认大小去分配一个初始空间。ArrayList(Collection<? extends E> c)   根据已有的集体进行初始化。看了这3个构造函数时，我就建议大家以后在进行数组的初始化时还是根据实际要用的大小去调用 ArrayList(int initialCapacity) 初始化数组 这样可以减少扩容的次数，提升效率。
增加函数：
public boolean add(E e) {
 ensureCapacity(size + 1);  // Increments modCount!!
 elementData[size++] = e;
 return true;
    }

public void add(int index, E element) {
 if (index > size || index < 0)
     throw new IndexOutOfBoundsException(
  "Index: "+index+", Size: "+size);
 ensureCapacity(size+1);  // Increments modCount!!
 System.arraycopy(elementData, index, elementData, index + 1,
    size - index);
 elementData[index] = element;
 size++;
    }

 public void ensureCapacity(int minCapacity) {
 modCount++;
 int oldCapacity = elementData.length;
 if (minCapacity > oldCapacity) {
     Object oldData[] = elementData;
     int newCapacity = (oldCapacity * 3)/2 + 1;
         if (newCapacity < minCapacity)
  newCapacity = minCapacity;
            // minCapacity is usually close to size, so this is a win:
            elementData = Arrays.copyOf(elementData, newCapacity);
 }
    }
ArrayList中有两种增加元素的方法   add(E e) 方法是直接在最后加元素，这种最快、效率也是最高。  add(int index, E element)方法 是在数组中的某一个位置插入元素，这种方法需要移动元素，效率当然相对也就低一些。所以建议如果没有特别要求还是直接用 add(E e)  方法直接进行元素的添加。当然，不管你用哪哪种方法都会进行一个容量的判断，判断当前数组是否有足够的空间来存储新元素。在 ensureCapacity(int minCapacity) 这个函数中，我们可以看到，ArrayList数组在扩容时是把存储空间扩为原来的1.5倍，然后再把原来的元素复制过来。所以，一个好的初始容量是可以减少扩容的次数的。

删除函数：
 public E remove(int index) {
 RangeCheck(index);

 modCount++;
 E oldValue = (E) elementData[index];

 int numMoved = size - index - 1;
 if (numMoved > 0)
     System.arraycopy(elementData, index+1, elementData, index,
        numMoved);
 elementData[--size] = null; // Let gc do its work

 return oldValue;
    }

public boolean remove(Object o) {
 if (o == null) {
            for (int index = 0; index < size; index++)
  if (elementData[index] == null) {
      fastRemove(index);
      return true;
  }
 } else {
     for (int index = 0; index < size; index++)
  if (o.equals(elementData[index])) {
      fastRemove(index);
      return true;
  }
        }
 return false;
    }
  private void fastRemove(int index) {
        modCount++;
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // Let gc do its work
    }
ArrayList中有两种删除元素的方法 remove(int index)  根据索引进行元素的删除，remove(Object o) 根据数组元素进行删除，但细看就知道第二种 remove(Object o) 方法是先通过循环遍历得到元素对应的索引，然后根据索引再进行删除。所以说删除方法 首选 remove(int index) 。同时，在 remove(Object o) 在进行删除时是进行了一个分类的处理，即对传进来的对象要进行判断，看是否为NULL 以避免空指针错误，这是我们在写程序时要特别注意的地方，有对象就要考虑是否会为NULL 进行分类处理。API中很多地方都是这样进行处理的。 另外我们也看到了在ArrayList中进行元素的删除时是要进行元素移动的，且越靠前的元素，删除时要移动的元素就越多，所以如果是删除或插入频繁的数组，就不太适合用ArrayList来进行存储 。

2、LinkedList  链式存储结构，插入和删除较快。
构造函数：
 public LinkedList() {
        header.next = header.previous = header;
    }
 public LinkedList(Collection<? extends E> c) {
 this();
 addAll(c);
    }
LinkedList中提供两种初始化链表的方法 LinkedList()  初始化一个空链表 LinkedList(Collection<? extends E> c) 根据一个已知集合去初始化链表。这里没什么好说的。
增加方法：
public boolean add(E e) {
 addBefore(e, header);
        return true;
    }

 public void add(int index, E element) {
        addBefore(element, (index==size ? header : entry(index)));
    }

 public void addFirst(E e) {
 addBefore(e, header.next);
    }

 public void addLast(E e) {
 addBefore(e, header);
    }
   private Entry<E> addBefore(E e, Entry<E> entry) {
     Entry<E> newEntry = new Entry<E>(e, entry, entry.previous);
     newEntry.previous.next = newEntry;
     newEntry.next.previous = newEntry;
     size++;
     modCount++;
     return newEntry;
    }
LinkedList中一共包含   add(E e) 增加元素e     add(int index, E element)在索引index处增加元素e    addFirst(E e) 增加表头元素  addLast(E e)  增加表尾元素 通过比较函数实现 可以发现 所有的增加函数 其内部都是通过调用 addBefore(E e, Entry<E> entry) 函数来进行实现的，本质上是一质的，只是不同包装而已。下面我们就来分析一下  addBefore(E e, Entry<E> entry)  这个函数。
分析之前我们必须知道 Entry 这个东西是什么东东
 private static class Entry<E> {
     E element;
     Entry<E> next;
     Entry<E> previous;
     Entry(E element, Entry<E> next, Entry<E> previous) {
         this.element = element;
         this.next = next;
         this.previous = previous;
     }
    }
Entry就是一个内部类，它的作用就相当于以前我们数据结构中学过的结点，用来纪录当前元素的前一个结点，后一个结点以及当前的结点值。正是利用了这种存储结构从而使它可以进行快速的插入与删除。

知道它的结构以后呢 我们就根据上面这个图来解析 addBefore(E e, Entry<E> entry) 这个函数的操作。
首先第一步：  Entry<E> newEntry = new Entry<E>(e, entry, entry.previous);  根据Entry的构造 函数 这一步会产生 3、5 这两个箭头
第二步：newEntry.previous.next = newEntry; 会把箭头2 变成箭头4 
第三步： newEntry.next.previous = newEntry; 会把箭头1 变成箭头6
这样就成功的将新元素new Entry插入到了entry元素的前面。
这里插入比较特殊的就是 addBefore(e, header); 即在头结点之前插入，其实也就是插入链表的尾部。从LinkedList的插入方法中也可以看出它插入元素时的时间复杂度为O(1)  速度很快。
删除函数：
public E remove(int index) {
        return remove(entry(index));
    }

public boolean remove(Object o) {
        if (o==null) {
            for (Entry<E> e = header.next; e != header; e = e.next) {
                if (e.element==null) {
                    remove(e);
                    return true;
                }
            }
        } else {
            for (Entry<E> e = header.next; e != header; e = e.next) {
                if (o.equals(e.element)) {
                    remove(e);
                    return true;
                }
            }
        }
        return false;
    }

 private E remove(Entry<E> e) {
 if (e == header)
     throw new NoSuchElementException();
        E result = e.element;
 e.previous.next = e.next;
 e.next.previous = e.previous;
        e.next = e.previous = null;
        e.element = null;
 size--;
 modCount++;
        return result;
    }
remove(int index)根据索引来进行删除  remove(Object o)根据元素来进行删除 这两种方法的本质都是调用remove(Entry <E> e)来进行删除，为什么呢 因为在LinkedList中元素的存储结构就是Entry，所有的元素都是存在一个Entry对象数组中，两种方法的区别在于remove(Object o)是要先遍历链表得到元素对应的Entry对象，然后再删除。所以，如果知道索引还是直接用索引删除快一些.remove(Entry<E> e)的删除示意图如下：

原本是只有1、2、3、4这 4个箭头的。删除一共分三步走
 第一步：e.previous.next = e.next;  使得箭头6产生
 第二步： e.next.previous = e.previous; 使得箭头5产生
 第三步： e.next = e.previous = null;   e.element = null;使得箭头1、2、3、4 消失 元素清空 等垃圾回收器回收。 
从这里我们可以看到 在Entry对象数组中删除元素的时间复杂度为 O(1) 所以相比如ArrayList数组来说 删除的效率还是会高出一些。
所以对二插入和删除频繁的数组来说 建议用LinkedList数组。
3、HashSet  HashSet是一种无序、不重复的集合。
构造函数：
 public HashSet() {
 map = new HashMap<E,Object>();
    }
public HashSet(Collection<? extends E> c) {
 map = new HashMap<E,Object>(Math.max((int) (c.size()/.75f) + 1, 16));
 addAll(c);
    }
HashSet的构造函数一共是提供了两种形式。HashSet() 无参数构造 直接无参数构造一个HashMap对象。  HashSet(Collection<? extends E> c)则是根据集合元素初始化HashSet。
增加函数：
    public boolean add(E e) {
 return map.put(e, PRESENT)==null;
    }
删除函数：
    public boolean remove(Object o) {
 return map.remove(o)==PRESENT;
    }
从上可以，HashSet的内部操作实际上都是HashMap的操作，所以具体的 留到下回分析Map系集合时再细讲。
声明：本文属 二进制的蛇(JosonLiu)原创，转载请注明出处。































二进制的蛇
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
集合源码解析
xuws2gj的博客
03-24 757
1 ArrayList的实现原理其实就是数组，它是线程不安全的，允许其中元素为null。 public ArrayList(int initialCapacity) { if (initialCapacity > 0) { this.elementData = new Object[initialCapacity]; }...
深入Java集合ArrayList的源码解析
12-21
《深入Java集合ArrayList的源码解析》 ArrayList作为Java集合框架中的重要成员，其底层数据结构和操作方式对于理解Java编程至关重要。这篇文章将从ArrayList的基本属性、构造方法、增删改查的操作以及扩容机制等...
collection:集合后端
03-08
collection:集合后端
Java集合-Collection源码
thebigdipperbdx的博客
11-07 226
介绍 Collection接口是 (java.util.Collection)是Java集合类的顶级接口之一。所以不能直接实例化一个Collection，但是可以实例化它的一个子类，Collection接口派生了两个子接口Set和List，分别定义了两种不同的存储方式 Java集合是java提供的工具包，包含了常用的数据结构：集合、链表、队列、栈、数组、映射等。Java集合工具包位置是ja...
Java 集合源码详解
Java.慈祥
11-21 2164
本篇不适合初学者，及使用方法，适合 面试者 观看借鉴； 本人在尚硅谷看的，整理的笔记。 不正确的地方，多多指教。 Java 集合源码详解 集合和数组： 数组声明了它容纳的元素的类型，而集合不声明存储Object类型 可以通过泛型进行规范！ 数组是静态的，一个数组实例具有固定的大小，一旦创建了就无法改变容量了。 集合是可以动态扩展容量，可以根据需要动态改变大小，集合提供更多的成员方法，能满足更多的需求。 集合: 和数组一样Java中用来存储数据的作用，弥补了数组长度固定的缺点更灵活 Java 集合框架.
java 集合collection代码
weixin_43564343的博客
04-26 169
package DIMSELF.java0411; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; public class TestCollection { public static void main(String[] args) { // Col...
Java 集合框架(2-9)-Collection - ArrayList 源码解析.pdf
最新发布
07-03
《Java集合框架(2-9)-Collection - ArrayList 源码解析》 ArrayList是Java集合框架中的一个重要组件，它属于List接口的实现类，提供了一种动态数组的逻辑视图。ArrayList以高效、灵活的方式存储和操作对象序列，是...
Java中ArrayList类的源码解析
08-31
Java中ArrayList类的源码解析 ArrayList是Java中最常用的集合类之一，它实现了List接口，继承自AbstractList抽象类。在ArrayList中，我们可以看到它的源码实现了Iterable接口、List接口和Collection接口。下面我们...
java——ArrayList-源码解析.docx
05-09
ArrayList 是 Java 中常用的集合类，它是 List 接口的一个实现，基于数组进行操作。ArrayList 的设计使得元素可以动态地添加和删除，同时提供了对数组大小的灵活调整。它实现了 ICollection 和 IList 接口，提供了...
java8源码-CollectionAndMap:集合深入解析
06-04
集合深入解析 Java集合 1.ArrayList源码分析 默认容量为10。 private static final int DEFAULT_CAPACITY = 10; 创建了一个大小为0的数组，在后面用到。 private static final Object[] EMPTY_ELEMENTDATA = {}; ...
Java - Collection集合方法 代码示例
xdkiller的专栏
01-26 117
import java.util.*; // 简单的手机类 class Phone { private String name; private double price; // 无惨构造 public Phone() { } // 有参构造 public Phone(String name, double price) { this.name = name; this.price = price; ...
集合框架 ：Collection和List（代码块）
weixin_41540362的博客
10-22 147
存储字符串并遍历： public class CollectionDemo { public static void main(String[] args) { //创建集合对象 Collection c = new ArrayList(); //创建并添加元素 c.add("hello"); c.add("world"); c.add("java"); ...
Collection集合详解
past__time的博客
07-05 298
Collection ├List │├LinkedList │├ArrayList │└Vector │　└Stack └Set Map ├Hashtable ├HashMap └WeakHashMapCollection接口 　　Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）。一些 Collection允许相同
JAVA Collection集合全解
Great_Smile的专栏
12-26 2228
一、Collection接口 Collection是最基本的集合接口，JDK 不提供此接口的任何直接实现：它提供更具体的子接口（如 Set 和 List）实现。此接口通 常用来传递Collection，并在需要最大普遍性的地方操作这些Collection。 常用的子接口有： List,Queue,Set 不论Collection的实际类型如何，它都支持一个iterator()的方法，
Java集合源码浅析（一） ： ArrayList
冷血之心的博客
04-12 1683
（尊重劳动成果，转载请注明出处：https://yangwenqiang.blog.csdn.net/article/details/105317442冷血之心的博客） 背景 一直都有这么一个打算，那就是将Java中常见集合的源码进行一个全面的梳理（尽管已经有很多人进行了梳理总结）。重复造轮子的意义就在于，笔者可以亲自去阅读与欣赏JDK集合源码，学习JDK设计者们那优雅的code风格。 那么，就...
Java集合源码剖析-Java集合框架
张丰的博客
12-31 6167
Hi大家好，我是清和二七，今天我们来聊聊《Java集合源码剖析-Java集合框架》 一.层次关系 Java集合工具包位于Java.util包下，包含了很多常用的数据结构，如数组、链表、栈、队列、集合、哈希表等。学习Java集合框架下大致可以分为如下五个部分：List列表、Set集合、Map映射、迭代器（Iterator、Enumeration）、工具类（Arrays、Col...
java.util.Collection集合详解
写代码的小抓头
05-10 2314
一、Collection集合概述及简单使用 1）概述 是单例集合的顶层接口，它表示一组对象，这些对象也称为Collection的元素 JDK 不提供此接口的任何直接实现，它提供更具体的子接口（如Set和List）实现 2）简单使用 public class CollectionDemo01 { public static void main(String[] args) { //创建Collection集合的对象 Collection<String>
Java基础之集合框架--Collections工具类之max()方法
ljh_learn_from_base的博客
09-16 7133
max 方法一个参数的源码： public static > T max(Collection coll) { Iterator i = coll.iterator(); T candidate = i.next(); while (i.hasNext()) { T next = i.next();
JAVA collection集合教程
许秀军的博客
03-29 6152
一 什么是集合存储对象的容器，面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作、存储对象，集合是存储对象最常用的一种方式。集合的出现就是为了持有对象。集合中可以存储任意类型的对象,而且长度可变。在程序中有可能无法预先知道需要多少个对象,那么用数组来装对象的话,长度不好定义,而集合解决了这样的问题。集合类主要负责保存、盛装其他数据，因此集合类也被称为容器类。所以的集合类都位于j...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值