ArrayList的编写

最新推荐文章于 2023-03-31 22:00:40 发布
最新推荐文章于 2023-03-31 22:00:40 发布
阅读量335 收藏 2
点赞数
分类专栏： java 文章标签： java arraylist
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44768464/article/details/120355354
版权

ArrayList

构建一个集合，用来存储数据

通过一个集合对象，可以屏蔽掉底层存储的复杂度，实际存储选择使用数组进行。

可以存储任意类型：Java中使用泛型来解决这个问题。

将当前的数组封装到我们的集合对象，ArrayList中去，避免了用户在去调用的过程中还需要去维护数组本身带来的复杂性操作。

编码实现ArrayList构造器
package arraylist;

/**
 * @author renyuhua
 * @date 2021年09月16日 16:33
 * 需求：
 *      1、存储任意类型，我们通过泛型搞定
 *      2、存储数据的大小由用户指定，或者自己指定一个合适的大小。
 */
public class ArrayList<E> {

    /**
     * 实际存储容器的数据
     */
    private E[] elementsDatal;

    /**
     * 指定默认情况下数组的初始长度为10。
     */
    private static final int INIT_CAPACITY = 10;

    /**
     * 空构造器 创建一个指定长度的数组对象。
     */
    public ArrayList(){
        this(INIT_CAPACITY);
    }

    /**
     * 创建一个带参的构造器，创建用户指定长度的数组对象
     * @param capacity 用户指定的数组长度
     */
    public ArrayList(int capacity){
        // 初始化我们对应的存储数据的数据对象即可
        this.elementsDatal = (E[])new Object[capacity];
    }
}
常见查询方法及添加元素
package arraylist;

/**
 * @author renyuhua
 * @date 2021年09月16日 16:33
 * 需求：
 *      1、存储任意类型，我们通过泛型搞定
 *      2、存储数据的大小由用户指定，或者自己指定一个合适的大小。
 */
public class ArrayList<E> {

    /**
     * 实际存储容器的数据
     */
    private E[] elementsDatal;

    /**
     * 指定默认情况下数组的初始长度为10。
     */
    private static final int INIT_CAPACITY = 10;

    /**
     * 维护当前数组中的待添加的索引位置
     * 维护当前数组的元素个数
     */
    private int size;

    /**
     * 空构造器 创建一个指定长度的数组对象。
     */
    public ArrayList(){
        this(INIT_CAPACITY);
    }

    /**
     * 创建一个带参的构造器，创建用户指定长度的数组对象
     * @param capacity 用户指定的数组长度
     */
    public ArrayList(int capacity){
        // 初始化我们对应的存储数据的数据对象即可
        this.elementsDatal = (E[])new Object[capacity];
    }

    /**
     * 添加元素E到当前的集合中
     * @param e
     */
    public void add(E e){
        // 将元素e添加到size指向的索引位置
        elementsDatal[size] = e;
        // 维护一下size即可
        size++;
    }

    /**
     * 查看当前集合是否为空
     * @return
     */
    public boolean isEmpty(){
        return size == 0;
    }

    /**
     * 查询当前集合中的元素个数
     * @return
     */
    public int getSize(){
        return size;
    }
}
修改添加操作的语义以及重写方法toString
package arraylist;

/**
 * @author renyuhua
 * @date 2021年09月16日 16:33
 * 需求：
 *      1、存储任意类型，我们通过泛型搞定
 *      2、存储数据的大小由用户指定，或者自己指定一个合适的大小。
 */
public class ArrayList<E> {

    /**
     * 实际存储容器的数据
     */
    private E[] elementsDatal;

    /**
     * 指定默认情况下数组的初始长度为10。
     */
    private static final int INIT_CAPACITY = 10;

    /**
     * 维护当前数组中的待添加的索引位置
     * 维护当前数组的元素个数
     */
    private int size;

    /**
     * 空构造器 创建一个指定长度的数组对象。
     */
    public ArrayList(){
        this(INIT_CAPACITY);
    }

    /**
     * 创建一个带参的构造器，创建用户指定长度的数组对象
     * @param capacity 用户指定的数组长度
     */
    public ArrayList(int capacity){
        // 初始化我们对应的存储数据的数据对象即可
        this.elementsDatal = (E[])new Object[capacity];
    }

    /**
     * 添加元素E到当前的集合中的末尾
     * @param e
     */
    public void add(E e){
        addLast(e);
    }

    /**
     * 添加元素到当前集合中的末尾
     * @param e
     */
    public void addLast(E e){
        // 将元素e添加到size指向的索引位置
        elementsDatal[size] = e;
        // 维护一下size即可
        size++;
    }

    /**
     * 查看当前集合是否为空
     * @return
     */
    public boolean isEmpty(){
        return size == 0;
    }

    /**
     * 查询当前集合中的元素个数
     * @return
     */
    public int getSize(){
        return size;
    }

