数组容器(ArrayList)设计与Java实现，看完这个你不懂ArrayList，你找我！！！

已于 2022-07-08 14:50:43 修改
阅读量181 收藏
点赞数
分类专栏： 容器设计与实现 算法 文章标签： java 数据结构 算法 容器
于 2022-07-06 22:55:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45537774/article/details/125649418
版权

数组容器(ArrayList)设计与Java实现

本篇文章主要跟大家介绍我们最常使用的一种容器ArrayList、Vector的原理，并且自己使用Java实现自己的数组容器MyArrayList，让自己写的容器能像ArrayList那样工作。在本篇文章当中首先介绍ArrayList的一些基本功能，然后去分析我们自己的容器MyArrayList应该如何进行设计，同时分析我们自己的具体实现方法，最后进行代码介绍！！！

ArrayList为我们提供了哪些功能？

我们来看一个简单的代码，随机生成100个随机数，查看生成随机数当中是否存在50这个数。

public class MyArrayList {

  public static void main(String[] args) {
    Random random = new Random();
    ArrayList<Integer> list = new ArrayList<>();
    for (int i = 0; i < 100; i++) {
      list.add(random.nextInt(5000));
    }
    for (int i = 0; i < 100; i++) {
      if (list.get(i) == 50) {
        System.out.println("包含数据 50");
      }
    }
    list.set(5, 1000);// 设置下标为5的数据为100
    list.remove(5);// 删除下标为5的数据
    list.remove(new Integer(888));// 删除容器当中的第一个值为5的数据
  }
}

上述代码包含了ArrayList最基本的一个功能，一个是add方法，向数组容器当中加入数据，另外一个方法是get从容器当中拿出数据，set方法改变容器里的数据，remove方法删除容器当中的数据。ArrayList的很多其他的方法都是围绕这四个最基本的方法展开的，因此我们在这里不仔细介绍其他的方法了，后面我们自己实现的时候遇到问题的时候自然会需要设计相应的方法，然后我们进行解决即可。

现在我们就需要去设计一个数组容器实现“增删改查”这四个基本功能。

设计原理分析

首先明白一点我们需要使用什么工具去实现这样一个容器。我们手里有的工具就是Java提供给我们的最基本的功能——数组（这个好像是废话，我们的标题就是数组容器🤣）。

当我们在Java当中使用数组去存储数据时，数据在Java当中的内存布局大致如下图所示。

我们在设计数组容器这样一个数据结构的时候主要会遇到两个问题：

  • 我们申请数组的长度是多少。
  • 当数组满了之后怎么办，也就是我们的扩容机制。

对于这两个问题，首先我们数组的初始大小可以有默认值，在我们自己实现的MyArrayList当中设置为10，我们在使用类时也可以传递一个参数指定初始大小。第二个问题当我们的数组满的时候我们需要对数组进行扩容，在我们实现的MyArrayList当中我们采取的方式是，新数组的长度是原数组的两倍（这个跟JDK的ArrayList方式不一样，ArrayList扩容为原来的1.5倍）。

代码实现

为了让我们的类实现的更加简单我们在代码当中就不做很多非必要的逻辑判断并且抛出异常，我们的代码只要能表现出我们的思想即可。

  • 首先定义一个接口MyCollection，表示我们要实现哪些方法！
public interface MyCollection<E> {

  /**
   * 往链表尾部加入一个数据
   * @param o 加入到链表当中的数据
   * @return
   */
  boolean add(E o);

  /**
   * 表示在第 index 位置插入数据 o
   * @param index
   * @param o
   * @return
   */
  boolean add(int index, E o);

  /**
   * 从链表当中删除数据 o
   * @param o
   * @return
   */
  boolean remove(E o);

  /**
   * 从链表当中删除第 index 个数据
   * @param index
   * @return
   */
  boolean remove(int index);

  /**
   * 往链表尾部加入一个数据，功能和 add 一样
   * @param o
   * @return
   */
  boolean append(E o);

  /**
   * 返回链表当中数据的个数
   * @return
   */
  int size();

  /**
   * 表示链表是否为空
   * @return
   */
  boolean isEmpty();

  /**
   * 表示链表当中是否包含数据 o
   * @param o
   * @return
   */
  boolean contain(E o);

