手写动态数组ArrayList，帮你彻底弄明白ArrayList的实现原理

最新推荐文章于 2021-12-26 15:06:25 发布
最新推荐文章于 2021-12-26 15:06:25 发布
阅读量255 收藏 2
点赞数 1
分类专栏： 数据结构和算法 文章标签： java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_37778801/article/details/105906856
版权

数组基础

概念

所谓数组，是有序的元素序列。数组是在程序设计中，为了处理方便， 把具有相同类型的若干元素按有序的形式组织起来的一种形式。这些有序排列的同类数据元素的集合称为数组。

数组是用于储存多个相同类型数据的集合。数组本身是静态的，在创建的时候，就必须要指定它的大小。

图解

代码演示：

package com.ldc.datastructures.array;

public class Main {
    public static void main(String[] args) {
        //第一种声明的方式
        int[] arr = new int[20];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i;
        }

        //第二种声明的方式
        int[] scores = new int[]{100, 99, 66};
        for (int i = 0; i < scores.length; i++) {
            System.out.println(scores[i]);
        }

        scores[0] = 98;
        for (int score : scores) {
            System.out.println(score);
        }
    }
}

基于Java数组手动实现动态数组

图解分析

二次封装数组

package com.ldc.datastructures.array;

/**
 * @author lengdongcheng
 * @date 2020-05-03 12:02
 */
public class Array {

    /**
     * 数组存放的元素
     */
    private int[] data;

    /**
     * 在数组中元素的个数，也即跟下标索引相对应
     */
    private int size;

    /**
     * 默认的构造函数，调用public Array(int capacity){...}来进行构造
     * 默认数组的容量capacity=10
     */
    public Array() {
        this(10);
    }

    /**
     * 构造函数,用传入参数capacity作为数组的容量来构造数组
     * @param capacity 容量
     */
    public Array(int capacity) {
        data = new int[capacity];
        size = 0;
    }

    /**
     * 获取数组中元素的个数
     * @return
     */
    public int getSize(){
        return size;
    }

    /**
     * 获取数组的容量
     * @return
     */
    public int getCapacity(){
        return data.length;
    }

    /**
     * 返回数组是否为空
     * @return
     */
    public boolean isEmpty(){
        return size == 0;
    }
}

向数组中添加元素

在数组的末尾添加元素

图解

我们只需要在数组的末尾添加元素，然后维护一下size即可

代码演示

    /**
     * 在数组的末尾添加元素
     * @param e
     */
    public void addLast(int e) {
        //如果数组的个数已经等于数组的容量，那么需要抛出异常
        if (size == data.length) {
            throw new IllegalArgumentException("AddLast failed.Array is full.");
        }
        data[size] = e;
        size++;
    }

在数组中指定的位置添加元素

图解

  1. 将索引为1以及索引为1后面的元素整体向后移，并且是将元素从最后面的元素开始移，不然会将数据覆盖：

  1. 将元素66插入到索引为1的位置

  1. 维护size，将size向后移一位

代码演示

这个时候，也可以把在末尾添加元素的方法进行修改，直接调用add方法

    /**
     * 在数组的末尾添加元素
     *
     * @param e
     */
    public void addLast(int e) {
        //如果数组的个数已经等于数组的容量，那么需要抛出异常
        add(size, e);
    }

    /**
     * 在数组中第index的位置添加元素
     * @param e
     */
    public void add(int index, int e) {
        //如果数组的个数已经等于数组的容量，那么需要抛出异常
        if (size == data.length) {
            throw new IllegalArgumentException("Add failed.Array is full.");
        }
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Add failed.index < 0 || index > size.");
        }

        //从要插入的位置到最后一个元素，都要向后挪一个位置，并且是从最后一个元素开始挪
        for (int i = size - 1; i >= index; i--) {
            //将后一个位置赋上前一个位置的元素
            data[i + 1] = data[i];
        }
        //实际上index这个位置还是有元素的，只不过是将e元素把之前的元素给覆盖了
        data[index] = e;
        size++;
    }

}

