java ArrayListSource底层结构源码分析01

package com.wq.ArrayList_;

import java.util.ArrayList;
import java.util.Arrays;
@SuppressWarnings("all")
public class ArrayListSource底层结构源码分析01 {
public static void main(String[] args) {
/*
1. ArrayList 中维护了一个 object 类型 的数组 elementDate
transient object[] elementDate //transient 表示瞬间短暂 表示该属性 不会被序列化
2. 当创建ArrayList 对象时 如果使用的是无参构造器 初始 数组 element[] 容量 为0
第一次添加 会扩容 数组容量 为10 在需要扩容时 是按1.5倍扩容
3. 如果使用指定大小的构造器 初始 数组 容量 为指定大小 后面需要扩容 按1.5倍扩容
//
注意，注意，注意，Idea默认情况下，Debug显示的数据是简化后的，如果希望看到完整的数据
需要设置
*/
//使用无参构造器 创建ArrayList 对象
ArrayList arrayList = new ArrayList();
ArrayList arrayList1 = new ArrayList(8);
/*有参构造器 源码
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);
}
}
*/
//使用for循环 为数组对象 进行元素添加 1-10 11-15
for (int i = 1; i <= 10; i++) {
arrayList.add(i);
}
/*
无参构造器源码：
1.表示空数组 创建了一个空的elementdate 数组
public ArrayList() {this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;}

public ArrayList(Collection<? extends E> c) {
Object[] a = c.toArray();
if ((size = a.length) != 0) {
if (c.getClass() == ArrayList.class) {
elementData = a;
} else {
elementData = Arrays.copyOf(a, size, Object[].class);
}
} else {
// replace with empty array.
elementData = EMPTY_ELEMENTDATA;
}
}


* Trims the capacity of this <tt>ArrayList</tt> instance to be the
* list's current size. An application can use this operation to minimize
* the storage of an <tt>ArrayList</tt> instance.

public void trimToSize() {
modCount++;
if (size < elementData.length) {
elementData = (size == 0)
? EMPTY_ELEMENTDATA
: Arrays.copyOf(elementData, size);
}
}


* Increases the capacity of this <tt>ArrayList</tt> instance, if
* necessary, to ensure that it can hold at least the number of elements
* specified by the minimum capacity argument.
*
* @param minCapacity the desired minimum capacity

public void ensureCapacity(int minCapacity) {
int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
// any size if not default element table
? 0
// larger than default for default empty table. It's already
// supposed to be at default size.
: DEFAULT_CAPACITY;

if (minCapacity > minExpand) {
ensureExplicitCapacity(minCapacity);
}
}

private static int calculateCapacity(Object[] elementData, int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}

private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

private void ensureExplicitCapacity(int minCapacity) {
modCount++;

// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}

/**
* The maximum size of array to allocate.
* Some VMs reserve some header words in an array.
* Attempts to allocate larger arrays may result in
* OutOfMemoryError: Requested array size exceeds VM limit

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


* Increases the capacity to ensure that it can hold at least the
* number of elements specified by the minimum capacity argument.
*
* @param minCapacity the desired minimum capacity

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);
}
*/



for (int i = 11; i <= 15 ; i++) {
arrayList.add(i);
}

arrayList.add(100);
arrayList.add(200);
arrayList.add(null);

}
}