  /**
   * 设置下标为 index 的数据为 o
   * @param index
   * @param o
   * @return
   */
  boolean set(int index, E o);
}
  • 我们的构造函数，初始化过程。
  public MyArrayList(int initialCapacity) {
    this();
    // 增长数组的空间为 initialCapacity，即申请一个数组
    // 且数组的长度为 initialCapacity
    grow(initialCapacity); 
  }

  public MyArrayList() {
    this.size = 0; // 容器当中的数据个数在开始时为 0
    this.elementData = EMPTY_INSTANCE; // 将数组设置为空数组
  }
  • 我们需要实现的最复杂的方法就是add了，这个方法是四个方法当中最复杂的，其余的方法都相对比较简单。
    • 进入add方法之后，我们需要找到符合要求的最小数组长度，这个值通常是容器当中元素的个数size + 1 ，也就是图中的minCapacity首先先比较这个值和现在数组的长度，如果长度不够的话则需要进行扩容，将数组的长度扩大到原来的两倍。
    • 如果不需要扩容，则直接讲元素放入到数组当中即可。

  @Override
  public boolean add(E o) {
    // 这个函数的主要作用就是确保数组的长度至少为 size + 1
    ensureCapacity(size + 1);
    // 新增加了一个数据，容器的大小需要 + 1
    elementData[++size] = o;
    return true;
  }

  /**
   * 这个函数的主要作用就是确保数组的长度至少为 capacity
   * @param capacity
   */
  public void ensureCapacity(int capacity) {
    int candidateCapacity = findCapacity(capacity);
    if (elementData.length < candidateCapacity)
      grow(candidateCapacity);
  }

  /**
   * 这个函数的主要目的就是找到最终数组长度需求的容量
   * @param minCapacity
   * @return
   */
  private int findCapacity(int minCapacity) {
    /**
     * 如果 if 条件为 true 即 elementData 还是初始化时设置的空数组
     * 那么返回默认大小和需要大小的最大值 
     * 否则直接返回 minCapacity
     */
    if (elementData == EMPTY_INSTANCE){
      return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
  }
  • 我们为什么需要将ensureCapacity的访问限制权限设置为public？因为我们想让用户尽量去使用这个函数，因为如果我们如果写出下面这样的代码我们会一直申请内存空间，然后也需要将前面的数组释放掉，会给垃圾回收器造成更大的压力。
    ArrayList<Integer> list = new ArrayList<>();
    for (int i = 0; i < 1000000; i++) {
      list.add(i);
    }

下面我们对ArrayList的方法进行测试：

import java.util.ArrayList;

class Person {

  String name;

  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }

  @Override
  public String toString() {
    return "Person{" +
        "name='" + name + '\'' +
        '}';
  }
}


public class ArrayListTest {

  public static void main(String[] args) {
    ArrayList<Person> o1 = new ArrayList<>();
    o1.ensureCapacity(10000000);
    long start = System.currentTimeMillis();
    for (int i = 0; i < 10000000; i++) {
      o1.add(new Person());
    }
    long end = System.currentTimeMillis();
    System.out.println("end - start: " + (end - start));
    ArrayList<Person> o2 = new ArrayList<>();
    start = System.currentTimeMillis();
    for (int i = 0; i < 10000000; i++) {
      o2.add(new Person());
    }
    end = System.currentTimeMillis();
    System.out.println("end - start: " + (end - start));
  }
}
// 输出结果
end - start: 1345
end - start: 4730