在数组头部添加元素

    /**
     * 在数组的头部添加元素
     *
     * @param e
     */
    public void addFirst(int e) {
        add(0, e);
    }

    /**
     * 在数组中第index的位置添加元素
     * @param e
     */
    public void add(int index, int e) {
        //如果数组的个数已经等于数组的容量，那么需要抛出异常
        if (size == data.length) {
            throw new IllegalArgumentException("Add failed.Array is full.");
        }
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Add failed.index < 0 || index > size.");
        }

        //从要插入的位置到最后一个元素，都要向后挪一个位置，并且是从最后一个元素开始挪
        for (int i = size - 1; i >= index; i--) {
            //将后一个位置赋上前一个位置的元素
            data[i + 1] = data[i];
        }
        //实际上index这个位置还是有元素的，只不过是将e元素把之前的元素给覆盖了
        data[index] = e;
        size++;
    }

}

向数组中查询元素和修改元素

向数组中查询元素和修改元素以及重写了toString方法

代码演示

    /**
     * 获取index索引位置的元素
     * @param index
     * @return
     */
    public int get(int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("get failed.index is illegal.");
        }
        return data[index];
    }

    /**
     * 修改index索引位置的元素
     * @param index
     * @return
     */
    public void set(int index,int e) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("set failed.index is illegal.");
        }
        data[index] = e;
    }

    /**
     * 重写toString方法
     * @return
     */
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append(String.format("Array: size = %d , capacity = %d \n", size, data.length));
        sb.append('[');
        for (int i = 0; i < size; i++) {
            sb.append(data[i]);
            if (i != size - 1) {
                sb.append(", ");
            }
        }
        sb.append(']');
        return sb.toString();
    }
}

删除数组中的元素

查看数组中是否包含某一个元素

    /**
     * 查找数组中是否包含元素e
     * @param e
     * @return
     */
    public boolean contains(int e) {
        for (int i = 0; i < size; i++) {
            if (data[i] == e) {
                return true;
            }
        }
        return false;
    }

查看数组中是否包含某一个元素

    /**
     * 查找数组中元素e所在的位置，如果不存在元素e，则返回-1
     * @param e
     * @return
     */
    public int find(int e) {
        for (int i = 0; i < size; i++) {
            if (data[i] == e) {
                return i;
            }
        }
        return -1;
    }

从数组中删除元素

图解

  1. 将指定位置后面的元素都向前挪一位

2. 维护size

这样size就指向了删除前最后一个元素，这样并不会有什么问题，

代码演示

    /**
     * 从数组中删除index位置的元素，并返回被删除的元素
     * @param index
     * @return
     */
    public int remove(int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("remove failed.index is illegal.");
        }
        int ret = data[index];

        //index后面的元素都向前挪一位
        for (int i = index+1; i < size; i++) {
            data[i - 1] = data[i];
        }
        //维护一下size
        size--;
        return ret;
    }

    /**
     * 从数组中删除第一个元素，并返回
     * @return
     */
    public int removeFirst() {
        return remove(0);
    }

    /**
     * 从数组中删除最后一个元素，并返回
     * @return
     */
    public int removeLast() {
        return remove(size - 1);
    }
    
        /**
     * 从数组中删除元素e
     * @param e
     */
    public void removeElement(int e) {
        int index = find(e);
        if (index != -1) {
            remove(index);
        }
    }

整体代码

package com.ldc.datastructures.array;

/**
 * @author lengdongcheng
 * @date 2020-05-03 12:02
 */
public class Array {

    /**
     * 数组存放的元素
     */
    private int[] data;

    /**
     * 在数组中元素的个数，也即跟下标索引相对应
     */
    private int size;

    /**
     * 默认的构造函数，调用public Array(int capacity){...}来进行构造
     * 默认数组的容量capacity=10
     */
    public Array() {
        this(10);
    }

    /**
     * 构造函数,用传入参数capacity作为数组的容量来构造数组
     *
     * @param capacity 容量
     */
    public Array(int capacity) {
        data = new int[capacity];
        size = 0;
    }

    /**
     * 查找数组中是否包含元素e
     * @param e
     * @return
     */
    public boolean contains(int e) {
        for (int i = 0; i < size; i++) {
            if (data[i] == e) {
                return true;
            }
        }
        return false;
    }

    /**
     * 从数组中删除index位置的元素，并返回被删除的元素
     * @param index
     * @return
     */
    public int remove(int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("remove failed.index is illegal.");
        }
        int ret = data[index];