    public String toString(){
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("size:"+size+"{");
        for (int i = 0; i < size; i++) {
            stringBuilder.append(elementsDatal[i]);
            if (i!=size-1){
                stringBuilder.append(",");
            }
        }
        stringBuilder.append("}");
        return stringBuilder.toString();
    }
}


package arraylist;

/**
 * @author renyuhua
 * @date 2021年09月16日 17:05
 */
public class ArrayListTest {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        System.out.println("打印当前集合是否为空："+list.isEmpty());
        System.out.println("当前集合中的元素个数："+list.getSize());

        // 添加元素
        for (int i = 1; i < 11; i++) {
            list.add(i);
            System.out.println("当前集合元素："+list);
        }
    }
}
添加元素到指定索引位置上
package arraylist;

/**
 * @author renyuhua
 * @date 2021年09月16日 17:05
 */
public class ArrayListTest {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        System.out.println("当前集合中的元素个数："+list.getSize());
        list.addFirst(13);
        list.addFirst(12);
        list.addLast(14);
        System.out.println(list);

        for (int i = 0; i < 7; i++) {
            list.add(i);
        }
        System.out.println(list);

    }


    public static void test(){
        ArrayList<Integer> list = new ArrayList<>();
        System.out.println("打印当前集合是否为空："+list.isEmpty());
        System.out.println("当前集合中的元素个数："+list.getSize());

        // 添加元素
        for (int i = 1; i < 11; i++) {
            list.add(i);
            System.out.println("当前集合元素："+list);
        }
    }
}


package arraylist;

/**
 * @author renyuhua
 * @date 2021年09月16日 16:33
 * 需求：
 *      1、存储任意类型，我们通过泛型搞定
 *      2、存储数据的大小由用户指定，或者自己指定一个合适的大小。
 */
public class ArrayList<E> {

    /**
     * 实际存储容器的数据
     */
    private E[] elementsDatal;

    /**
     * 指定默认情况下数组的初始长度为10。
     */
    private static final int INIT_CAPACITY = 10;

    /**
     * 维护当前数组中的待添加的索引位置
     * 维护当前数组的元素个数
     */
    private int size;

    /**
     * 空构造器 创建一个指定长度的数组对象。
     */
    public ArrayList(){
        this(INIT_CAPACITY);
    }

    /**
     * 创建一个带参的构造器，创建用户指定长度的数组对象
     * @param capacity 用户指定的数组长度
     */
    public ArrayList(int capacity){
        // 初始化我们对应的存储数据的数据对象即可
        this.elementsDatal = (E[])new Object[capacity];
    }

    /**
     * 添加元素E到当前的集合中的末尾
     * @param e
     */
    public void add(E e){
        addLast(e);
    }

    /**
     * 添加元素到指定的索引位置上
     * @param e
     * @param index
     */
    public void add(E e,int index){
        // 判定index的合法性，不能添加超过size的元素，防止数组中出现内存碎片
        checkIndex(index);
        // 循环挪动元素
        for (int i = size; i > index; i--)
            elementsDatal[i] = elementsDatal[i-1];
        // 保证index上的元素空出来
        elementsDatal[index] = e;
        // 维护size
        size++;

    }

    /**
     * 添加首元素
     * @param e
     */
    public void addFirst(E e){
        add(e,0);
    }

    /**
     * 判定index的合法性
     * @param index
     */
    private void checkIndex(int index){
        if (index<0 || index>size){
            throw new IllegalArgumentException("index out of bounds index"+index);
        }
    }

    /**
     * 添加元素到当前集合中的末尾
     * @param e
     */
    public void addLast(E e){
        // 将元素e添加到size指向的索引位置
        elementsDatal[size] = e;
        // 维护一下size即可
        size++;
    }

    /**
     * 查看当前集合是否为空
     * @return
     */
    public boolean isEmpty(){
        return size == 0;
    }

    /**
     * 查询当前集合中的元素个数
     * @return
     */
    public int getSize(){
        return size;
    }

    public String toString(){
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("size:"+size+"{");
        for (int i = 0; i < size; i++) {
            stringBuilder.append(elementsDatal[i]);
            if (i!=size-1){
                stringBuilder.append(",");
            }
        }
        stringBuilder.append("}");
        return stringBuilder.toString();
    }
}
扩容操作

数组长度一旦指定了，添加元素过多，导致添加失败

package arraylist;

/**
 * @author renyuhua
 * @date 2021年09月16日 17:05
 */
public class ArrayListTest {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        System.out.println("当前集合中的元素个数："+list.getSize());
        list.addFirst(13);
        list.addFirst(12);
        list.addLast(14);
        System.out.println(list);

        for (int i = 0; i < 7; i++) {
            list.add(i);
        }
        list.add(20);
        System.out.println(list);

    }


    public static void test(){
        ArrayList<Integer> list = new ArrayList<>();
        System.out.println("打印当前集合是否为空："+list.isEmpty());
        System.out.println("当前集合中的元素个数："+list.getSize());

        // 添加元素
        for (int i = 1; i < 11; i++) {
            list.add(i);
            System.out.println("当前集合元素："+list);
        }
    }
}


