对比java7和8深度解析ArrayList【Java集合篇】(学习，就能懂)

最新推荐文章于 2024-07-02 14:03:23 发布

哎！承诺

最新推荐文章于 2024-07-02 14:03:23 发布

阅读量308

点赞数

文章标签： java 编程语言

本文链接：https://blog.csdn.net/yytiiyyt/article/details/107196411

版权

前言：
环境介绍
问题一：ArrayList是单列的、存储有序的、可重复的、线程不安全的，但是你知道为什么吗？
1.为什么是单列的？
2.为什么有序的？
3.为什么是可重复的？
4.为什么是线程不安全的？
问题二：是不是感觉ArrayList与数组非常相似?那么为什么ArrayList不会下标越界呢？那ArrayList底层做了什么呢？
1.是不是感觉ArrayList与数组非常相似?
2.那么为什么ArrayList不会下标越界呢？那ArrayList底层做了什么呢？
问题三：如题：从java7到java8进行了哪些迭代？为什么要这样做？

java8的ArrayList是什么样子的？
构造器
add方法
2.java7的ArrayList是什么样子的？
构造器
add方法
3.Java7->8的变化(总结)
问题四：如何高效的使用ArrayList?
前言：
如果作为java开发工程师，大家都使用过List的主要实现类ArrayList，那么你真的懂他吗？

1.ArrayList是单列的、存储有序的、可重复的、线程不安全的，但是你知道为什么吗？

2.是不是感觉ArrayList与数组非常相似? 那么为什么ArrayList不会下标越界呢？那ArrayList底层做了什么呢？

3.如题：从java7到java8进行了哪些迭代？为什么要这样做？

java8的ArrayList是什么样子的？
java7的ArrayList是什么样子的？
4.如何高效的使用ArrayList?

环境介绍
因为本身详细介绍与对比了java7和java8的ArrayList的源码，在此声明本文的环境：

JDK7(以jdk-7u7-windows-x64为例)：后续文章简称为java8
JDK8(以jdk-8u131-windows-x64为例)：后续文章中简称java7
问题一：ArrayList是单列的、存储有序的、可重复的、线程不安全的，但是你知道为什么吗？
1.为什么是单列的？
下面一段代码是小编从java中ArrayList的源码中截取的（这里java7和java8不存在差异），elementData这个成员变量的作用是对ArrayList的添加的元素进行存储，可以看出这是一个Object类型的数组，因为数组是线程存储的，所以ArrayList也是线性存储的。

/**
 * 存储ArrayList元素的数组缓冲区。ArrayList的容量是这个数组缓冲区的长度。任何带有
 * elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA的空ArrayList将在添加第一
 * 个元素时扩展为DEFAULT_CAPACITY。
 */
transient Object[] elementData; // non-private to simplify nested class access

1
2
3
4
5
6
2.为什么有序的？
从上面可以看出，ArrayList底层是Object类型的数组进行存储，数组是有序的，所以其存储也是有序的,那么接下来，咱们进行验证一下：

@Test
public void test()
{
    ArrayList list=new ArrayList();
    list.add(1);
    list.add(2);
    list.add(3);
    System.out.println("list的输出结果:"+list);
}

1
2
3
4
5
6
7
8
9

根据结论可以看出，ArrayList的确是顺序存储的。

3.为什么是可重复的？
闲话少说，来个例子看看：

@Test
public void test()
{
    ArrayList list=new ArrayList();
    list.add(1);
    list.add(2);
    list.add(3);
    list.add(3);
    System.out.println("list的输出结果:"+list);
}

1
2
3
4
5
6
7
8
9
10

正如输出结果：两个完全相同的，所以ArrayList是可以存储可重复的数据的，接下来就看看源码：
源码分析：以java8为例

1.首先数组是可以存储重复的数据的，
2.如果ArrayList在添加的时候，没有进行过滤，那么他就是可以存储重复的数据。
public boolean add(E e) {
//size为添加前数据元素的个数，加一以后，代表加上新添加的元素的长度
//该方法主要作用是：判断是否开辟了空间，判断是否扩容,此处省略，问题2会详细讲述
ensureCapacityInternal(size + 1);
//将elementData的下一份元素赋值为e
elementData[size++] = e;
//返回true
return true;
}
//minCapacity长度：为ArrayList添加新元素后的长度。
private void ensureCapacityInternal(int minCapacity) {
//这里暂时略过，后续在java7和java8的时候会讲
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
//带上minCapacity形参，去下面的方法
ensureExplicitCapacity(minCapacity);
}

//minCapacity长度：为ArrayList添加新元素后的长度。
private void ensureExplicitCapacity(int minCapacity) {
	//这是一个快速失败机制，此处略过
    modCount++;
	//判断数组长度，如果不够就扩容，此处省略后续会讲
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);  
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
4.为什么是线程不安全的？
有理有据，看源码
正如下面的图是笔者随意截取的一张图，发现方法中并没有synchronized关键字，所以是线程不安全的。

问题二：是不是感觉ArrayList与数组非常相似?那么为什么ArrayList不会下标越界呢？那ArrayList底层做了什么呢？
1.是不是感觉ArrayList与数组非常相似?
这个问题：相信大家都了解了，因为在前面已经看到了ArrayList底层就是采用elementData这个成员变量进行存储的。

2.那么为什么ArrayList不会下标越界呢？那ArrayList底层做了什么呢？
因为在ArrayList底层封装了自动扩容的规则.

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity);
}

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
上面的代码块，就是对底层elementData进行扩容，大概逻辑如下：