        //index后面的元素都向前挪一位
        for (int i = index+1; i < size; i++) {
            data[i - 1] = data[i];
        }
        //维护一下size
        size--;
        return ret;
    }

    /**
     * 从数组中删除元素e
     * @param e
     */
    public void removeElement(int e) {
        int index = find(e);
        if (index != -1) {
            remove(index);
        }
    }

    /**
     * 从数组中删除第一个元素，并返回
     * @return
     */
    public int removeFirst() {
        return remove(0);
    }

    /**
     * 从数组中删除最后一个元素，并返回
     * @return
     */
    public int removeLast() {
        return remove(size - 1);
    }


    /**
     * 查找数组中元素e所在的位置，如果不存在元素e，则返回-1
     * @param e
     * @return
     */
    public int find(int e) {
        for (int i = 0; i < size; i++) {
            if (data[i] == e) {
                return i;
            }
        }
        return -1;
    }

    /**
     * 获取数组中元素的个数
     *
     * @return
     */
    public int getSize() {
        return size;
    }

    /**
     * 获取数组的容量
     *
     * @return
     */
    public int getCapacity() {
        return data.length;
    }

    /**
     * 返回数组是否为空
     *
     * @return
     */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * 在数组的末尾添加元素
     *
     * @param e
     */
    public void addLast(int e) {
        add(size, e);
    }

    /**
     * 在数组的头部添加元素
     *
     * @param e
     */
    public void addFirst(int e) {
        add(0, e);
    }

    /**
     * 在数组中第index的位置添加元素
     *
     * @param e
     */
    public void add(int index, int e) {
        //如果数组的个数已经等于数组的容量，那么需要抛出异常
        if (size == data.length) {
            throw new IllegalArgumentException("Add failed.Array is full.");
        }
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Add failed.index < 0 || index > size.");
        }

        //从要插入的位置到最后一个元素，都要向后挪一个位置，并且是从最后一个元素开始挪
        for (int i = size - 1; i >= index; i--) {
            //将后一个位置赋上前一个位置的元素
            data[i + 1] = data[i];
        }
        //实际上index这个位置还是有元素的，只不过是将e元素把之前的元素给覆盖了
        data[index] = e;
        size++;
    }

    /**
     * 获取index索引位置的元素
     * @param index
     * @return
     */
    public int get(int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("get failed.index is illegal.");
        }
        return data[index];
    }

    /**
     * 修改index索引位置的元素
     * @param index
     * @return
     */
    public void set(int index,int e) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("set failed.index is illegal.");
        }
        data[index] = e;
    }

    /**
     * 重写toString方法
     * @return
     */
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append(String.format("Array: size = %d , capacity = %d \n", size, data.length));
        sb.append('[');
        for (int i = 0; i < size; i++) {
            sb.append(data[i]);
            if (i != size - 1) {
                sb.append(", ");
            }
        }
        sb.append(']');
        return sb.toString();
    }
}

使用泛型进行优化

使用泛型让我们的数据结构可以放置"任意"的数据类型（泛型是不支持基本的数据类型，只能是类对象）

package com.ldc.datastructures.array;

/**
 * @author lengdongcheng
 * @date 2020-05-03 12:02
 */
public class Array<E> {

    /**
     * 数组存放的元素
     */
    private E[] data;

    /**
     * 在数组中元素的个数，也即跟下标索引相对应
     */
    private int size;

    /**
     * 默认的构造函数，调用public Array(int capacity){...}来进行构造
     * 默认数组的容量capacity=10
     */
    public Array() {
        this(10);
    }

    /**
     * 构造函数,用传入参数capacity作为数组的容量来构造数组
     *
     * @param capacity 容量
     */
    public Array(int capacity) {
        data = (E[]) new Object[capacity];
        size = 0;
    }