package arraylist;

/**
 * @author renyuhua
 * @date 2021年09月16日 16:33
 * 需求：
 *      1、存储任意类型，我们通过泛型搞定
 *      2、存储数据的大小由用户指定，或者自己指定一个合适的大小。
 */
public class ArrayList<E> {

    /**
     * 实际存储容器的数据
     */
    private E[] elementsDatal;

    /**
     * 指定默认情况下数组的初始长度为10。
     */
    private static final int INIT_CAPACITY = 10;

    /**
     * 维护当前数组中的待添加的索引位置
     * 维护当前数组的元素个数
     */
    private int size;

    /**
     * 维护当前数组中的最大存储容量
     */
    private int capacity;

    /**
     * 空构造器 创建一个指定长度的数组对象。
     */
    public ArrayList(){
        this(INIT_CAPACITY);
    }

    /**
     * 创建一个带参的构造器，创建用户指定长度的数组对象
     * @param capacity 用户指定的数组长度
     */
    public ArrayList(int capacity){
        // 初始化我们对应的存储数据的数据对象即可
        this.elementsDatal = (E[])new Object[capacity];
        this.capacity = capacity;
    }

    /**
     * 添加元素E到当前的集合中的末尾
     * @param e
     */
    public void add(E e){
        addLast(e);
    }

    /**
     * 添加元素到指定的索引位置上
     * @param e
     * @param index
     */
    public void add(E e,int index){
        // 判定index的合法性，不能添加超过size的元素，防止数组中出现内存碎片
        checkIndex(index);

        // 判定当前数组是否满了
        if (size==capacity)
            grow(capacity*2);

        // 循环挪动元素
        for (int i = size; i > index; i--)
            elementsDatal[i] = elementsDatal[i-1];
        // 保证index上的元素空出来
        elementsDatal[index] = e;
        // 维护size
        size++;

    }

    /**
     * 数组扩容的方法
     * @param newCapacity
     */
    private void grow(int newCapacity){
        // 重新定义一个新的数组
        E[] newElementData = (E[]) new Object[newCapacity];
        // 进行数组拷贝
        for (int i = 0; i < size; i++)
            newElementData[i] = elementsDatal[i];
        // 将对象中的elementData重新进行指向
        this.elementsDatal = newElementData;
        // 维护capacity的值
        this.capacity = newCapacity;
    }

    /**
     * 添加首元素
     * @param e
     */
    public void addFirst(E e){
        add(e,0);
    }

    /**
     * 判定index的合法性
     * @param index
     */
    private void checkIndex(int index){
        if (index<0 || index>size){
            throw new IllegalArgumentException("index out of bounds index"+index);
        }
    }

    /**
     * 添加元素到当前集合中的末尾
     * @param e
     */
    public void addLast(E e){
        if (size==capacity)
            grow(capacity*2);
        // 将元素e添加到size指向的索引位置
        elementsDatal[size] = e;
        // 维护一下size即可
        size++;
    }

    /**
     * 查看当前集合是否为空
     * @return
     */
    public boolean isEmpty(){
        return size == 0;
    }

    /**
     * 查询当前集合中的元素个数
     * @return
     */
    public int getSize(){
        return size;
    }

    @Override
    public String toString(){
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("size:"+size+"{");
        for (int i = 0; i < size; i++) {
            stringBuilder.append(elementsDatal[i]);
            if (i!=size-1){
                stringBuilder.append(",");
            }
        }
        stringBuilder.append("} capacity:"+capacity);
        return stringBuilder.toString();
    }
}
删除指定位置上的元素
package arraylist;

/**
 * @author renyuhua
 * @date 2021年09月16日 17:05
 */
public class ArrayListTest {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        System.out.println("当前集合中的元素个数："+list.getSize());
        list.addFirst(13);
        list.addFirst(12);
        list.addLast(14);
        System.out.println(list);

        for (int i = 0; i < 7; i++) {
            list.add(i);
        }
        list.add(20);
        System.out.println(list);

        list.remove(0);
        System.out.println(list);

        list.remove(Integer.valueOf(14));
        System.out.println(list);
    }


    public static void test(){
        ArrayList<Integer> list = new ArrayList<>();
        System.out.println("打印当前集合是否为空："+list.isEmpty());
        System.out.println("当前集合中的元素个数："+list.getSize());

        // 添加元素
        for (int i = 1; i < 11; i++) {
            list.add(i);
            System.out.println("当前集合元素："+list);
        }
    }
}


package arraylist;

/**
 * @author renyuhua
 * @date 2021年09月16日 16:33
 * 需求：
 *      1、存储任意类型，我们通过泛型搞定
 *      2、存储数据的大小由用户指定，或者自己指定一个合适的大小。
 */
public class ArrayList<E> {

    /**
     * 实际存储容器的数据
     */
    private E[] elementsDatal;

    /**
     * 指定默认情况下数组的初始长度为10。
     */
    private static final int INIT_CAPACITY = 10;

    /**
     * 维护当前数组中的待添加的索引位置
     * 维护当前数组的元素个数
     */
    private int size;

