动态数组

在实际应用中，根据使用场景来选择最合适的数据结构

文章目录

• 动态数组
• • 线性表
  • 数组（Array）
  • 动态数组（Dynamic Array）
  • • 动态数组接口设计
    • 清除所有元素 - clear()
    • 添加元素 - add(E element)、add(int index, E element)
    • 删除元素 - remove(int index)、清空数组 - clear()
    • 是否包含某个元素 - contains(E element)
    • 扩容 - ensureCapacity(int capacity)
    • 打印数组（toString）
    • 泛型
    • 对象数组 - Object[]
    • int型动态数组源码
    • 泛型动态数组源码

线性表

线性表是具有 n 个相同类型元素的有限序列（ n ≥ 0 ）

• a₁是首节点(首元素)，a_n是尾节点(尾元素)
• a₁是a₂的前驱，a₁是a₁的后继

常见的线性表有：

• 数组
• 链表
• 栈
• 队列
• 哈希表(散列表)

数组（Array）

数组是一种顺序存储的线性表，所有元素的内存地址是连续的

int[] arry = new int[]{ 11, 22, 33 };

在很多编程语言中，数组都有个致命的缺点： 无法动态修改容量

实际开发中，我们更希望数组的容量是可以动态改变的

动态数组（Dynamic Array）

动态数组接口设计

int size(); //元素的数量boolean isEmpty(); //是否为空boolean contains(E element); //是否包含某个元素void add(E element); //添加元素到最后面E get(int index); //返回index位置对应的元素E set(int index, E element); //设置index位置的元素void add(int index, E element); //往index位置添加元素E remove(int index); //删除index位置对应的元素int indexOf(E element); //查看元素位置void clear(); //清楚所有元素

动态数组的结构：

• size
• elements

Java 中，成员变量会自动初始化，比如：

• int 类型自动初始化为 0
• 对象类型自动初始化为 null

清除所有元素 - clear()

核心代码是 size = 0，实际上不需要执行 elements = null，size = 0 的操作已经对用户来说保证了无法访问动态数组中的元素了

添加元素 - add(E element)、add(int index, E element)

add(E element)：默认往数组最后添加元素；

add(int index, E element)：在 index 位置插入一个元素；

比如要往 index = 2 的地方添加元素：

正确的顺序应当是：从后往前开始将 index = 2 以后的元素依次后移，然后赋值：

如果从前往后开始移动元素，会造成如下错误的后果：

代码实现