    /**
     * 查找数组中是否包含元素e
     * @param e
     * @return
     */
    public boolean contains(E e) {
        for (int i = 0; i < size; i++) {
            if (data[i].equals(e)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 从数组中删除index位置的元素，并返回被删除的元素
     * @param index
     * @return
     */
    public E remove(int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("remove failed.index is illegal.");
        }
        E ret = data[index];

        //index后面的元素都向前挪一位
        for (int i = index+1; i < size; i++) {
            data[i - 1] = data[i];
        }
        //维护一下size
        size--;
        //loitering Object
        data[size] = null;
        return ret;
    }

    /**
     * 从数组中删除元素e
     * @param e
     */
    public void removeElement(E e) {
        int index = find(e);
        if (index != -1) {
            remove(index);
        }
    }

    /**
     * 从数组中删除第一个元素，并返回
     * @return
     */
    public E removeFirst() {
        return remove(0);
    }

    /**
     * 从数组中删除最后一个元素，并返回
     * @return
     */
    public E removeLast() {
        return remove(size - 1);
    }


    /**
     * 查找数组中元素e所在的位置，如果不存在元素e，则返回-1
     * @param e
     * @return
     */
    public int find(E e) {
        for (int i = 0; i < size; i++) {
            if (data[i].equals(e)) {
                return i;
            }
        }
        return -1;
    }

    /**
     * 获取数组中元素的个数
     *
     * @return
     */
    public int getSize() {
        return size;
    }

    /**
     * 获取数组的容量
     *
     * @return
     */
    public int getCapacity() {
        return data.length;
    }

    /**
     * 返回数组是否为空
     *
     * @return
     */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * 在数组的末尾添加元素
     *
     * @param e
     */
    public void addLast(E e) {
        add(size, e);
    }

    /**
     * 在数组的头部添加元素
     *
     * @param e
     */
    public void addFirst(E e) {
        add(0, e);
    }

    /**
     * 在数组中第index的位置添加元素
     *
     * @param e
     */
    public void add(int index, E e) {
        //如果数组的个数已经等于数组的容量，那么需要抛出异常
        if (size == data.length) {
            throw new IllegalArgumentException("Add failed.Array is full.");
        }
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Add failed.index < 0 || index > size.");
        }

        //从要插入的位置到最后一个元素，都要向后挪一个位置，并且是从最后一个元素开始挪
        for (int i = size - 1; i >= index; i--) {
            //将后一个位置赋上前一个位置的元素
            data[i + 1] = data[i];
        }
        //实际上index这个位置还是有元素的，只不过是将e元素把之前的元素给覆盖了
        data[index] = e;
        size++;
    }

    /**
     * 获取index索引位置的元素
     * @param index
     * @return
     */
    public E get(int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("get failed.index is illegal.");
        }
        return data[index];
    }

    /**
     * 修改index索引位置的元素
     * @param index
     * @return
     */
    public void set(int index,E e) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("set failed.index is illegal.");
        }
        data[index] = e;
    }

    /**
     * 重写toString方法
     * @return
     */
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append(String.format("Array: size = %d , capacity = %d \n", size, data.length));
        sb.append('[');
        for (int i = 0; i < size; i++) {
            sb.append(data[i]);
            if (i != size - 1) {
                sb.append(", ");
            }
        }
        sb.append(']');
        return sb.toString();
    }
}

动态数组的实现

图解

  1. 新开辟一个空间，然后将数组中的数据拷贝到新的数组

  2. 将数组中的数据拷贝到新的数组

3. 将原数组的变量data指向新数组的地址空间

  1. 这样，就相当于进行了扩容

代码实现

     /**
     * 在数组中第index的位置添加元素
     *
     * @param e
     */
    public void add(int index, E e) {
        //如果数组的个数已经等于数组的容量，那么需要抛出异常

        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Add failed.index < 0 || index > size.");
        }
        //扩容
        if (size == data.length) {
            resize(2 * data.length);
        }

        //从要插入的位置到最后一个元素，都要向后挪一个位置，并且是从最后一个元素开始挪
        for (int i = size - 1; i >= index; i--) {
            //将后一个位置赋上前一个位置的元素
            data[i + 1] = data[i];
        }
        //实际上index这个位置还是有元素的，只不过是将e元素把之前的元素给覆盖了
        data[index] = e;
        size++;
    }
  
    /**
     * 进行扩容
     * @param newCapacity
     */
    private void resize(int newCapacity) {
        E[] newData = (E[]) new Object[newCapacity];
        for (int i = 0; i < size; i++) {
            newData[i] = data[i];
        }
        data = newData;
    }
    
        /**
     * 从数组中删除index位置的元素，并返回被删除的元素
     * @param index
     * @return
     */
    public E remove(int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("remove failed.index is illegal.");
        }
        E ret = data[index];

        //index后面的元素都向前挪一位
        for (int i = index+1; i < size; i++) {
            data[i - 1] = data[i];
        }
        //维护一下size
        size--;
        //loitering Object
        data[size] = null;
        //缩容
        if (size == data.length / 2) {
            resize(data.length / 2);
        }
        return ret;
    }

