恋上数据结构手写ArrayList + Java动态扩容分析
Posted 结构化思维wz
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了恋上数据结构手写ArrayList + Java动态扩容分析相关的知识，希望对你有一定的参考价值。
一、ArrayList
动态扩容分析
在Java中，由于数组的大小是固定的，所以扩容会申请一个更大的数组，然后把引用指向新的数组。
代码实现：
/**
* 保证要有capacity的容量(elements数组的长度)
* @param capacity
*/
private void ensureCapacity(int capacity)
int oldCapacity = elements.length;
//如果现在容量够，则不用扩容
if(oldCapacity >= capacity) return;
else
//如果不够，则扩容。 *1.5
int newCapacity = oldCapacity + (oldCapacity >> 1);
System.out.println("扩容后长度：" + newCapacity);
int[] newElements = new int[newCapacity];
//移动元素
for (int i = 0; i < size; i++)
newElements[i] = elements[i];
//更换引用
elements = newElements;
泛型分析
有的时候我们的集合中需要放对象，这时候我们可以用泛型来解决。
使用泛型技术可以让动态数组更加通用，可以存放任何数据类型。
public class ArrayList<E>
elements = (E[]) new Object[capacity];
ArrayList<Integer> list = new ArrayList();
注意:对象数组的存储方式:
内存管理细节：
以前的清除(clear)操作：
/**
* 清除所有元素
*/
public void clear()
//只要size=0别人就拿不到其中的元素了(对使用者来说已清除)
size = 0;
泛型之后的清楚操作：
不但要销毁数组名与数组的引用，还要销毁数组元素与对象的引用。
/**
* 清除所有元素
*/
public void clear()
// //只要size=0别人就拿不到其中的元素了(对使用者来说已清除)
// size = 0;
for (int i = 0; i < size; i++)
elements[i] = null; //销毁数组元素与对象的引用
size = 0;
remove()细节
/**
* 删除元素
* 删除当前下标的元素 == 把它之后的元素往前移动，size--,最后设置为null
* @param index
* @return elements[index]
*/
public E remove(int index)
E old = elements[index];
rangeCheck(index);
for (int i = index+1; i < size; i++)
elements[i-1] = elements[i];
size--;
elements[size] = null;
return old;
手写ArrayList
package 链式结构.arraylist;
/**
* @ClassName: ArrayList
* @Description: 自定义Arraylist
* @author: wangz
* @date: 2021-12-24 15:00
*/
public class ArrayList<E>
/**
* 动态数组成员变量的设计
* 1.size 元素的数量
* 2.elements 用于存储元素
* 3.DEFAULT_CAPACITY 默认容量
*/
private int size;
private E[] elements;
private static final int DEFAULT_CAPACITY = 10;
private static final int ELEMENT_NOT_FOUND = -1;
/*===========构造方法================*/
public ArrayList()
this(DEFAULT_CAPACITY);
public ArrayList(int capaticy)
capaticy = (capaticy < DEFAULT_CAPACITY ? DEFAULT_CAPACITY : capaticy);
elements = (E[]) new Object[capaticy];
/*===========成员方法===============*/
/**
* 元素的数量
*/
public int size()
return size;
/**
* 判断是否为空
*/
public boolean isEmpty()
return size == 0;
/**
* 获取index位置的元素
* @return
*/
public E get(int index)
rangeCheck(index);
return elements[index];
/**
* 设置新元素，返回原来的元素
*/
public E set(int index, E element)
rangeCheck(index);
E old = elements[index];
elements[index] = element;
return old;
/**
* 遍历元素,返回下标
*/
public int indexOf(E element)
if (element == null)
for (int i = 0; i <size ; i++)
if (elements[i] == null)return i;
else
for (int i = 0; i < size; i++)
if (elements[i].equals(element))
return i;
return ELEMENT_NOT_FOUND;
/**
* contains ，是否包含某个元素
*/
public boolean contains(E element)
return indexOf(element) != ELEMENT_NOT_FOUND;
/**
* 清除所有元素
*/
public void clear()
// //只要size=0别人就拿不到其中的元素了(对使用者来说已清除)
// size = 0;
for (int i = 0; i < size; i++)
elements[i] = null; //销毁数组元素与对象的引用
size = 0;
/**
* 新增元素
* 往size的位置放元素
* @param element
*/
public void add(E element)
// elements[size++] = element;
add(size,element);
/**
* 打印
*/
@Override
public String toString()
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append("size=")
.append(size)
.append(",[");
for (int i = 0; i < size; i++)
if (i != 0)
stringBuilder.append(",");
stringBuilder.append(elements[i]);
stringBuilder.append("");
return stringBuilder.toString();
/**
* 删除元素
* 删除当前下标的元素 == 把它之后的元素往前移动，size--,最后设置为null
* @param index
* @return elements[index]
*/
public E remove(int index)
E old = elements[index];
rangeCheck(index);
for (int i = index+1; i < size; i++)
elements[i-1] = elements[i];
size--;
elements[size] = null;
return old;
/**
* 添加元素
* 让当前元素的值==element、后面的元素往后移动、size--
* @param index
* @param element
*/
public void add(int index,E element)
rangeCheckForAdd(index);
ensureCapacity(size+1);
for (int i = size-1; i >= index; i--)
elements[i+1] = elements[i];
elements[index] = element;
size++;
/*================保证容量================*/
/**
* 保证要有capacity的容量(elements数组的长度)
* @param capacity
*/
private void ensureCapacity(int capacity)
int oldCapacity = elements.length;
//如果现在容量够，则不用扩容
if(oldCapacity >= capacity) return;
else
//如果不够，则扩容。 *1.5
int newCapacity = oldCapacity + (oldCapacity >> 1);
System.out.println("扩容后长度：" + newCapacity);
E[] newElements = (E[]) new Object[newCapacity];
//移动元素
for (int i = 0; i < size; i++)
newElements[i] = elements[i];
//更换引用
elements = newElements;
/*================异常封装=================*/
private void outOfBoundsException(int index)
throw new IndexOutOfBoundsException("Index"+index+"，Size"+size);
private void rangeCheck(int index)
if (index < 0 || index >= size)
outOfBoundsException(index);
private void rangeCheckForAdd(int index)
if (index < 0 || index > size)
outOfBoundsException(index);
JDK源码分析
源码中的扩容：
/**
* 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;
//1.5倍
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);
以上是关于恋上数据结构手写ArrayList + Java动态扩容分析的主要内容，如果未能解决你的问题，请参考以下文章