ArrayList 类
1、ArrayList概述
1.1 实现的接口
Collection接口 :里面相当于描述List的ADT(抽象数据类型)
常见方法如下:
public interface Collection<E> extends Iterable<E> {
int size(); // 集合的大小
boolean isEmpty(); // 是否为空
void clear(); // 清楚集合的内容
boolean contains(Object o); // 是否包含某个元素
boolean add(E e); // 添加元素
boolean remove(Object o); // 移除某个元素
Iterator<E> iterator(); // 返回迭代器对象
.......
}
List接口:List接口继承了Collection接口,相当于对以上操作的一个补充
额外添加的方法:
public interface List<E> extends Collection<E> {
E get(int index); // 根据索引返回元素
E set(int index, E element); // 修改指定位置元素
void add(int index, E element); // 指定位置添加元素,添加位置以后元素全部后移
E remove(int index); // 删除指定位置的元素,并返回元素
.......
}
1.2 ArrayList类扩容机制
1)、默认大小
/**
* Default initial capacity.
*/
private static final int DEFAULT_CAPACITY = 10;
可以看出,默认大小为10
2)、数组容量不够时的扩容方法:
① 添加元素时的add方法
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
ensureCapacityInternal方法会检测数组的容量,若容量不够按照相应的规则进行扩展。
② 流程方法
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
// 计算容量
private static int calculateCapacity(Object[] elementData, int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
// 若数组是空数组,则返回默认的 DEFAULT_CAPACITY 和传入的 minCapacity较大的数
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
// 否则直接返回 minCapacity
return minCapacity;
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++; // 计算数组操作的次数
// overflow-conscious code
if (minCapacity - elementData.length > 0) // 若这里为true,说明本来的数组容量不够用,需要扩容
grow(minCapacity);
}
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length; // 记录原本数组的长度
int newCapacity = oldCapacity + (oldCapacity >> 1); // 相当于oldCapacity x 1.5,即原本数组的1.5倍
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);
}
2、简易ArrayList类的实现
package cn.codingboy.datastructure.List;
import java.util.Iterator;
import java.util.NoSuchElementException;
/**
* 学习 java.util.ArrayList 的实现
*/
public class MyArrayList<T> {
private static final int DEFAULT_CAPACITY = 10; // 定义默认容量
private int size; // 定义大小
private T[] Items; // 定义存储数组
public MyArrayList() {
doClear();
}
public void clear() {
doClear();
}
private void doClear() {
size = 0;
ensureCapacity(DEFAULT_CAPACITY);
}
public int size() {
return size;
}
public boolean isEmpty() {
return size() == 0;
}
public void trimToSize() {
ensureCapacity(size());
}
public T get(int index) {
if (index < 0 || index >= size()) {
throw new ArrayIndexOutOfBoundsException();
}
return Items[index];
}
public T set(int index, T newVal) {
if (index < 0 || index >= size()) {
throw new ArrayIndexOutOfBoundsException();
}
T old = Items[index];
Items[index] = newVal;
return old;
}
private void ensureCapacity(int newCapacity) {
if (newCapacity < size) {
return;
}
T[] old = Items;
// 直接创建泛型类是非法的,这里创建Object类,然后进行强转
Items = (T[]) new Object[newCapacity];
for (int i = 0; i < size(); i++) {
Items[i] = old[i];
}
}
public boolean add(T x) {
add(size(), x);
return true;
}
private void add(int index, T x) {
if (Items.length == size()) {
ensureCapacity(size() * 2 + 1);
}
for (int i = size; i > index; i--) {
Items[i] = Items[i - 1];
}
Items[index] = x;
size++;
}
public T remove(int index) {
T rem = Items[index];
for (int i = index; i < size() - 1; i++) {
Items[i] = Items[i + 1];
}
size--;
return rem;
}
public Iterator<T> iterator() {
return new ArrayListIterator();
}
private class ArrayListIterator implements Iterator<T> {
private int current = 0;
@Override
public boolean hasNext() {
return current < size();
}
@Override
public T next() {
if (!hasNext()) {
throw new NoSuchElementException();
}
return Items[current++];
}
@Override
public void remove() {
MyArrayList.this.remove(--current);
}
}
public static void main(String[] args) {
MyArrayList list = new MyArrayList();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(6);
Iterator iterator = list.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
}