从上面的测试结果我们可以看出提前使用ensureCapacity方法之后，程序执行的时间更加短。

  • 插入数据的add方法。
  @Override
  public boolean add(E o) {
    // 这个函数的主要作用就是确保数组的长度至少为 size + 1
    ensureCapacity(size + 1);
    // 新增加了一个数据，容器的大小需要 + 1
    elementData[size] = o;
    size++;
    return true;
  }
  • add在指定下标插入数据。
    • 首先将插入下标后的数据往后移动一个位置
    • 然后在将数据放在指定下标的位置。

  /**
   * 在下标 index 位置插入数据 o
   * 首先先将 index 位置之后的数据往后移动一个位置
   * 然后将 index 赋值为 o
   * @param index
   * @param o
   * @return
   */
  @Override
  public boolean add(int index, E o) {
    // 确保容器当中的数组长度至少为 size + 1
    ensureCapacity(size + 1);
    // 将 elementData index位置之后的数据往后移动一个位置
    // 做一个原地拷贝
    System.arraycopy(elementData, index, elementData, index + 1,
        size - index); // 移动的数据个数为 size - index
    elementData[index] = o;
    size++;
    return true;
  }
  • 删除数据的方法remove。
    • 首先先删除指定下标的数据。
    • 然后将指定下标后的数据往前移动一个位置
    • 在实际的操作过程中我们可以不删除，直接移动，这样也覆盖被插入位置的数据了。

  /**
   * 移除下标为 index 的数据
   * @param index
   * @return
   */
  @Override
  public boolean remove(int index) {
    // 需要被移动的数据个数
    int numMoved = size - index - 1;
    if (numMoved > 0)
      System.arraycopy(elementData, index+1, elementData, index,
          numMoved);
    elementData[--size] = null;

    return true;
  }
  • 移除容器当中具体的某个对象。
  /**
   * 这个方法主要是用于溢出容器当中具体的某个数据
   * 首先先通过 for 循环遍历容器当中的每个数据，
   * 比较找到相同的数据对应的下标，然后通过下标移除方法
   * @param o
   * @return
   */
  @Override
  public boolean remove(E o) {
    if (o == null) {
      for (int index = 0; index < size; index++)
        if (elementData[index] == null) {
          remove(index);
          return true;
        }
    } else {
      for (int index = 0; index < size; index++)
        if (o.equals(elementData[index])) {
          remove(index);
          return true;
        }
    }
    return false;
  }
  • set方法，这个方法就很简单了。
  @Override
  public boolean set(int index, E o) {
    elementData[index] = o;
    return true;
  }
  • 重写toString方法。
  @Override
  public String toString() {

    if (size <= 0)
      return "[]";

    StringBuilder builder = new StringBuilder();
    builder.append("[");
    for (int index = 0; index < size; index++) {
      builder.append(elementData[index].toString() + ", ");
    }
    builder.delete(builder.length() - 2, builder.length());
    builder.append("]");
    return builder.toString();
  }
  • 测试代码
public static void main(String[] args) {
    MyArrayList<Integer> list = new MyArrayList<>();
    for (int i = 0; i < 15; i++) {
      list.add(-i);
    }
    System.out.println(list.contain(5));
    System.out.println(list);
    list.remove(new Integer(-6));
    System.out.println(list);
    System.out.println(list.elementData.length); // 容器会扩容两倍，而默认容器长度为10，因此这里是 20 
    list.add(5, 99999);
    System.out.println(list);
    System.out.println(list.contain(99999));
  }
// 代码输出
false
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14]
[0, -1, -2, -3, -4, -5, -7, -8, -9, -10, -11, -12, -13, -14]
20
[0, -1, -2, -3, -4, 99999, -5, -7, -8, -9, -10, -11, -12, -13, -14]
true

完整代码

import java.util.ArrayList;
import java.util.Arrays;


public class MyArrayList<E> implements MyCollection<E> {

  /**
   * 容器当中存储数据的个数
   */
  private int size;

  /**
   * 容器中数组的默认长度
   */
  private static final int DEFAULT_CAPACITY = 10;

  /**
   * 存放具体数据的数组，也就是我们容器当中真正存储数据的地方
   */
  Object[] elementData;

  /**
   * 当容器当中没有数据将 elementData 设置为这个值，这个值是所有实例一起共享的
   */
  private static final Object[] EMPTY_INSTANCE = {};


  public MyArrayList(int initialCapacity) {
    this();
    // 增长数组的空间为 initialCapacity，即申请一个数组
    // 且数组的长度为 initialCapacity
    grow(initialCapacity);
  }

  public MyArrayList() {
    this.size = 0; // 容器当中的数据个数在开始时为 0
    this.elementData = EMPTY_INSTANCE; // 将数组设置为空数组
  }

  /**
   * 这个函数的主要作用就是确保数组的长度至少为 capacity
   * @param capacity
   */
  public void ensureCapacity(int capacity) {
    int candidateCapacity = findCapacity(capacity);
    if (elementData.length < candidateCapacity)
      grow(candidateCapacity);
  }