    /**
     * 维护当前数组中的最大存储容量
     */
    private int capacity;

    /**
     * 空构造器 创建一个指定长度的数组对象。
     */
    public ArrayList(){
        this(INIT_CAPACITY);
    }

    /**
     * 创建一个带参的构造器，创建用户指定长度的数组对象
     * @param capacity 用户指定的数组长度
     */
    public ArrayList(int capacity){
        // 初始化我们对应的存储数据的数据对象即可
        this.elementsDatal = (E[])new Object[capacity];
        this.capacity = capacity;
    }

    /**
     * 添加元素E到当前的集合中的末尾
     * @param e
     */
    public void add(E e){
        addLast(e);
    }

    /**
     * 添加元素到指定的索引位置上
     * @param e
     * @param index
     */
    public void add(E e,int index){
        // 判定index的合法性，不能添加超过size的元素，防止数组中出现内存碎片
        checkIndex(index);

        // 判定当前数组是否满了
        if (size==capacity)
            grow(capacity*2);

        // 循环挪动元素
        for (int i = size; i > index; i--)
            elementsDatal[i] = elementsDatal[i-1];
        // 保证index上的元素空出来
        elementsDatal[index] = e;
        // 维护size
        size++;

    }

    /**
     * 数组扩容的方法
     * @param newCapacity
     */
    private void grow(int newCapacity){
        // 重新定义一个新的数组
        E[] newElementData = (E[]) new Object[newCapacity];
        // 进行数组拷贝
        for (int i = 0; i < size; i++)
            newElementData[i] = elementsDatal[i];
        // 将对象中的elementData重新进行指向
        this.elementsDatal = newElementData;
        // 维护capacity的值
        this.capacity = newCapacity;
    }

    /**
     * 添加首元素
     * @param e
     */
    public void addFirst(E e){
        add(e,0);
    }

    /**
     * 删除指定索引位置上的元素
     * @param index 删除索引
     * @return 删除位置的元素
     */
    public E remove(int index){
        // 判定索引是否有效
        checkIndex(index);
        // 获取待删除的元素
        E ret = elementsDatal[index];
        // 循环挪动元素
        for (int i = index; i < size - 1; i++){
            elementsDatal[i] = elementsDatal[i+1];
        }
        // 维护索引
        size--;
        // 将size指向的元素置为null
        elementsDatal[size] = null;
        return ret;
    }

    /**
     * 删除指定元素
     * @param e
     */
    public void remove(E e){
        // 查找该元素是否存在
        int index = indexOf(e);
        if (index==-1){
            throw new IllegalArgumentException("element e: "+e+" is not found");
        }
        remove(index);
    }

    /**
     * 查找元素是否存在，
     * @param e 元素
     * @return 如果存在，返回对应的索引，如果不存在，返回-1
     */
    public int indexOf(E e){
        // 控制判定用==就可以了，非空值的判定用equals
        if (e==null){
            for (int i = 0; i < size; i++) {
                if (elementsDatal[i]==null){
                    return i;
                }
            }
        }else {
            for (int i = 0; i < size; i++) {
                if (e.equals(elementsDatal[i])){
                    return i;
                }
            }
        }
        return -1;
    }

    /**
     * 判定index的合法性
     * @param index
     */
    private void checkIndex(int index){
        if (index<0 || index>size){
            throw new IllegalArgumentException("index out of bounds index"+index);
        }
    }

    /**
     * 添加元素到当前集合中的末尾
     * @param e
     */
    public void addLast(E e){
        if (size==capacity)
            grow(capacity*2);
        // 将元素e添加到size指向的索引位置
        elementsDatal[size] = e;
        // 维护一下size即可
        size++;
    }

    /**
     * 查看当前集合是否为空
     * @return
     */
    public boolean isEmpty(){
        return size == 0;
    }

    /**
     * 查询当前集合中的元素个数
     * @return
     */
    public int getSize(){
        return size;
    }

    @Override
    public String toString(){
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("size:"+size+"{");
        for (int i = 0; i < size; i++) {
            stringBuilder.append(elementsDatal[i]);
            if (i!=size-1){
                stringBuilder.append(",");
            }
        }
        stringBuilder.append("} capacity:"+capacity);
        return stringBuilder.toString();
    }
}
删除首位元素以及缩容操作
package arraylist;

/**
 * @author renyuhua
 * @date 2021年09月16日 16:33
 * 需求：
 *      1、存储任意类型，我们通过泛型搞定
 *      2、存储数据的大小由用户指定，或者自己指定一个合适的大小。
 */
public class ArrayList<E> {

    /**
     * 实际存储容器的数据
     */
    private E[] elementsDatal;

    /**
     * 指定默认情况下数组的初始长度为10。
     */
    private static final int INIT_CAPACITY = 10;

    /**
     * 维护当前数组中的待添加的索引位置
     * 维护当前数组的元素个数
     */
    private int size;

    /**
     * 维护当前数组中的最大存储容量
     */
    private int capacity;