动态数组完整代码

package com.ldc.datastructures.array;

/**
 * @author lengdongcheng
 * @date 2020-05-03 12:02
 */
public class Array<E> {

    /**
     * 数组存放的元素
     */
    private E[] data;

    /**
     * 在数组中元素的个数，也即跟下标索引相对应
     */
    private int size;

    /**
     * 默认的构造函数，调用public Array(int capacity){...}来进行构造
     * 默认数组的容量capacity=10
     */
    public Array() {
        this(10);
    }

    /**
     * 构造函数,用传入参数capacity作为数组的容量来构造数组
     *
     * @param capacity 容量
     */
    public Array(int capacity) {
        data = (E[]) new Object[capacity];
        size = 0;
    }

    /**
     * 查找数组中是否包含元素e
     * @param e
     * @return
     */
    public boolean contains(E e) {
        for (int i = 0; i < size; i++) {
            if (data[i].equals(e)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 从数组中删除index位置的元素，并返回被删除的元素
     * @param index
     * @return
     */
    public E remove(int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("remove failed.index is illegal.");
        }
        E ret = data[index];

        //index后面的元素都向前挪一位
        for (int i = index+1; i < size; i++) {
            data[i - 1] = data[i];
        }
        //维护一下size
        size--;
        //loitering Object
        data[size] = null;
        //缩容
        if (size == data.length / 2) {
            resize(data.length / 2);
        }
        return ret;
    }

    /**
     * 从数组中删除元素e
     * @param e
     */
    public void removeElement(E e) {
        int index = find(e);
        if (index != -1) {
            remove(index);
        }
    }

    /**
     * 从数组中删除第一个元素，并返回
     * @return
     */
    public E removeFirst() {
        return remove(0);
    }

    /**
     * 从数组中删除最后一个元素，并返回
     * @return
     */
    public E removeLast() {
        return remove(size - 1);
    }


    /**
     * 查找数组中元素e所在的位置，如果不存在元素e，则返回-1
     * @param e
     * @return
     */
    public int find(E e) {
        for (int i = 0; i < size; i++) {
            if (data[i].equals(e)) {
                return i;
            }
        }
        return -1;
    }

    /**
     * 获取数组中元素的个数
     *
     * @return
     */
    public int getSize() {
        return size;
    }

    /**
     * 获取数组的容量
     *
     * @return
     */
    public int getCapacity() {
        return data.length;
    }

    /**
     * 返回数组是否为空
     *
     * @return
     */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * 在数组的末尾添加元素
     *
     * @param e
     */
    public void addLast(E e) {
        add(size, e);
    }

    /**
     * 在数组的头部添加元素
     *
     * @param e
     */
    public void addFirst(E e) {
        add(0, e);
    }

    /**
     * 在数组中第index的位置添加元素
     *
     * @param e
     */
    public void add(int index, E e) {
        //如果数组的个数已经等于数组的容量，那么需要抛出异常

        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Add failed.index < 0 || index > size.");
        }
        //扩容
        if (size == data.length) {
            resize(2 * data.length);
        }

        //从要插入的位置到最后一个元素，都要向后挪一个位置，并且是从最后一个元素开始挪
        for (int i = size - 1; i >= index; i--) {
            //将后一个位置赋上前一个位置的元素
            data[i + 1] = data[i];
        }
        //实际上index这个位置还是有元素的，只不过是将e元素把之前的元素给覆盖了
        data[index] = e;
        size++;
    }

    /**
     * 进行扩容
     * @param newCapacity
     */
    private void resize(int newCapacity) {
        E[] newData = (E[]) new Object[newCapacity];
        for (int i = 0; i < size; i++) {
            newData[i] = data[i];
        }
        data = newData;
    }

    /**
     * 获取index索引位置的元素
     * @param index
     * @return
     */
    public E get(int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("get failed.index is illegal.");
        }
        return data[index];
    }

    /**
     * 修改index索引位置的元素
     * @param index
     * @return
     */
    public void set(int index,E e) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("set failed.index is illegal.");
        }
        data[index] = e;
    }

    /**
     * 重写toString方法
     * @return
     */
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append(String.format("Array: size = %d , capacity = %d \n", size, data.length));
        sb.append('[');
        for (int i = 0; i < size; i++) {
            sb.append(data[i]);
            if (i != size - 1) {
                sb.append(", ");
            }
        }
        sb.append(']');
        return sb.toString();
    }
}