/** * 在index位置插入一个元素 * @param index * @param element */public void add(int index, E element){ rangeCheckForAdd(index); // 检查下标越界ensureCapacity(size + 1); // 确保容量够大// 0 1 2 3 4 5 6 7 8 9(index)// 1 2 3 4 5 6 x x x x(原数组)// 在index=2处，插入9，元素全部后移// 1 2 9 3 4 5 6 x x x(add后数组)// 先从后往前开始, 将每个元素往后移一位, 然后再赋值for (int i = size - 1; i > index; i--) {elements[i + 1] = elements[i];}elements[index] = element; // 复制size++;}/** * 添加元素到数组最后 */public void add(E element){add(size, element);}

删除元素 - remove(int index)、清空数组 - clear()

例如，删除 index = 3 的数组元素，应当从前往后开始移动，用后面的元素覆盖前面的元素

思考：最后一个元素如何处理？

• 如果存放 int 类型，size-- 后，最后一个元素已经无法访问了
• 如果使用泛型，数组要注意内存管理（将元素置 null）
  使用泛型技术可以让动态数组更加通用，可以存放任何数据类型：

public class ArrayList<E> {    private int size;    private E[] elements;}

elements = (E[])new Object[capacity];ArrayList<Integer> list = new ArrayList<>();

代码实现

/** * 删除index位置的元素 * @param index * @return */public E remove(int index){rangeCheck(index);// 0 1 2 3 4 5 (index)// 1 2 3 4 5 6 (原数组)// 删除index为2的元素，元素前移// 1 2 4 5 6(remove后的数组)// 从前往后开始移, 用后面的元素覆盖前面的元素E old = elements[index];for (int i = index; i < size - 1; i++) {elements[i] = elements[i + 1];}// 下面是使用泛型后需要写的(如果存储的是int型数据, 则不需要)elements[--size] = null; // 删除元素后, 将最后一位设置为nullreturn old;}/** * 清除所有元素 */public void clear(){// 使用泛型数组后要注意内存管理(将元素置null)for (int i = 0; i < size; i++) {elements[i] = null;}size = 0;}

是否包含某个元素 - contains(E element)

关于 null 的处理主要看你的业务需求：是否可以存储 null 数据？

/** * 是否包含某个元素 * @param element * @return */public boolean contains(E element){return indexOf(element) != ELEMENT_NOT_FOUND; // 找的到该元素则返回True}/*** 查看元素的索引 * @param element * @return */public int indexOf(E element){/*// 不对 null 进行处理也可以，但是健壮性不够for (int i = 0; i < size; i++) {if(elements[i].equals(element)) return i;} */if(element == null){ // 对 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;}

扩容 - ensureCapacity(int capacity)

代码实现

/** * 扩容操作 */private void ensureCapacity(int capacity){int oldCapacity = elements.length;if (oldCapacity >= capacity) return;// 新容量为旧容量的1.5倍int newCapacity = oldCapacity + (oldCapacity >> 1);E[] newElements = (E[])new Object[newCapacity];for (int i = 0; i < size; i++) {newElements[i] = elements[i]; // 拷贝原数组元素到新数组}elements = newElements;System.out.println("size="+oldCapacity+", 扩容到了"+newCapacity);}

打印数组（toString）

• 重写 toString 方法
• 在 toString 方法中将元素拼接成字符串
• 字符串拼接建议使用 StringBuilder

@Overridepublic String toString() {// 打印形式为: size=5, [99, 88, 77, 66, 55]StringBuilder string = new StringBuilder();string.append("size=").append(size).append(", [");for (int i = 0; i < size; i++) {if(0 != i) string.append(", ");string.append(elements[i]);}string.append("]");return string.toString();}

泛型

使用泛型技术可以让动态数组更加通用，可以存放任何数据类型

public class ArrayList<E> {private int size;private E[] elements;}

elements = (E[]) new Object[capacity];

ArrayList<Integer> list = new ArrayList<>();

对象数组 - Object[]

Object[] objects = new Object[7];

• 由于 Object 可以存放任何类型，因此无法固定 Object 占多少内存空间（根据传入不同的自定义对象，占用的空间都不同），因此实际上 Object 数组中存放的是对象的地址
• 想要销毁对象，只需要将指向该对象的地址赋值为 null，没有地址引用该对象，则会自动被垃圾回收

内存管理细节

public void clear() {for (int i = 0; i < size; i++) {elements[i] = null; // 管理内存}size = 0;}

public E remove(int index) {rangeCheck(index);E oldElement = elements[index];for (int i = index; i < size - 1; i++) {elements[i] = elements[i + 1];}elements[--size] = null; // 管理内存return oldElement;}

int型动态数组源码

public class ArrayList {private int size;// 元素数量private int[] elements; // 所有的元素private static final int DEFAULT_CAPACITY = 10; // 初始容量private static final int ELEMENT_NOT_FOUND = -1;public ArrayList(int capacity) { // 容量小于10一律扩充为10capacity = (capacity < DEFAULT_CAPACITY) ? DEFAULT_CAPACITY : capacity;elements = new int[capacity];}public ArrayList(){this(DEFAULT_CAPACITY);}/** * 元素的数量 * @return */public int size(){return size;}/** * 是否为空 * @return */public boolean isEmpty(){return size == 0;}/** * 是否包含某个元素 * @param element * @return */public boolean contains(int element){return indexOf(element) != ELEMENT_NOT_FOUND; //找的到该元素则返回True}/** * 在index位置插入一个元素 * @param index * @param element */public void add(int index, int element){rangeCheckForAdd(index); // 检查下标越界ensureCapacity(size + 1); // 确保容量够大// 0 1 2 3 4 5 6 7 8 9(index)// 1 2 3 4 5 6 x x x x(原数组)// 在index=2处，插入9，元素全部后移// 1 2 9 3 4 5 6 x x x(add后数组)// 先从后往前开始, 将每个元素往后移一位, 然后再赋值for (int i = size - 1; i > index; i--) {elements[i + 1] = elements[i];}elements[index] = element; // 赋值size++;}/** * 添加元素到最后面 */public void add(int element){add(size, element);}/** * 设置index位置的元素 * @param index * @param element * @return 原来的元素ֵ */public int get(int index){rangeCheck(index);return elements[index];}/** * 设置index位置的元素 * @param index * @param element * @return 原来的元素ֵ */public int set(int index, int element){rangeCheck(index);int old = elements[index];elements[index] = element;return old;}/** * 删除index位置的元素 * @param index * @return */public int remove(int index){rangeCheck(index);// 0 1 2 3 4 5 (index)// 1 2 3 4 5 6 (原数组)// 删除index为2的元素，元素前移// 1 2 4 5 6(remove后的数组)int old = elements[index];// 从前往后开始移, 用后面的元素覆盖前面的元素for (int i = index; i < size-1; i++) {elements[i] = elements[i + 1];}size--;return old;}/** * 查看元素的索引 * @param element * @return */public int indexOf(int element){for (int i = 0; i < size; i++) {if(elements[i] == element) return i;}return ELEMENT_NOT_FOUND;}/** * 清除所有元素 */public void clear(){size = 0;}/* * 扩容操作 */private void ensureCapacity(int capacity){int oldCapacity = elements.length;if(oldCapacity >= capacity) return;// 新容量为旧容量的1.5倍int newCapacity = oldCapacity + (oldCapacity >> 1); // 1.5int[] newElements = new int[newCapacity];for (int i = 0; i < size; i++) {newElements[i] = elements[i];}elements = newElements;System.out.println("size="+oldCapacity+", 扩容到了"+newCapacity);}/****************封装好的功能函数*******************************/// 下标越界抛出的异常private void outOfBounds(int index) {throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);}// 检查下标越界(不可访问或删除size位置)private void rangeCheck(int index){if(index < 0 || index >= size){outOfBounds(index);}}// 检查add()的下标越界(可以在size位置添加)private void rangeCheckForAdd(int index) {if (index < 0 || index > size) {outOfBounds(index);}}/****************封装好的功能函数*******************************/@Overridepublic String toString() {// 打印形式为: size=5, [99, 88, 77, 66, 55]StringBuilder string = new StringBuilder();string.append("size=").append(size).append(", [");for (int i = 0; i < size; i++) {if(0 != i) string.append(", ");string.append(elements[i]);}string.append("]");return string.toString();}}

泛型动态数组源码

@SuppressWarnings("unchecked")public class ArrayList<E> {private int size;// 元素的数量private E[] elements; // 所有的元素private static final int DEFAULT_CAPACITY = 10; // 初始容量private static final int ELEMENT_NOT_FOUND = -1;public ArrayList(int capacity) { // 容量小于10一律扩充为10capacity = (capacity < DEFAULT_CAPACITY) ? DEFAULT_CAPACITY : capacity;elements = (E[])new Object[capacity];}public ArrayList(){this(DEFAULT_CAPACITY);}/** * 元素的数量 * @return */public int size(){return size;}/** * 是否为空 * @return */public boolean isEmpty(){return size == 0;}/** * 是否包含某个元素 * @param element * @return */public boolean contains(E element){return indexOf(element) != ELEMENT_NOT_FOUND; // 找的到该元素则返回True}/** * 在index位置插入一个元素 * @param index * @param element */public void add(int index, E element){ rangeCheckForAdd(index); // 检查下标越界ensureCapacity(size + 1); // 确保容量够大// 0 1 2 3 4 5 6 7 8 9(index)// 1 2 3 4 5 6 x x x x(原数组)// 在index=2处，插入9，元素全部后移// 1 2 9 3 4 5 6 x x x(add后数组)// 先从后往前开始, 将每个元素往后移一位, 然后再赋值for (int i = size - 1; i > index; i--) {elements[i + 1] = elements[i];}elements[index] = element; // 复制size++;}/** * 添加元素到最后面 */public void add(E element){add(size, element);}/** * 设置index位置的元素 * @param index * @param element * @return 原来的元素ֵ */public E get(int index){rangeCheck(index);return elements[index];}/** * 设置index位置的元素 * @param index * @param element * @return 原来的元素ֵ */public E set(int index, E element){rangeCheck(index);E old = elements[index];elements[index] = element;return old;}/** * 删除index位置的元素 * @param index * @return */public E remove(int index){rangeCheck(index);// 0 1 2 3 4 5 (index)// 1 2 3 4 5 6 (原数组)// 删除index为2的元素，元素前移// 1 2 4 5 6(remove后的数组)// 从前往后开始移, 用后面的元素覆盖前面的元素E old = elements[index];for (int i = index; i < size - 1; i++) {elements[i] = elements[i + 1];}elements[--size] = null; // 删除元素后, 将最后一位设置为nullreturn old;}/** * 查看元素的索引 * @param element * @return */public int indexOf(E element){/*// 不对 null 进行处理也可以，但是健壮性不够for (int i = 0; i < size; i++) {if(elements[i].equals(element)) return i;} */if(element == null){ // 对 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;}/** * 清除所有元素 */public void clear(){// 使用泛型数组后要注意内存管理(将元素置null)for (int i = 0; i < size; i++) {elements[i] = null;}size = 0;}/** * 扩容操作 */private void ensureCapacity(int capacity){int oldCapacity = elements.length;if(oldCapacity >= capacity) return;// 新容量为旧容量的1.5倍int newCapacity = oldCapacity + (oldCapacity >> 1);E[] newElements = (E[])new Object[newCapacity];for (int i = 0; i < size; i++) {newElements[i] = elements[i]; // 拷贝原数组元素到新数组}elements = newElements;System.out.println("size="+oldCapacity+", 扩容到了"+newCapacity);}/****************封装好的功能函数**************************/// 下标越界抛出的异常private void outOfBounds(int index) {throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);}// 检查下标越界(不可访问或删除size位置)private void rangeCheck(int index){if(index < 0 || index >= size){outOfBounds(index);}}// 检查add()的下标越界(可以在size位置添加元素)private void rangeCheckForAdd(int index) {if (index < 0 || index > size) {outOfBounds(index);}}/****************封装好的功能函数***************************/@Overridepublic String toString() {// 打印形式为: size=5, [99, 88, 77, 66, 55]StringBuilder string = new StringBuilder();string.append("size=").append(size).append(", [");for (int i = 0; i < size; i++) {if(0 != i) string.append(", ");string.append(elements[i]);}string.append("]");return string.toString();}}

测试运行

public static void main(String[] args) {ArrayList<Person> list = new ArrayList<>();list.add(new Person(10, "jack"));list.add(new Person(20, "rose"));list.add(null);list.add(null);System.out.println("add()添加元素: " + list);System.out.println("get()获取元素: " + list.get(0));list.set(0, new Person(99, "ghost"));System.out.println("set()设置元素值: " + list);list.remove(0);System.out.println("remove()删除元素: " + list);list.clear();System.out.println("clear()清空数组: " + list);}

add()添加元素: size=4, [Person [age=10, name=jack], Person [age=20, name=rose], null, null]get()获取元素: Person [age=10, name=jack]set()设置元素值: size=4, [Person [age=99, name=ghost], Person [age=20, name=rose], null, null]remove()删除元素: size=3, [Person [age=20, name=rose], null, null]clear()清空数组: size=0, []