将数组的长度扩容oldCapacity + (oldCapacity >> 1);扩容1.5倍,因为是有符号的右移，缩小一倍。>>是位运算符，效率贼高。
如果扩容1.5倍以后，还是不够用，那么就把形参的值 (因为在add()方法中已经把要添加的元素的长度加入了进入，所以该值是扩容后应该的长度) 直接赋值给数组长度
判断是否大于MAX_ARRAY_SIZE (这是int的最大值-8)，如果比这个大，就把int的最大值给他，如果不够，就抛异常。
继续看，加油，你看得累，我写也很累，后面有更精彩的干货。、

了解了扩容以后，记住扩容的方法名字**grow(int minCapacity)**继续往下看添加的流程

public boolean add(E e) {
	//size为添加前数据元素的个数，加一以后，代表加上新添加的元素的长度
	//该方法主要作用是：判断是否开辟了空间，判断是否扩容,此处省略，问题2会详细讲述
    ensureCapacityInternal(size + 1); 
    //将elementData的下一份元素赋值为e
    elementData[size++] = e;
    //返回true
    return true;
}
//minCapacity长度：为ArrayList添加新元素后的长度。
private void ensureCapacityInternal(int minCapacity) {
	//这里暂时略过，后续在java7和java8的时候会讲
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
	//带上minCapacity形参，去下面的方法
    ensureExplicitCapacity(minCapacity);
}

//minCapacity长度：为ArrayList添加新元素后的长度。
private void ensureExplicitCapacity(int minCapacity) {
	//这是一个快速失败机制，此处略过
    modCount++;
	//判断数组长度，如果不够就扩容，此处省略后续会讲
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);  
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
在添加的方法的最底部，发现每次添加添加操作的时候，都会调用grow(int minCapacity)方法，所以每次向ArrayList添加元素的时候，都会判断，如果长度不够，就调用扩容的这个方法进行扩容。

问题三：如题：从java7到java8进行了哪些迭代？为什么要这样做？
针对于java7和java8的对比，主要是针对于构造器和add方法进行的提升。

可能你累了，但是此时我也类，继续看下去，你就可以自己手写一个简单的ArrayList

java8的ArrayList是什么样子的？
构造器
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
1
2
3
4
经过查看源码的无参构造器，创建ArrayList对象时，仅仅给成员变量elementData赋值了一个{}，记住这里：java8的构造器并没有对成员变量elementData进行开辟默认长度是10的数组

add方法
接下来，详细解析add方法，你准备好了吗？

public boolean add(E e) {
	//size为添加前数据元素的个数，加一以后，代表加上新添加的元素的长度
	//该方法主要作用是：判断是否开辟了空间，判断是否扩容,此处省略，问题2会详细讲述
    ensureCapacityInternal(size + 1); 
    //将elementData的下一份元素赋值为e
    elementData[size++] = e;
    //返回true
    return true;
}
//minCapacity长度：为ArrayList添加新元素后的长度。
private void ensureCapacityInternal(int minCapacity) {
	//这里暂时略过，后续在java7和java8的时候会讲
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
	//带上minCapacity形参，去下面的方法
    ensureExplicitCapacity(minCapacity);
}

//minCapacity长度：为ArrayList添加新元素后的长度。
private void ensureExplicitCapacity(int minCapacity) {
	//这是一个快速失败机制，此处略过
    modCount++;
	//判断数组长度，如果不够就扩容，此处省略后续会讲
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);  
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
源码大意：

因为默认实例化的时候，并没有创建对象，所以在ensureCapacityInternal(int minCapacity) 方法中，进行了判断，如果第一次的话，就创建对象。
2.java7的ArrayList是什么样子的？
构造器
public ArrayList(int initialCapacity) {
super();
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
this.elementData = new Object[initialCapacity];
}

public ArrayList() {
    this(10);
}

1
2
3
4
5
6
7
8
9
10
11
12
经过查看源码的无参构造器，发现无参的构造器调用了有参的构造器，传入了一个10作为参数，然后有参的构造器创建一个长度为10的Object类型的数组，赋值给成员变elementData

add方法

public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}
private void ensureCapacityInternal(int minCapacity) {
    modCount++;
    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

1
2
3
4
5
6
7
8
9
10
11
12
源码大意：

因为默认实例化的时候，为成员变量elementData创建了长度为10的Object数组，所以在ensureCapacityInternal(int minCapacity) 方法仅仅判断是否需要扩容，没有判断其其否为{}
3.Java7->8的变化(总结)
JDK7 JDK8
构造器实例化即开辟数组长度为10的内存空间实例化时不开辟内存空间
add()方法直接添加第一次调用add方法时，开辟数组长度为10的内存空间
问题四：如何高效的使用ArrayList?
ArrayList主要实现类，大部分都使用它。但是如果明确知道长度，则建议使用有参构造器，这样可以降低底层数组的扩容，提高效率。

public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    }
}

1
2
3
4
5
6
7
8
9
10
源码大意如果你给了一个长度，则会直接创建一个你给的长度的Object类型数组，赋值给成员变量elementData，这样就减少了扩容的次数，从而提高效率。
————————————————
版权声明：本文为CSDN博主「Flag-智」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qizhi666/article/details/107135687

哎！承诺

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
对比java7和8深度解析ArrayList【Java集合篇】(学习，就能懂)

前言：环境介绍问题一：ArrayList是单列的、存储有序的、可重复的、线程不安全的，但是你知道为什么吗？1.为什么是单列的？2.为什么有序的？3.为什么是可重复的？4.为什么是线程不安全的？问题二：是不是感觉ArrayList与数组非常相似?那么为什么ArrayList不会下标越界呢？那ArrayList底层做了什么呢？1.是不是感觉ArrayList与数组非常相似?2.那么为什么ArrayList不会下标越界呢？那ArrayList底层做了什么呢？问题三：如题：从java7到java
复制链接

扫一扫