测试案例

package com.ldc.datastructures.array;

public class Main {
    public static void main(String[] args) {
        Array<Integer> arr = new Array<>(10);
        for (int i = 0; i < 15; i++) {
            arr.addLast(i);
        }
        System.out.println(arr);

        arr.add(1,100);
        System.out.println(arr);

        arr.remove(2);
        System.out.println(arr);
    }
}

  • 运行结果如下：可以看出已经实现了扩容

“

Array: size = 15 , capacity = 20 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14] Array: size = 16 , capacity = 20 [0, 100, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14] Array: size = 15 , capacity = 20 [0, 100, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

让优秀成为你的习惯
关注
专栏目录
Java 手写一个动态数组
法毅的博客
10-31 305
public class Array<E> { private E[] data; // 有效元素个数 private int size; /** * 构造函数，传入数组容量capacity构造Array * @param capacity */ public Array(int capacity){ data = (E[])new Object[capacity]; size = 0; .
金三银四跳槽季，java面试突击（100题）进大厂就这么简单
m0_67788957的博客
03-22 889
1、谈谈对面向对象思想的理解 首先，谈谈“面向过程”vs“面向对象” 我觉得这两者是思考角度的差异，面向过程更多是以“执行者”的角度来思考问题，而面向对象更多是以“组织者”的角度来思考问题，举个例子，比如我要产生一个0-10之间的随机数，如果以“面向过程”的思维，那我更多是关注如何去设计一个算法，然后保证比较均衡产生0-10的随机数，而面向对象的思维会更多关注，我找谁来帮我们做这件事，比如Random类，调用其中提供的方法即可。 所以，面向对象的思维更多的是考虑如何去选择合适的工具，然后组织到...
00019.02 手动实现动态数组（逻辑结构、ArrayList）
小良的博客
10-20 215
系列文章目录 文章目录系列文章目录前言一、pandas是什么？二、使用步骤总结 前言 一、pandas是什么？ 二、使用步骤 总结
ArrayList动态数组
qq_28781729的博客
03-06 349
1、什么是ArrayList ArrayList就是传说中的动态数组，用MSDN中的说法，就是Array的复杂版本，它提供了如下一些好处： 动态的增加和减少元素 实现了ICollection和IList接口 灵活的设置数组的大小 2、如何使用ArrayList 最简单的例子： ArrayList List = new ArrayList(); for( int i=0;i ...
Java——ArrayList（动态数组）介绍
华墨1024的博客
10-31 7466
本章节对ArrayList进行个简要的介绍，前面也写过一篇博客记录自己模拟实现ArrayList的情况。
手动实现ArrayList容器
qq_35810838的博客
05-31 160
手动实现ArrayList容器 1 package text; 2 3 import java.util.ArrayList; 4 import java.util.List; 5 6 public class SxtArrayList{ 7 private Object[] elementData...
手写.ArrayList 实现要求：包括add、get、size、indexOf、remove方法的实现。
最新发布
06-04
下面是手写 ArrayList 实现的代码： ```java public class ArrayList<E> { private static final int DEFAULT_CAPACITY = 10; private Object[] elementData; private int size; public ArrayList() { ...
29个要点帮你完成java代码优化
09-03
27. 使用`Arrays.copyOf()`替代手写的数组复制代码，以利用内置的优化。 28. 考虑使用Java 8的流API进行并行处理，充分利用多核处理器。 29. 性能测试和分析：使用工具如JProfiler或VisualVM监控和定位性能瓶颈。 ...
安卓系统层开发之C++
Gordon的博客
06-13 323
安卓系统层开发，职业生涯新起点。
69个经典安卓面试题和答案详解，赶紧收藏起来！
m0_57081438的博客
06-20 5867
一、java面试题 熟练掌握java是很关键的，大公司不仅仅要求你会使用几个api，更多的是要你熟悉源码实现原理，甚至要你知道有哪些不足，怎么改进，还有一些java有关的一些算法，设计模式等等。 （一） java基础面试知识点 java中==和equals和hashCode的区别 int、char、long各占多少字节数 int与integer的区别 谈谈对java多态的理解 String、StringBuffer、StringBuilder区别 什么是内部类？内部类的作用 抽象类和接口区别 抽象类的意义
手动实现动态数组二(java)
Batac的博客
04-18 214
package com.batac; /** * Author: Batac * 动态数组: * 数组: 是一种连续存储结构的线性表; * 优点: 查询速度快, 根据地址直接查找到元素(寻址法); * 缺点: 插入与删减元素速度差, 最差需要移动其他所有元素 */ public class ArrayList<E> { //数组 private E[]...
java核心技术学习笔记9---动态数组的ArrayList实现
busy50的专栏
12-01 868
ArrayList类 在JDK5.0以中，ArrayList是一个采用类型参数的泛型类。JDK5.0以前，java没有泛型类，只有一个ArrayList类，其中保存的类型是Object类型的元素，它是“自适应大小”的集合。java老版本中程序员用Vector类实现动态数组，不过ArrayList更加有效。 数组列表管理着对象引用的一个内部数组。 数组的全部容量有可能被用尽。如果调用add且内
栈的实现
weixin_34381666的博客
12-22 111
2019独角兽企业重金招聘Python工程师标准>>> ...
手动实现arrayList底层源码
痛哭流涕，痛定思痛
08-10 111
我尝试了写出集合中arraylist的实现，比较有趣，可以作为复习知识点，来练习 package 手工实现; import javax.management.RuntimeErrorException; public class TestArrayList1<E> { // 需要 // 添加方法，setget方法，tostring方法，remove方法 // 数组扩容 priva...
Java手写动态数组（1）
weixin_30480651的博客
11-13 76
public class Array { private int[] data; private int size; public Array(int capacity) { data = new int[capacity]; size =0; } public Array () { th...
java怎样定义动态数组_java如何手写动态数组？实例代码展示
weixin_35639230的博客
02-27 1266
自从21世纪以来。科学技术水平高速发展，这也促使了新兴技术的不断发展与壮大。越来越多的人开始投入到新技术的学习当中来。其中java的学习则是更多人的选择。今天就为大家介绍一下java如何手写动态数组，并用实际代码展示。一起来看看吧。首先说一下注意事项。1.在定义增量时，不要定义成一个固定的值，每次扩充一定比例。2.比例不是越大越好，也要考虑到内存问题，所以取个合适的值就行。3. 在Array中的s...
ArrayList动态数组底层封装分析
派拉斯兔子的博客
10-21 342
动态数组 1、什么是数据结构？ 数据结构是计算机存储、组织数据的方式 2、线性表 线性表是具有 n 个相同类型元素的有限序列（ n ≥ 0 ） 常见的线性表有 ①、数组 ②、链表 ③、栈 ④、队列 ⑤、哈希表（散列表） 3、数组（Array） 数组是一种顺序存储的线性表，所有元素的内存地址是连续的 4、动态数组（Dynamic Array）接口设计 int size(); // 元素的数量 boolean isEmpty(); // 是否为空 boolean contains(E
【恋上数据结构】手写ArrayList + Java动态扩容分析
Javaer
12-26 601
Gitee同步更新代码和笔记： 文章目录一、ArrayList动态扩容分析泛型分析手写ArrayListJDK源码分析 一、ArrayList 动态扩容分析 在Java中，由于数组的大小是固定的，所以扩容会申请一个更大的数组，然后把引用指向新的数组。 代码实现： /** * 保证要有capacity的容量(elements数组的长度) * @param capacity */ private void ensureCapacity(int capac
java动态数组输入_java中如何使用动态数组?代码示例
weixin_30199299的博客
02-21 1651
关于java动态数组你都了解多少呢?那么具体的来说java当中应该怎样使用动态数组呢?下面来看一下代码详例吧。首先我们要搞清楚，java动态数组是一种能够任意伸缩数组长度的对象，在java当中，我们经常使用的就是ArrayList。之前有给大家介绍过关于java动态数组arraylist该如何使用的问题，具体的可以去了解一下-java动态数组arraylist该如何使用?什么是arraylist?...
c#动态数组arraylist增删改查底层实现
03-16
C#中的动态数组ArrayList是通过数组实现的，其底层实现包括以下几个方面： 1. 增加元素：当向ArrayList中添加元素时，如果当前数组已满，则会创建一个新的数组，并将原数组中的元素复制到新数组中，然后再将新元素...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值