03-ArrayList(CustomDynamicArray)

数据结构是什么？

.

.

动态数组

.

.

.

Person.java

package com.rnny;

/**
 * @author 软柠柠吖(Runny)
 * @date 2023-01-03
 */
public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    protected void finalize() throws Throwable {
        System.out.println("Person - finalize");
    }
}

Assert.java

package com.rnny;

/**
 * @author 软柠柠吖(Runny)
 * @date 2023-01-01
 */
public class Assert {
    public static void test(boolean value) {
        try {
            // if (value) {} 与 if (!value) {}❓
            //  答：if (value)：表示 value 为 true 时，执行 if 语句
            //      => 简单理解为：当 value 是真的时，执行 if 语句（额……有点多余）
            //      if (!value)：表示 value 为 false 时，执行 if 语句
            //      => 简单理解为：当 value 为假的时，执行 if 语句。
            // 总结：value => true ==> if (value) {}
            //      value => false ==> if (!value) {}
            if (!value) {
                throw new Exception("测试未通过❗");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

ArrayList.java

ArrayList<E>

.

package com.rnny;

/**
 * @author 软柠柠吖(Runny)
 * @date 2023-01-01
 */
@SuppressWarnings("unchecked")
public class ArrayList<E> {
}

成员变量

/**
 * 元素的数量
 */
private int size;
/**
 * 所有的元素
 */
private E[] elements;
/**
 * 默认容量 <br>
 * static：保证变量的内存空间仅此一份
 */
private static final int DEFAULT_CAPACITY = 16;
/**
 * 元素未发现
 */
private static final int ELEMENT_NOT_FOUND = -1;

构造函数

.

public ArrayList() {
    // this(参数)：调用有参构造
    this(DEFAULT_CAPACITY);
}

public ArrayList(int capacity) {
    // > VS <（大于号与小于号如何区分❓）
    //  答：从左向右看（正常看的顺序），如果为大头，则为大于号 '>'
    //                              如果为小头，则为小于号 '<'

    // 等价于：capacity = Math.max(capacity, DEFAULT_CAPACITY);
    capacity = capacity < DEFAULT_CAPACITY ? DEFAULT_CAPACITY : capacity;
    this.size = 0;
    // 对象数组中每个位置存储的是什么❓
    //  答：地址❗对象数组中存储的是对象的地址，而不是具体的对象。
    //  如果存储的是具体的对象，那 Object 就没法用了，这样设计也不好
    //  因为具体对象的大小不确定，无法用 Object[] 接收。
    //  存储地址就能完美的解决这个问题🐲
    this.elements = (E[]) new Object[capacity];
}

clear()

.

/**
 * 清除所有元素
 */
public void clear() {
    for (int i = 0; i < size; i++) {
        elements[i] = null;
    }
    size = 0;
}

size()

/**
 * 元素的数量
 *
 * @return
 */
public int size() {
    return size;
}

isEmpty()

/**
 * 是否为空
 *
 * @return
 */
public boolean isEmpty() {
    // 这里为什么要写 "size == 0" ?
    //  答：自己不应该纠结 JAVA 的判断语句怎么写，而是要按照具体的逻辑写代码。
    //      说的有点抽象❓ 一言以蔽之：用具体的代码来实现方法名所表达的含义❗
    //      例如，方法名 isEmpty：是空的 ==> 则具体的代码就写判断为空即可 ==> 即代码为："size == 0"
    return size == 0;
}

contains(E element)

/**
 * 是否包含某个元素
 *
 * @param element
 * @return
 */
public boolean contains(E element) {
    return indexOf(element) != ELEMENT_NOT_FOUND;
}

add(E element)

.

/**
 * 添加元素到最后面
 *
 * @param element
 */
public void add(E element) {
    // 代码重用
    add(size, element);
    //if (size >= this.elements.length) {
    //    resize();
    //}
    //this.elements[size++] = element;
}

add(int index, E element)

.

/**
 * 往 index 位置添加元素
 *
 * @param index
 * @param element
 */
public void add(int index, E element) {
    rangeCheckForAdd(index);

    ensureCapacity(size + 1);
    //if (size >= this.elements.length) {
    //    resize();
    //}
    //for (int i = size - 1; i >= index; i--) {
    //    elements[i + 1] = elements[i];
    //}
    for (int i = size; i > index; i--) {
        elements[i] = elements[i - 1];
    }
    this.elements[index] = element;
    size++;
}

rangeCheckForAdd(int index)

/**
 * 添加元素时检查下表是否越界
 * @param index
 */
private void rangeCheckForAdd(int index) {
    if (index < 0 || index > size) {
        outOfBounds(index);
    }
}

resize()

最终结果没有使用此方法

private void resize() {
    E[] newArray = (E[]) new Object[elements.length * 2];
    System.arraycopy(elements, 0, newArray, 0, elements.length);
    elements = newArray;
}

ensureCapacity(int desiredCapacity)

.

/**
 * 保证有 desiredCapacity 的容量
 *
 * @param desiredCapacity
 */
private void ensureCapacity(int desiredCapacity) {
    // “微观” VS “宏观”❓
    //  答：微观上指具体的数组元素（索引下标），即水桶中水的位置（刻度线）
    //     宏观上指数组的容量，即水桶的大小（容积）
    // ensureCapacity：保证数组有地方存储增加的元素，因此这里是 “宏观” 问题，即判断容量是否足够。
    int oldCapacity = elements.length;
    if (oldCapacity >= desiredCapacity) {
        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(oldCapacity + " 扩容为 " + newCapacity);
}

get(int index)

/**
 * 返回 index 位置对应的元素
 *
 * @param index
 * @return
 */
public E get(int index) {
    rangeCheck(index);
    return elements[index];
}

rangeCheck(int index)

/**
 * 检查下标是否越界（查询或删除元素）
 * @param index
 */
private void rangeCheck(int index) {
    if (index < 0 || index >= size) {
        outOfBounds(index);
    }
}

set(int index, E element)

/**
 * 设置 index 位置的元素
 *
 * @param index
 * @param element
 * @return
 */
public E set(int index, E element) {
    E oldValue = get(index);
    this.elements[index] = element;
    return oldValue;
}

outOfBounds(int index)

private void outOfBounds(int index) {
    throw new IndexOutOfBoundsException("Index：" + index + ", Size:" + size);
}

remove(int index)

.

.

/**
 * 删除 index 位置对应的元素
 *
 * @param index
 * @return
 */
public E remove(int index) {
    E oldValue = get(index);
    for (int i = index + 1; i < size; i++) {
        this.elements[i - 1] = this.elements[i];
    }
    this.elements[--size] = null;
    return oldValue;
}

remove(E element)

/**
 * 删除与 element 相等的元素
 * @param element
 * @return
 */
public E remove(E element) {
    return remove(indexOf(element));
}

indexOf(E element)

.

/**
 * 查看元素的位置
 *
 * @param element
 * @return
 */
public int indexOf(E element) {
    // for 循环的 "i < size" 判断条件如何理解❓（注意：忽略 for 循环花括号里的语句）
    //  答：① 按照 “指针” 思想来理解，将 i 看作指向每个数组元素的 “索引指针”❗
    //  即，“索引指针” 从 0 开始（第一个元素）遍历，直到 size - 1（最后一个元素）结束。
    //      ② 按照 “执行次数 ” 来理解，这里符合 “等 0 小数”（i = 0, i < 执行次数）的规则，
    //  那么 size 即为执行次数❗
    //  即，for 循环执行 size 次，数组中每个元素都有被遍历到的机会。
    if (element == null) {
        for (int i = 0; i < size; i++) {
            if (this.elements[i] == null) {
                return i;
            }
        }
    } else {
        for (int i = 0; i < size; i++) {
            if (element.equals(this.elements[i])) {
                return i;
            }
        }
    }

    //for (int i = 0; i < size; i++) {
    //    if (this.elements[i] == null) {
    //        if (element == null) {
    //            return i;
    //        }
    //    } else if (this.elements[i].equals(element)) {
    //        return i;
    //    }
    //}
    return ELEMENT_NOT_FOUND;
}

toString()

.

@Override
public String toString() {
    // 格式：size=3, [55, 22, 2]
    // 字符串拼接推荐使用：StringBuilder
    StringBuilder sb = new StringBuilder();
    sb.append("size=").append(size).append(", [");
    for (int i = 0; i < size; i++) {
        // 不需要减法运算，【推荐】
        if (i != 0) {
            sb.append(", ").append(elements[i]);
        } else {
            sb.append(elements[i]);
        }
        // 不是很好❓
        //  原因：判断的时候需要 size - 1，进行减法运算，效率不高
        //if (i == size - 1) {
        //    sb.append(elements[i]).append("]");
        //} else {
        //    sb.append(elements[i]).append(", ");
        //}
    }
    sb.append("]");
    return sb.toString();
}

完整版

.

package com.rnny;

/**
 * @author 软柠柠吖(Runny)
 * @date 2023-01-01
 */
@SuppressWarnings("unchecked")
public class ArrayList<E> {

    /**
     * 元素的数量
     */
    private int size;
    /**
     * 所有的元素
     */
    private E[] elements;
    /**
     * 默认容量 <br>
     * static：保证变量的内存空间仅此一份
     */
    private static final int DEFAULT_CAPACITY = 16;
    /**
     * 元素未发现
     */
    private static final int ELEMENT_NOT_FOUND = -1;

    public ArrayList() {
        // this(参数)：调用有参构造
        this(DEFAULT_CAPACITY);
    }

    public ArrayList(int capacity) {
        // > VS <（大于号与小于号如何区分❓）
        //  答：从左向右看（正常看的顺序），如果为大头，则为大于号 '>'
        //                              如果为小头，则为小于号 '<'

        // 等价于：capacity = Math.max(capacity, DEFAULT_CAPACITY);
        capacity = capacity < DEFAULT_CAPACITY ? DEFAULT_CAPACITY : capacity;
        this.size = 0;
        // 对象数组中每个位置存储的是什么❓
        //  答：地址❗对象数组中存储的是对象的地址，而不是具体的对象。
        //  如果存储的是具体的对象，那 Object 就没法用了，这样设计也不好
        //  因为具体对象的大小不确定，无法用 Object[] 接收。
        //  存储地址就能完美的解决这个问题🐲
        this.elements = (E[]) new Object[capacity];
    }

    /**
     * 清除所有元素
     */
    public void clear() {
        for (int i = 0; i < size; i++) {
            elements[i] = null;
        }
        size = 0;
    }

    /**
     * 元素的数量
     *
     * @return
     */
    public int size() {
        return size;
    }

    /**
     * 是否为空
     *
     * @return
     */
    public boolean isEmpty() {
        // 这里为什么要写 "size == 0" ?
        //  答：自己不应该纠结 JAVA 的判断语句怎么写，而是要按照具体的逻辑写代码。
        //      说的有点抽象❓ 一言以蔽之：用具体的代码来实现方法名所表达的含义❗
        //      例如，方法名 isEmpty：是空的 ==> 则具体的代码就写判断为空即可 ==> 即代码为："size == 0"
        return size == 0;
    }

    /**
     * 是否包含某个元素
     *
     * @param element
     * @return
     */
    public boolean contains(E element) {
        return indexOf(element) != ELEMENT_NOT_FOUND;
    }

    /**
     * 添加元素到最后面
     *
     * @param element
     */
    public void add(E element) {
        add(size, element);
        //if (size >= this.elements.length) {
        //    resize();
        //}
        //this.elements[size++] = element;
    }

    private void resize() {
        E[] newArray = (E[]) new Object[elements.length * 2];
        System.arraycopy(elements, 0, newArray, 0, elements.length);
        elements = newArray;
    }

    /**
     * 保证有 desiredCapacity 的容量
     *
     * @param desiredCapacity
     */
    private void ensureCapacity(int desiredCapacity) {
        // “微观” VS “宏观”❓
        //  答：微观上指具体的数组元素（索引下标），即水桶中水的位置（刻度线）
        //     宏观上指数组的容量，即水桶的大小（容积）
        // ensureCapacity：保证数组有地方存储增加的元素，因此这里是 “宏观” 问题，即判断容量是否足够。
        int oldCapacity = elements.length;
        if (oldCapacity >= desiredCapacity) {
            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(oldCapacity + " 扩容为 " + newCapacity);
    }

    /**
     * 返回 index 位置对应的元素
     *
     * @param index
     * @return
     */
    public E get(int index) {
        rangeCheck(index);
        return elements[index];
    }

    /**
     * 检查下标是否越界（查询或删除元素）
     * @param index
     */
    private void rangeCheck(int index) {
        if (index < 0 || index >= size) {
            outOfBounds(index);
        }
    }

    /**
     * 设置 index 位置的元素
     *
     * @param index
     * @param element
     * @return
     */
    public E set(int index, E element) {
        E oldValue = get(index);
        this.elements[index] = element;
        return oldValue;
    }

    /**
     * 往 index 位置添加元素
     *
     * @param index
     * @param element
     */
    public void add(int index, E element) {
        rangeCheckForAdd(index);

        ensureCapacity(size + 1);
        //if (size >= this.elements.length) {
        //    resize();
        //}
        //for (int i = size - 1; i >= index; i--) {
        //    elements[i + 1] = elements[i];
        //}
        for (int i = size; i > index; i--) {
            elements[i] = elements[i - 1];
        }
        this.elements[index] = element;
        size++;
    }

    /**
     * 添加元素时检查下表是否越界
     * @param index
     */
    private void rangeCheckForAdd(int index) {
        if (index < 0 || index > size) {
            outOfBounds(index);
        }
    }

    private void outOfBounds(int index) {
        throw new IndexOutOfBoundsException("Index：" + index + ", Size:" + size);
    }

    /**
     * 删除 index 位置对应的元素
     *
     * @param index
     * @return
     */
    public E remove(int index) {
        E oldValue = get(index);
        for (int i = index + 1; i < size; i++) {
            this.elements[i - 1] = this.elements[i];
        }
        this.elements[--size] = null;
        return oldValue;
    }

    /**
     * 删除与 element 相等的元素
     * @param element
     * @return
     */
    public E remove(E element) {
        return remove(indexOf(element));
    }

    /**
     * 查看元素的位置
     *
     * @param element
     * @return
     */
    public int indexOf(E element) {
        // for 循环的 "i < size" 判断条件如何理解❓（注意：忽略 for 循环花括号里的语句）
        //  答：① 按照 “指针” 思想来理解，将 i 看作指向每个数组元素的 “索引指针”❗
        //  即，“索引指针” 从 0 开始（第一个元素）遍历，直到 size - 1（最后一个元素）结束。
        //      ② 按照 “执行次数 ” 来理解，这里符合 “等 0 小数”（i = 0, i < 执行次数）的规则，
        //  那么 size 即为执行次数❗
        //  即，for 循环执行 size 次，数组中每个元素都有被遍历到的机会。
        if (element == null) {
            for (int i = 0; i < size; i++) {
                if (this.elements[i] == null) {
                    return i;
                }
            }
        } else {
            for (int i = 0; i < size; i++) {
                if (element.equals(this.elements[i])) {
                    return i;
                }
            }
        }

        //for (int i = 0; i < size; i++) {
        //    if (this.elements[i] == null) {
        //        if (element == null) {
        //            return i;
        //        }
        //    } else if (this.elements[i].equals(element)) {
        //        return i;
        //    }
        //}
        return ELEMENT_NOT_FOUND;
    }

    @Override
    public String toString() {
        // 格式：size=3, [55, 22, 2]
        // 字符串拼接推荐使用：StringBuilder
        StringBuilder sb = new StringBuilder();
        sb.append("size=").append(size).append(", [");
        for (int i = 0; i < size; i++) {
            // 不需要减法运算，【推荐】
            if (i != 0) {
                sb.append(", ").append(elements[i]);
            } else {
                sb.append(elements[i]);
            }
            // 不是很好❓
            //  原因：判断的时候需要 size - 1，进行减法运算，效率不高
            //if (i == size - 1) {
            //    sb.append(elements[i]).append("]");
            //} else {
            //    sb.append(elements[i]).append(", ");
            //}
        }
        sb.append("]");
        return sb.toString();
    }
}

Main.java

package com.rnny;

/**
 * @author 软柠柠吖(Runny)
 * @date 2023-01-01
 */
public class Main {
    public static void main(String[] args) {
        // 所有的类，最终都继承 java.lang.Object

        // new：向堆空间申请内存
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        //list.add(list.size() - 1, 100);
        //list.set(0, 30);
        //list.remove(2);
        //System.out.println(list);
        //Assert.test(list.get(list.size() - 2) == 100);

        ArrayList<Person> personArrayList = new ArrayList<>();
        personArrayList.add(new Person("jack", 12));
        personArrayList.add(new Person("tom", 14));
        personArrayList.add(new Person("scott", 16));

        personArrayList.clear();
        // 提醒 JVM 进行垃圾回收
        System.gc();
    }
}