    /**
     * 空构造器 创建一个指定长度的数组对象。
     */
    public ArrayList(){
        this(INIT_CAPACITY);
    }

    /**
     * 创建一个带参的构造器，创建用户指定长度的数组对象
     * @param capacity 用户指定的数组长度
     */
    public ArrayList(int capacity){
        // 初始化我们对应的存储数据的数据对象即可
        this.elementsDatal = (E[])new Object[capacity];
        this.capacity = capacity;
    }

    /**
     * 添加元素E到当前的集合中的末尾
     * @param e 元素
     */
    public void add(E e){
        addLast(e);
    }

    /**
     * 添加元素到指定的索引位置上
     * @param e 元素
     * @param index 索引
     */
    public void add(E e,int index){
        // 判定index的合法性，不能添加超过size的元素，防止数组中出现内存碎片
        checkIndex(index);

        // 判定当前数组是否满了
        if (size==capacity){
            grow(capacity*2);
        }

        // 循环挪动元素
        for (int i = size; i > index; i--){
            elementsDatal[i] = elementsDatal[i-1];
        }
        // 保证index上的元素空出来
        elementsDatal[index] = e;
        // 维护size
        size++;

    }

    /**
     * 数组扩容的方法
     * @param newCapacity 新的容量
     */
    private void grow(int newCapacity){
        // 重新定义一个新的数组
        E[] newElementData = (E[]) new Object[newCapacity];
        // 进行数组拷贝
        for (int i = 0; i < size; i++)
            newElementData[i] = elementsDatal[i];
        // 将对象中的elementData重新进行指向
        this.elementsDatal = newElementData;
        // 维护capacity的值
        this.capacity = newCapacity;
    }

    /**
     * 添加首元素
     * @param e 元素
     */
    public void addFirst(E e){
        add(e,0);
    }

    /**
     * 删除指定索引位置上的元素
     * @param index 删除索引
     * @return 删除位置的元素
     */
    public E remove(int index){
        // 判定索引是否有效
        checkIndex(index);
        // 获取待删除的元素
        E ret = elementsDatal[index];
        // 循环挪动元素
        for (int i = index; i < size - 1; i++){
            elementsDatal[i] = elementsDatal[i+1];
        }
        // 维护索引
        size--;
        // 将size指向的元素置为null
        elementsDatal[size] = null;
        // 判断是否缩容
        if (size==capacity/2){
            grow(capacity/2);
        }
        return ret;
    }

    /**
     * 删除指定元素
     * @param e 元素
     */
    public void remove(Object e){
        // 查找该元素是否存在
        int index = indexOf((E)e);
        if (index==-1){
            throw new IllegalArgumentException("element e: "+e+" is not found");
        }
        remove(index);
    }

    /**
     * 删除首元素
     * @return 删除位置的元素
     */
    public E removeFirst(){
        return remove(0);
    }

    /**
     * 删除尾元素
     * @return 删除位置的元素
     */
    public E removeLast(){
        E ret = elementsDatal[size-1];
        elementsDatal[size--] = null;
        if (size==capacity/2){
            grow(capacity/2);
        }
        return ret;
    }

    /**
     * 查找元素是否存在，
     * @param e 元素
     * @return 如果存在，返回对应的索引，如果不存在，返回-1
     */
    public int indexOf(E e){
        // 控制判定用==就可以了，非空值的判定用equals
        if (e==null){
            for (int i = 0; i < size; i++) {
                if (elementsDatal[i]==null){
                    return i;
                }
            }
        }else {
            for (int i = 0; i < size; i++) {
                if (e.equals(elementsDatal[i])){
                    return i;
                }
            }
        }
        return -1;
    }

    /**
     * 判定index的合法性
     * @param index 索引
     */
    private void checkIndex(int index){
        if (index<0 || index>size){
            throw new IllegalArgumentException("index out of bounds index"+index);
        }
    }

    /**
     * 添加元素到当前集合中的末尾
     * @param e 元素
     */
    public void addLast(E e){
        if (size==capacity){
            grow(capacity*2);
        }
        // 将元素e添加到size指向的索引位置
        elementsDatal[size] = e;
        // 维护一下size即可
        size++;
    }

    /**
     * 查看当前集合是否为空
     * @return 判断size是否为空
     */
    public boolean isEmpty(){
        return size == 0;
    }

    /**
     * 查询当前集合中的元素个数
     * @return 返回size
     */
    public int getSize(){
        return size;
    }

    @Override
    public String toString(){
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("size:"+size+"{");
        for (int i = 0; i < size; i++) {
            stringBuilder.append(elementsDatal[i]);
            if (i!=size-1){
                stringBuilder.append(",");
            }
        }
        stringBuilder.append("} capacity:"+capacity);
        return stringBuilder.toString();
    }
}


package arraylist;

/**
 * @author renyuhua
 * @date 2021年09月16日 17:05
 */
public class ArrayListTest {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        System.out.println("当前集合中的元素个数："+list.getSize());
        list.addFirst(13);
        list.addFirst(12);
        list.addLast(14);
        System.out.println(list);