  /**
   * 这个函数的主要目的就是找到最终数组长度需求的容量
   * @param minCapacity
   * @return
   */
  private int findCapacity(int minCapacity) {
    /**
     * 如果 if 条件为 true 即 elementData 还是初始化时设置的空数组
     * 那么返回默认大小和需要大小的最大值
     * 否则直接返回 minCapacity
     */
    if (elementData == EMPTY_INSTANCE){
      return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
  }

  /**
   * 该函数主要保证 elementData 的长度至少为 minCapacity
   * 如果数组的长度小于 minCapacity 则需要进行扩容，反之
   * @param minCapacity 数组的最短长度
   */
  private void grow(int minCapacity) {
    int oldCapacity = elementData.length;
    // 新的数组长度为原来数组长度的两倍
    int newCapacity = oldCapacity << 1;

    // 如果数组新数组的长度 newCapacity 小于所需要的长度 minCapacity
    // 新申请的长度应该为 minCapacity
    if (newCapacity < minCapacity) {
      newCapacity = minCapacity;
    }
    // 申请一个长度为 newCapacity 的数组，在将原来数组
    // elementData 的数据拷贝到新数组当中
    elementData = Arrays.copyOf(elementData, newCapacity);
  }

  @Override
  public boolean add(E o) {
    // 这个函数的主要作用就是确保数组的长度至少为 size + 1
    ensureCapacity(size + 1);
    // 新增加了一个数据，容器的大小需要 + 1
    elementData[size] = o;
    size++;
    return true;
  }

  /**
   * 在下标 index 位置插入数据 o
   * 首先先将 index 位置之后的数据往后移动一个位置
   * 然后将 index 赋值为 o
   * @param index
   * @param o
   * @return
   */
  @Override
  public boolean add(int index, E o) {
    // 确保容器当中的数组长度至少为 size + 1
    ensureCapacity(size + 1);
    // 将 elementData index位置之后的数据往后移动一个位置
    // 做一个原地拷贝
    System.arraycopy(elementData, index, elementData, index + 1,
        size - index); // 移动的数据个数为 size - index
    elementData[index] = o;
    size++;
    return true;
  }

  /**
   * 这个方法主要是用于溢出容器当中具体的某个数据
   * 首先先通过 for 循环遍历容器当中的每个数据，
   * 比较找到相同的数据对应的下标，然后通过下标移除方法
   * @param o
   * @return
   */
  @Override
  public boolean remove(E o) {
    if (o == null) {
      for (int index = 0; index < size; index++)
        if (elementData[index] == null) {
          remove(index);
          return true;
        }
    } else {
      for (int index = 0; index < size; index++)
        if (o.equals(elementData[index])) {
          remove(index);
          return true;
        }
    }
    return false;
  }

  /**
   * 移除下标为 index 的数据
   * @param index
   * @return
   */
  @Override
  public boolean remove(int index) {
    // 需要被移动的数据个数
    int numMoved = size - index - 1;
    if (numMoved > 0)
      System.arraycopy(elementData, index+1, elementData, index,
          numMoved);
    elementData[--size] = null;

    return true;
  }

  @Override
  public boolean append(E o) {
    return add(o);
  }

  @Override
  public int size() {
    return size;
  }

  @Override
  public boolean isEmpty() {
    return size == 0;
  }

  @Override
  public boolean contain(E o) {
    if (o == null) {
      for (int index = 0; index < size; index++)
        if (elementData[index] == null) {
          return true;
        }
    } else {
      for (int index = 0; index < size; index++)
        if (o.equals(elementData[index])) {
          return true;
        }
    }
    return false;
  }

  @Override
  public String toString() {

    if (size <= 0)
      return "[]";

    StringBuilder builder = new StringBuilder();
    builder.append("[");
    for (int index = 0; index < size; index++) {
      builder.append(elementData[index].toString() + ", ");
    }
    builder.delete(builder.length() - 2, builder.length());
    builder.append("]");
    return builder.toString();
  }
    
  @Override
  public boolean set(int index, E o) {
    elementData[index] = o;
    return true;
  }


  public static void main(String[] args) {
    MyArrayList<Integer> list = new MyArrayList<>();
    for (int i = 0; i < 15; i++) {
      list.add(-i);
    }
    System.out.println(list.contain(5));
    System.out.println(list);
    list.remove(new Integer(-6));
    System.out.println(list);
    System.out.println(list.elementData.length);
    list.add(5, 99999);
    System.out.println(list);
    System.out.println(list.contain(99999));
  }
}

本篇文章我们介绍了ArrayList的内部原理，并且我们实现了一个自己的简单数组容器MyArrayList，但是我们还有一些内容没有涉及，比如clone、equals和迭代器，这些内容我们下期分析ArrayList源码再进行分析，我是LeHung，我们下期再见！！！

更多容器设计的内容在项目https://github.com/Chang-LeHung/CSCore!!!

关注公众号：一无是处的研究僧，了解更多计算机知识。

一无是处的研究僧
关注
专栏目录
一文就懂HashMap原理！学不会你来砍我！
流楚丶格念的博客
08-12 2360
HashMap 基于哈希表的 Map 接口实现，是以 key-value 存储形式存在，即主要用来存放键值对。HashMap 的实现不是同步的，这意味着它不是线程安全的。它的 key、value 都可以为 null（但是key的位置只能有一个null），此外，HashMap 中的映射不是有序的。好，我们根据这里的简介看一个入门例子： 运行结果如下所示：这里的HashMap我是用的jdk8的，jdk1.7及以前和jdk1.8 及以后的HashMap是有很大区别的：下面我们说的HashMap都是jdk1.8 及
Java贪吃蛇小游戏，我家小AD从小水蛇成长为水中巨蟒！
编程界明世隐的博客
06-18 2万+
引言： 相信每一个人在童年时都有一个乃至数个伟大的梦想，我小时候就梦想成为： 1.孙悟空，因为我想成为一个降妖除魔、72变，最重要的是我想去哪就去哪，一个跟斗就起飞！ 2.葫芦娃，因为分开时个个独挡一面、身怀绝技；合体时，完美无敌，想大就大、想小就小！ 3.军事家，我从小比较喜欢看抗日电视剧，感觉我们国家从苦难中走出来很不容易，我那时希望自己成为军事家，能够保卫好我们的国家！ 4.科学家，老师跟我们说科学家是国家栋梁！我也希望能够成为杰出的科学家，提升我们国家的科技。 5.工程师，成为一名优秀的工程师，能建
JAVA 用数组实现 ArrayList
weixin_30740295的博客
05-25 174
JAVA 用数组实现 ArrayList 　　我们知道 ArrayList 是一个集合，它能存放各种不同类型的数据，而且其容量是自动增长的。那么它是怎么实现的呢？ 　　其实 ArrayList 的底层是用 数组实现的。我们查看 JDK 源码也可以发现。而用数组实现集合的原理有两点： 　　1、能自动扩容 　　2、能存放不同类型的数据 这两点我们是这样解决的： 　　1、当一个...
JAVA容器之ArrayList
JALJA
12-02 204
ArrayList 存在线程安全问题的本质是因为 ArrayList 自身的 elementData、size、modConut 在进行各种操作时，都没有加锁，并且这些变量的类型并非是volatile的，也不是原子操作
java用数组实现ArrayList
u014018804的博客
07-10 360
java用数组实现ArrayList ArrayList 是一个集合，它能存放各种不同类型的数据，而且其容量是自动增长的，底层是用 数组实现的。我们查看 JDK 源码也可以发现。 　　1、能自动扩容 　　2、能存放不同类型的数据 当一个数据存放满了，我们就将这个数据复制到一个新的数组中，而这个新的数组容量要比原数组大。通过这样不断的扩大数组长度，也就是集合的容量。那么这里我们用到了这个方法 System.arraycopy 完整的写法为： public static void arraycopy(Obje
今年Java面试必问的这些技术面，看完这一篇你就懂了
m0_57286518的博客
05-17 697
前言 众所周知，Java开发人员的生存环境可谓是与以前大相径庭，以IT行业发展来说，在十几年前的时候，IT行业的技术人才是稀缺的，程序员最初的招聘行情，只要你会敲“holle world”、会点技术，能做出点东西，就能入职月薪过万的大厂岗位。 而到了今年2021年，初级人才已经不稀缺了。“IT初级人才招聘市场上”除了每年新入行的人，还有几年内、大几年内入行后技术没有进步的人，这些人被辞退、或跳槽找工作，找的也是“IT初级程序员”岗位…… 以互联网巨头阿里的招聘信息来看，首先对于工作经验有一定的要求，在我看来
数组容器(ArrayList)设计与Java实现
JavaShark的博客
07-07 70
本篇文章主要跟大家介绍我们最常使用的一种容器 、 的原理，并且自己使用 实现自己的数组容器 ，让自己写的容器能像 那样工作。在本篇文章当中首先介绍 的一些基本功能，然后去分析我们自己的容器 应该如何进行设计，同时分析我们自己的具体实现方法，最后进行代码介绍！！！我们来看一个简单的代码，随机生成100个随机数，查看生成随机数当中是否存在50这个数。 public class MyArrayList { public static void main(String[] args) {
Java面试题大全（整理版）1000+面试题附答案详解，最全面详细，看完稳了
热门推荐
m0_67322837的博客
05-11 6万+
进大厂是大部分程序员的梦想，而进大厂的门槛也是比较高的，所以这里整理了一份阿里、美团、滴滴、头条等大厂面试大全，其中概括的知识点有：Java、MyBatis、ZooKeeper、Dubbo、Elasticsearch、Memcached、 Redis、MySQL、Spring、Spring Boot、Spring Cloud、RabbitMQ、Kafka、Linux 等技术栈共有1000+道面试题。 对于Java后端的朋友来说应该是最全面最完整的面试备战仓库，为了更好地整理每个模块，我也参考了很多网上的
java数组 arraylist_JAVA 用数组实现 ArrayList
weixin_39914975的博客
02-15 200
我们知道 ArrayList 是一个集合，它能存放各种不同类型的数据，而且其容量是自动增长的。那么它是怎么实现的呢？其实 ArrayList 的底层是用 数组实现的。我们查看 JDK 源码也可以发现。而用数组实现集合的原理有两点：1、能自动扩容2、能存放不同类型的数据这两点我们是这样解决的：1、当一个数据存放满了，我们就将这个数据复制到一个新的数组中，而这个新的数组容量要比原数组大。通过这样不断的...
java ArrayList
02-14 115
ArrayList ArrayList 类是一个可以动态修改的数组，与普通数组的区别就是它没有长度大小的限制。我们可以随意增加或删除元素。 ArrayList 继承了 AbstractList，并实现了List接口。 ArrayList 类位于 java.util 包内。 import java.util.ArrayList; ArrayList<E> objectName = new ArrayList<>(); // 初始化 添加元素 使用add()方法，添加元素到Arr
java 容器_java容器（一）ArrayList
weixin_39594457的博客
12-02 105
简单的说，容器是一种能够存放对象的一种工具，就比如我们学过的数组一样，它能存放相同类型的数据。下面我讲结合下面这张图，对java自带的常见容器做分析和实现。java常见容器java的容器可以分为Colection和Map两大类，Colection是序列化的容器，而Map则是基于键值对的容器，这里如果不熟悉的话，可以先只暂时了解一下，然后对于Colection接口，下面又有两个分类，是List和Se...
Java数组与ArrayList
qq_41827018的博客
04-17 318
Java数组与ArrayList 数据的组织形式无非两种：连续的、离散的，数组就是一种连续的数据组织。 数组 数组是一个固定长度的，包含了相同类型数据的容器。 数组的使用 //创建数组 int [] a;//声明一个数组，int表示数组类的元素类型，a为变量名 a = new int[10];//创建一个长度为10的数组，并让a引用指向数组 int[] b = new int[10];//声...
【Java源码】基于数组实现的ArrayList（上）
funyoo的博客
09-23 851
    目录   基本属性：            构造方法   给定容量的构造方法   无参构造方法   根据已有的Collection构造ArrayList             “修剪数组” 即 去除多余的（多申请的空间） ensureCapacity确保数组容量 grow扩容 大小，是否为空，是否包含 indexOf 查找某指定成员的第一个下标 lastInde...
Java 容器 ArrayList
peabits' Web Log
07-30 134
文章目录2. ArrayList2.1 概览2.2 扩容2.3 删除元素2.4 Fail-Fast2.5 序列化 Java 容器 2. ArrayList 2.1 概览 因为 ArrayList 是基于数组实现的，所以支持快速随机访问。RandomAccess 接口标识着该类支持快速随机访问。 public class ArrayList<E> extends AbstractList...
用数组的方式实现ArrayList
来杯咖啡吗的博客
09-24 155
/** * this is my ArrayList * @param <Object> */ public class myarraylist<Object> implements Iterable<Object> { private static final int DEFAULT_CAPACITY = 10; //用来定义默认数组的长度 private int thesize; //用来控制theitems数组的长度(实际也就是.
Java集合ArrayList详解
最新发布
weixin_62458944的博客
08-03 7662
ArrayList 类是一个可以动态修改的数组，与普通数组的区别就是它是没有固定大小的限制，我们可以添加或删除元素。ArrayList 继承了 AbstractList ，并实现了 List 接口。
Java -- 自己实现数组列表（Arraylist）
qq_38105361的博客
05-10 563
Java – 自己实现数组列表（Arraylist）
使用数组实现ArrayList实践
博客
09-21 1631
使用数组的方式实现一个 ArrayList 泛型类，为避免与类型库中的类混淆，这里将类命名为 MyArrayList import java.util.NoSuchElementException; public class MyArrayList&amp;amp;amp;amp;amp;amp;lt;AnyType&amp;amp;amp;amp;amp;amp;gt; implements Iterable&amp;amp;amp;amp;amp;amp;lt;AnyType&
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值