        for (int i = 0; i < 7; i++) {
            list.add(i);
        }
        list.add(20);
        System.out.println(list);
        System.out.println(list.removeLast());
        System.out.println(list);
        System.out.println(list.removeFirst());
        System.out.println(list);
    }


    public static void test(){
        ArrayList<Integer> list = new ArrayList<>();
        System.out.println("打印当前集合是否为空："+list.isEmpty());
        System.out.println("当前集合中的元素个数："+list.getSize());

        // 添加元素
        for (int i = 1; i < 11; i++) {
            list.add(i);
            System.out.println("当前集合元素："+list);
        }
    }
}
关于复杂度震荡问题及边界检查
package arraylist;

/**
 * @author renyuhua
 * @date 2021年09月16日 17:05
 */
public class ArrayListTest {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>(2);
        System.out.println(list);
        for (int i = 0; i < 2; i++){
            list.add("apple"+i);
        }
        for (int i = 2; i < 12; i++) {
            if (i%2==0){
                list.addLast("apple2");
            }
            else {
                list.removeLast();
            }
            System.out.println(list);

        }
        list.remove("apple1");
        list.remove("apple0");
        System.out.println(list);
        list.add("banana");
        System.out.println(list);
        list.removeFirst();
        System.out.println(list);
        list.add("banana");
        System.out.println(list);
    }

    public static void test2(){
        ArrayList<Integer> list = new ArrayList<>();
        System.out.println("当前集合中的元素个数："+list.getSize());
        list.addFirst(13);
        list.addFirst(12);
        list.addLast(14);
        System.out.println(list);

        for (int i = 0; i < 7; i++) {
            list.add(i);
        }
        list.add(20);
        System.out.println(list);
        System.out.println(list.removeLast());
        System.out.println(list);
        System.out.println(list.removeFirst());
        System.out.println(list);
    }

    public static void test(){
        ArrayList<Integer> list = new ArrayList<>();
        System.out.println("打印当前集合是否为空："+list.isEmpty());
        System.out.println("当前集合中的元素个数："+list.getSize());

        // 添加元素
        for (int i = 1; i < 11; i++) {
            list.add(i);
            System.out.println("当前集合元素："+list);
        }
    }
}


package arraylist;

/**
 * @author renyuhua
 * @date 2021年09月16日 16:33
 * 需求：
 *      1、存储任意类型，我们通过泛型搞定
 *      2、存储数据的大小由用户指定，或者自己指定一个合适的大小。
 */
public class ArrayList<E> {

    /**
     * 实际存储容器的数据
     */
    private E[] elementsDatal;

    /**
     * 指定默认情况下数组的初始长度为10。
     */
    private static final int INIT_CAPACITY = 10;

    /**
     * 维护当前数组中的待添加的索引位置
     * 维护当前数组的元素个数
     */
    private int size;

    /**
     * 维护当前数组中的最大存储容量
     */
    private int capacity;

    /**
     * 空构造器 创建一个指定长度的数组对象。
     */
    public ArrayList(){
        this(INIT_CAPACITY);
    }

    /**
     * 创建一个带参的构造器，创建用户指定长度的数组对象
     * @param capacity 用户指定的数组长度
     */
    public ArrayList(int capacity){
        // 初始化我们对应的存储数据的数据对象即可
        this.elementsDatal = (E[])new Object[capacity];
        this.capacity = capacity;
    }

    /**
     * 添加元素E到当前的集合中的末尾
     * @param e 元素
     */
    public void add(E e){
        addLast(e);
    }

    /**
     * 添加元素到指定的索引位置上
     * @param e 元素
     * @param index 索引
     */
    public void add(E e,int index){
        // 判定index的合法性，不能添加超过size的元素，防止数组中出现内存碎片
        checkIndex(index);

        // 判定当前数组是否满了
        if (size==capacity){
            grow(capacity*2);
        }

        // 循环挪动元素
        for (int i = size; i > index; i--){
            elementsDatal[i] = elementsDatal[i-1];
        }
        // 保证index上的元素空出来
        elementsDatal[index] = e;
        // 维护size
        size++;

    }

    /**
     * 数组扩容的方法
     * @param newCapacity 新的容量
     */
    private void grow(int newCapacity){
        // 重新定义一个新的数组
        E[] newElementData = (E[]) new Object[newCapacity];
        // 进行数组拷贝
        for (int i = 0; i < size; i++)
            newElementData[i] = elementsDatal[i];
        // 将对象中的elementData重新进行指向
        this.elementsDatal = newElementData;
        // 维护capacity的值
        this.capacity = newCapacity;
    }

    /**
     * 添加首元素
     * @param e 元素
     */
    public void addFirst(E e){
        add(e,0);
    }

    /**
     * 删除指定索引位置上的元素
     * @param index 删除索引
     * @return 删除位置的元素
     */
    public E remove(int index){
        // 判定索引是否有效
        checkIndex(index);
        // 获取待删除的元素
        E ret = elementsDatal[index];
        // 循环挪动元素
        for (int i = index; i < size - 1; i++){
            elementsDatal[i] = elementsDatal[i+1];
        }
        // 维护索引
        size--;
        // 将size指向的元素置为null
        elementsDatal[size] = null;
        // 判断是否缩容
        if (size==capacity/4&&capacity/2!=0){
            grow(capacity/2);
        }
        return ret;
    }

    /**
     * 删除指定元素
     * @param e 元素
     */
    public void remove(Object e){
        // 查找该元素是否存在
        int index = indexOf((E)e);
        if (index==-1){
            throw new IllegalArgumentException("element e: "+e+" is not found");
        }
        remove(index);
    }

    /**
     * 删除首元素
     * @return 删除位置的元素
     */
    public E removeFirst(){
        return remove(0);
    }

    /**
     * 删除尾元素
     * @return 删除位置的元素
     */
    public E removeLast(){
//        E ret = elementsDatal[size-1];
//        elementsDatal[size--] = null;
//        if (size==capacity/2){
//            grow(capacity/2);
//        }
//        return ret;
        return remove(size-1);
    }

    /**
     * 查找元素是否存在，
     * @param e 元素
     * @return 如果存在，返回对应的索引，如果不存在，返回-1
     */
    public int indexOf(E e){
        // 控制判定用==就可以了，非空值的判定用equals
        if (e==null){
            for (int i = 0; i < size; i++) {
                if (elementsDatal[i]==null){
                    return i;
                }
            }
        }else {
            for (int i = 0; i < size; i++) {
                if (e.equals(elementsDatal[i])){
                    return i;
                }
            }
        }
        return -1;
    }

    /**
     * 判定index的合法性
     * @param index 索引
     */
    private void checkIndex(int index){
        if (index<0 || index>size){
            throw new IllegalArgumentException("index out of bounds index"+index);
        }
    }

    /**
     * 添加元素到当前集合中的末尾
     * @param e 元素
     */
    public void addLast(E e){
        if (size==capacity){
            grow(capacity*2);
        }
        // 将元素e添加到size指向的索引位置
        elementsDatal[size] = e;
        // 维护一下size即可
        size++;
    }

    /**
     * 查看当前集合是否为空
     * @return 判断size是否为空
     */
    public boolean isEmpty(){
        return size == 0;
    }

    /**
     * 查询当前集合中的元素个数
     * @return 返回size
     */
    public int getSize(){
        return size;
    }

    @Override
    public String toString(){
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("size:"+size+"{");
        for (int i = 0; i < size; i++) {
            stringBuilder.append(elementsDatal[i]);
            if (i!=size-1){
                stringBuilder.append(",");
            }
        }
        stringBuilder.append("} capacity:"+capacity);
        return stringBuilder.toString();
    }
}
鲸落ж
关注
专栏目录
自己写一个简单的ArrayList
humian151的博客
09-27 1708
自己通过写一个简单的SimpleArrayList来加深对JDK源码中的ArrayList的理解。 构造器 如果没有对集合设定长度，这里我们默认采取长度为10作为内置数组的初始化长度。 public SimpleArrayList() { this(DEFAULT_SIZE); } public SimpleArrayList(int size) {
反向遍历 java_基于ArrayList编写支持反向遍历的List
weixin_28956753的博客
02-20 1072
一、概述List遍历是我们经常会使用到的一个功能，很多时候我们也会用到反向遍历，在用到反向遍历时我们常用的方法是通过for循环或者是对List反向排序来完成相应的操作，像下面代码这样：方法1:for(int i = list.size()-1; i>=0; i--) {System.out.println(list.get(i));}这个方法开上去就比较臃肿，写起来也相对繁琐一些。方法2:C...
ArrayList类的简单编写
chaoliao2466的博客
09-05 301
　　ArrayList类　　编写ArrayList类　　package com.mage.arrays;　　public class ArrayList {　　private Object[] arrs;　　private int size; //数组实际存储元素个数　　private int capacity;//底层arrs数组的长度,也就是开的内存空间大小　　priva...
ArrayList基本写法
dingzhimang0206的博客
09-21 612
1.ArrayList基本数据包装类写法 　　　　ArrayList<数据类型>名字=new ArrayList<数据类型>(;) (1)ArrayList 可以用向集合ArrayList当中存储基本类型数据，必须使用基本类型对应的“包装类”。 　　基本类型 包装类（引用类型，包装类都位于java.lang包下...
java ArrayList集合类的书写
wilver的博客
08-30 2535
java中的ArrayList的书写还是比较容易些的，所以就写了一遍import java.util.Arrays; import java.util.ConcurrentModificationException; import java.util.Iterator; import java.util.NoSuchElementException;public class ArrayListsw
ArrayList源码是怎么写的,什么意思
weixin_39694434的博客
09-18 140
原文出处:小小知行者(https://www.cnblogs.com/gxl1995/p/7534171344218b3784f1beb90d621337.html) public class ArrayList extends AbstractList implements List, RandomAccess, Cloneable, java.io.Serializable { /** * 序...
Java数据结构之基于ArrayList编写大众麻将和扑克牌洗牌小练习
我的主页
03-31 1293
本期讲解：二维数组、二维顺序表实现大众麻将洗牌、扑克牌洗牌小程序。
使用ArrayList编写Java程序：使用下面的方法头编写一个方法，从字符串中返回一个Character 的数组列表。 public static ArrayList<Character>toCharacterArray(String s) 例如,toCharacterArray("abc")返回一个包含字符'a'、'b'和'c'的数组列表。
最新发布
05-27
好的，这是一个使用ArrayList实现的toCharacterArray方法的示例代码： ```java import java.util.ArrayList; public class Main { public static void main(String[] args) { String s = "abc"; ArrayList...
MiniLab：用于排序，数组，ArrayList，编写类的研究项目
02-19
MiniLab 是一个专门为学习和研究Java编程语言中的排序算法、数组操作、ArrayList使用以及类的编写而设计的项目。这个项目旨在帮助初学者和有一定经验的开发者深化对这些核心概念的理解，通过实践来巩固理论知识。 1...
14--ArrayList相关习题
qq_44787898的博客
06-18 937
第一题 键盘录入学生信息，保存到集合中。 循环录入的方式，1：表示继续录入，0：表示结束录入。 定义学生类，属性为姓名，年龄，使用学生对象保存录入数据。 使用ArrayList集合，保存学生对象，录入结束后，遍历集合。 代码实现，效果如图所示： 参考答案： public class Test1 { public static void main(String[] args) { Scanner scanner = new Scanner(System.in);
手写ArrayList，LinkedList
smile_juan
02-19 2388
虽然学习Java很长时间了，但是对数据结构一直很痛恨，更何况手写Collections之类的了，这次实在是没办法，所以看看书，上网看看别人怎么写的，扒了过来了，记个笔记方便以后复习，\(^o^)/~ ArrayList是比较好写，比较容易看懂的...... package com.juan; public class MyArrayList{          private s
如何手写一个ArrayList
Kerwin的博客
09-17 5503
写完HashMap，觉得手痒痒，所以隔了一天再来实现一下简单的ArrayList，ArrayList相比而言就非常的简单，主要的核心点有以下几个方面： 1.ArrayList的底层是由数组构成的 2.添加时需要考虑扩容问题 3.对于index索引的操作，需要考虑到下标不合法的异常 4.remove操作的时候，需要一点数学知识进行一下逻辑操作 下面贴出我的代码: MyList接口: ...
ArrayList的简单实现（手写）
L-Study
07-03 3538
对着源码改的，还有一些方法没有添加，后续有时间再实现直接上代码：/** * 1.ArrayList的简单实现（手写） * 2.包括以下方法： * int size(); * MyArrayList(); * MyArrayList(int initialCapacity); * boo
手写一个简单的ArrayList
weixin_43031156的博客
10-31 778
定义接口 package com.lzq.ArrayList; public interface List<E> { //获取实际储存内容的大小 int size(); //判断数组实际储存内容是否为空 boolean isEmpty(); //往数组中添加内容 void add(E e); //取数据 E get(int index); //删除 boolean remove(int index); } .
手写代码：ArrayList
lydms的博客
02-08 3173
1、创建、添加、tostring方法 具体增加方法： 1、创建默认大小为10的数组 2、创建指定大小的数组 3、添加元素 4、打印数组内容 代码： public class MyArrayList<E> { private Object[] elementData; private int size; private static final int DEFA...
数组集合ArrayList编写
weixin_43564728的博客
03-15 164
java种的ArrayList 底层就是使用数组进行存储，这里就为大家示范一下，其他细节读者可以自己再去填补！ 读者可以自己添加泛型进行处理。 package ArrayListWZF; import java.util.Arrays; public class MyArrayList { //集合初始化容量 private static final int CAPACITY = 10; private static final Object[] EMPTY_EL..
java编程--ArrayList详解
longdui123的博客
04-05 204
一，ArrayList的使用(允许定义重复有序的集合) public class TestDemo{ public static void main(String[] args){ List<String> list = new ArrayList<String>(); //插入元素 list.add("123"); list.add("456"); ...
Java笔记（ArrayList、简单的项目写法规则）
you__jing的博客
03-31 152
/** * ArrayList * 简单的项目写法规则 */ 1.ArrayList 集合 1.1 泛型（Object）的集合，可以装任何类型的数据 ArrayList list = new ArrayList(); 1.2 往集合中存入元素 list.add(1); list.add("2"); list.add("2"); 1.3 按下标存入元素 list.add(3, true); 1.4 不会把原有的数据覆盖掉,而是在该下标处插入该元素 list.
应用列表ArrayList 编写程序,存储学生的学号,姓名,计算机,数学,英语,三门课程
05-18
import java.util.ArrayList; public class Student { private int id; private String name; private double computerScore; private double mathScore; private double englishScore; public Student(int ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值