Java 集合 (3) -- ArrayList 类

最新推荐文章于 2022-11-28 21:08:37 发布
最新推荐文章于 2022-11-28 21:08:37 发布
阅读量228 收藏
点赞数
分类专栏： # Java 集合 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38350925/article/details/105886509
版权

文章目录

1. 简介

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable {}

ArrayList 底层是通过一个动态数组来实现的。

它实现了 List 接口，提供了基础的添加、删除、遍历等操作；实现了 RandomAccess 接口，标识该类具有随机访问的能力；实现了 Cloneable, java.io.Serializable 接口，表示该类可以被克隆和序列化。

此外，它还继承了 AbstractList 抽象类，该抽象类实现了 List 接口中大多数的方法，帮助其子类最大程度地减少了实现 List 接口所需的工作。

ArrayList 不是同步的；它允许存储包括 null 在内的所有对象元素；除了实现 List 接口的所有方法外，它还另外提供一些方法用来操作其内部的数组大小。

因为它支持随机访问，即通过索引访问元素，查询的时间复杂度为 O(1)；它支持添加元素到尾部以及从尾部删除元素，平均时间复杂度也是 O(1)，但它添加元素到中间以及删除中间元素会比较慢，因为要搬移元素，平均时间复杂度为 O(n)；

支持求并集，调用 addAll(Collection<? extends E> c) 方法即可；支持求交集，调用 retainAll(Collection<? extends E> c) 方法即可；支持求单向差集，调用 removeAll(Collection<? extends E> c) 方法即可。

ArrayList 的扩容机制：ArrayList 内部使用了一个 Object 类型的并且被 transient 修饰的数组 elementData 来存储元素，当数组长度不够时会调用 grow() 方法进行扩容，每次扩容都会增加一半的空间，并且它不会进行缩容；每个 ArrayList 实例都有一个容量，该容量是指用来存储列表元素的数组的大小，默认初始容量为 10，随着 ArrayList 中元素的增加，它的容量也会不断地自动增长；在每次添加新的元素时，ArrayList 都会检查是否需要进行扩容操作，如果需要，那么在扩容操作时需要将数据拷贝到新的数组，所以如果我们知道具体业务的数据量的话，那么当我们在构造 ArrayList 时可以给 ArrayList 指定一个初始容量，这样就可以减少扩容次数。

其实每次扩容并不是一定就是 1.5 倍增长，grow() 方法：首先让新容量等于旧容量的 1.5 倍，然后判断新容量是否大于实际需求的容量，若小于则以实际容量为准，另外，如果新容量的值大于最大容量 MAX_ARRAY_SIZ，则以最大容量为准

elementData 设置成了 transient，那 ArrayList 是怎么把元素序列化的呢 ？首先，transient 用来表示一个域不是该对象序行化的一部分，当一个对象被序行化的时候，transient 修饰的变量不会被序列化；默认的序列化，也就是只实现 Serializable 接口的情况下，如果 elementData 不被 transient 修饰，那么 ArrayList 序列化的时候会将整个 elementData 进行序列化，因为 ArrayList 的扩容机制，elementData 数组会保留有一部分空间，这一部分空间是没有存储元素的，所以默认序列化的话，会导致这一部分空元素也一起被序列化，占用了一些没必要的空间，多少会影响性能；解决方案就是用 transient 修饰 elementData，并重写 writeObject() 和 readObject() 来实现自定义序列化，这两个方法必须声明为 private，writeObject() 会直接将 size 和 element 写入到 ObjectOutputStream 中；反序列化时调用 readObject()，然后从 ObjectInputStream 中获取 size 和 element，并恢复到 elementData，这样子，就可以根据 size 来序列化真实的元素，而不是根据数组的长度序列化元素，减少了空间占用。

Array 和 ArrayList 有何区别 ？什么时候更适合用 Array ？Array 可以容纳基本类型和对象，而 ArrayList 只能容纳对象；Array 是固定大小的，而 ArrayList 不是；适合使用 Array 的场景：如果列表的大小已经指定，大部分情况下是存储和遍历它们；用于遍历基本数据类型；使用多维数组。

ArrayList 扩容时为什么是 1.5 倍 ？因为 1.5 倍的扩容可以说是最好的倍数。一次性扩容太大 (例如 2.5 倍) 可能会浪费更多的内存 ( 1.5 倍最多浪费 33%，而 2.5 倍最多会浪费 60%，3.5倍则会浪费 71%……)。但是一次性扩容太小，就可能需要多次对数组重新分配内存，对性能消耗比较严重。所以 1.5 倍刚刚好，既能满足性能需求，也不会造成很大的内存消耗

2. 常用方法

  1. boolean add(Element e)：增加指定元素到列表尾部
  2. void add(int index, Element e)：增加指定元素到列表指定位置
  3. boolean addAll(Collection<? extends E> c)：将指定collection中的所有元素插入到ArrayList中
  4. boolean addAll(int index, Collection<? extends E> c)：从指定的位置开始，将指定collection 中的所有元素插入到ArrayList中
  5. void clear()：从列表中删除所有元素
  6. E remove(int index)：删除列表中指定位置的元素
  7. boolean removeIf(Predicate<? super E> filter)：根据重写Predicate类的test方法选择删除集合中的元素
  8. boolean removeAll(Collection<?> c)：移除ArrayList中Collection所包含的所有元素
  9. boolean remove(Object o)：移除ArrayList中首次出现的指定元素（如果存在则移除并返回true，否则返回false）
  10. E get(int index)：获取列表中指定位置处的元素
  11. Object[] toArray()：获取一个数组，数组中所有元素是列表中的元素.（即将列表转换为一个数组）
  12. T[] toArray(T[] a)：构造一个数组
  13. List subList(int fromIndex, int toIndex)：获取从 fromIndex 到 toIndex - 1 位置的元素
  14. E set(int index, E element)：将列表中指定位置上的元素替换成新元素
  15. boolean contains(Object o)：如果列表包含指定元素，返回true
  16. int indexOf(Object o)：返回元素在列表中第一次出现的位置，如果返回-1，表示列表中没有这个元素
  17. int lastIndexOf(Object o)：返回元素在列表中最后一次出现的位置，如果返回-1，表示列表中没有这个元素
  18. boolean isEmpty()：返回true表示列表中没有任何元素. 判断逻辑是size == 0
  19. int size()：返回列表长度（列表包含元素的个数）

3. 源码分析 (JDK 1.8)

1. 继承体系

在这里插入图片描述

2. 属性

//序列化ID
private static final long serialVersionUID = 8683452581122892189L;

/**
 * 默认容，即通过 new ArrayList() 创建时的默认容量
 */
private static final int DEFAULT_CAPACITY = 10;

/**
 * 空数组，如果传入的容量为 0 时使，即通过 new ArrayList(0) 创建时用的是这个空数组
 */
private static final Object[] EMPTY_ELEMENTDATA = {};

/**
 * 空数组，传传入容量时使用，通过new ArrayList()创建时用的是这个空数组，
 * 与EMPTY_ELEMENTDATA的区别是在添加第一个元素时使用这个空数组的会初始化为DEFAULT_CAPACITY（10）个元素
 */
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

/**
 * 存储元素的数组
 * 至于没有使用private修饰，后面注释是写的“为了简化嵌套类的访问”，
 * 但是实测加了private嵌套类一样可以访问
 */
transient Object[] elementData; // non-private to simplify nested class access

/**
 * 集合中元素的个数,即真正存储元素的个数，而不是elementData数组的长度
 */
private int size;

/**
 * 最大容量，Integer.MAX_VALUE = 0x7fffffff，即 2^31
 */
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

3. 构造器

  1. ArrayList(int initialCapacity)
    public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {
        // 如果传入的初始容量大于0，就新建一个数组存储元素
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        // 如果传入的初始容量等于0，使用空数组EMPTY_ELEMENTDATA
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        // 如果传入的初始容量小于0，抛出异常
        throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity);
    }
}
  2. ArrayList()
    public ArrayList() {
    // 如果没有传入初始容量，则使用空数组DEFAULTCAPACITY_EMPTY_ELEMENTDATA
    // 使用这个数组是在添加第一个元素的时候会扩容到默认大小10
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
  3. ArrayList(Collection<? extends E> c)
    /**
* 把传入集合的元素初始化到ArrayList中
*/
public ArrayList(Collection<? extends E> c) {
    // 集合转数组
    elementData = c.toArray();
    if ((size = elementData.length) != 0) {
        // 检查c.toArray()返回的是不是Object[]类型，如果不是，重新拷贝成Object[].class类型
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        // 如果c的空集合，则初始化为空数组EMPTY_ELEMENTDATA
        this.elementData = EMPTY_ELEMENTDATA;
    }
}
    为什么c.toArray();返回的有可能不是Object[]类型呢？请看下面的代码：
    public class ArrayTest {
    public static void main(String[] args) {
        Father[] fathers = new Son[]{};
        // 打印结果为class [Lcom.coolcoding.code.Son;
        System.out.println(fathers.getClass());

        List<String> strList = new MyList();
        // 打印结果为class [Ljava.lang.String;
        System.out.println(strList.toArray().getClass());
    }
}

class Father {}

class Son extends Father {}

class MyList extends ArrayList<String> {
    /**
     * 子类重写父类的方法，返回值可以不一样
     * 但这里只能用数组类型，换成Object就不行
     * 应该算是java本身的bug
     */
    @Override
    public String[] toArray() {
        // 为了方便举例直接写死
        return new String[]{"1", "2", "3"};
    }
}

4. 其他方法

1. 添加元素
  1. add(E e)：添加元素到末尾，平均时间复杂度为O(1)
    public boolean add(E e) {
    // 检查是否需要扩容
    ensureCapacityInternal(size + 1);
    // 把元素插入到最后一位
    elementData[size++] = e;
    return true;
}

    private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

    private static int calculateCapacity(Object[] elementData, int minCapacity) {
    // 如果是空数组DEFAULTCAPACITY_EMPTY_ELEMENTDATA，就初始化为默认大小10
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}

    private void ensureExplicitCapacity(int minCapacity) {
    modCount++; //修改次数 +1，用于 Fail-Fast 机制

    if (minCapacity - elementData.length > 0)
        // 扩容
        grow(minCapacity);
}

    private void grow(int minCapacity) {
    int oldCapacity = elementData.length;
    // 新容量为旧容量的1.5倍
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    // 如果新容量发现比需要的容量还小，则以需要的容量为准
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    // 如果新容量已经超过最大容量了，则使用最大容量
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // 创建新容量的数组并把老数组拷贝到新数组
    elementData = Arrays.copyOf(elementData, newCapacity);
}
  2. add(int index, E element)：添加元素到指定位置，平均时间复杂度为O(n)
    public void add(int index, E element) {
    // 检查是否越界
    rangeCheckForAdd(index);
    // 检查是否需要扩容
    ensureCapacityInternal(size + 1);
    // 将inex及其之后的元素往后挪一位，则index位置处就空出来了
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    // 将元素插入到index的位置
    elementData[index] = element;
    // 大小增1
    size++;
}

    private void rangeCheckForAdd(int index) {
    if (index > size || index < 0)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
  3. addAll(Collection<? extends E> c)：将集合 c 中所有元素添加到当前 ArrayList 尾部
    public boolean addAll(Collection<? extends E> c) {
    // 将集合c转为数组
    Object[] a = c.toArray();
    int numNew = a.length;
    // 检查是否需要扩容
    ensureCapacityInternal(size + numNew);
    // 将c中元素全部拷贝到数组的最后
    System.arraycopy(a, 0, elementData, size, numNew);
    // 大小增加c的大小
    size += numNew;
    // 如果c不为空就返回true，否则返回false
    return numNew != 0;
}
2. 获取元素
  1. get(int index)：获取指定索引位置的元素，时间复杂度为O(1)
    public E get(int index) {
    // 检查是否越界
    rangeCheck(index);
    // 返回数组index位置的元素
    return elementData(index);
}

    private void rangeCheck(int index) {
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

    E elementData(int index) {
    return (E) elementData[index];
}
3. 删除元素
  1. remove(int index)：删除指定索引位置的元素，时间复杂度为O(n)
    public E remove(int index) {
    // 检查是否越界
    rangeCheck(index);

    modCount++; //修改次数 +1，用于 Fail-Fast 机制
    
    // 获取index位置的元素
    E oldValue = elementData(index);

    // 如果index不是最后一位，则将index之后的元素往前挪一位
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index, numMoved);

    // 将最后一个元素删除，帮助GC
    elementData[--size] = null; // clear to let GC do its work

    // 返回旧值
    return oldValue;
}
  2. remove(Object o)：删除第一个指定元素值的元素，时间复杂度为O(n)
    public boolean remove(Object o) {
    if (o == null) {
        // 遍历整个数组，找到元素第一次出现的位置，并将其快速删除
        for (int index = 0; index < size; index++)
            // 如果要删除的元素为null，则以null进行比较，使用==
            if (elementData[index] == null) {
                fastRemove(index);
                return true;
            }
    } else {
        // 遍历整个数组，找到元素第一次出现的位置，并将其快速删除
        for (int index = 0; index < size; index++)
            // 如果要删除的元素不为null，则进行比较，使用equals()方法
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
    }
    return false;
}

    private void fastRemove(int index) {
    // 少了一个越界的检查
    
    modCount++; //修改次数 +1，用于 Fail-Fast 机制
    
    // 如果index不是最后一位，则将index之后的元素往前挪一位
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index, numMoved);
    // 将最后一个元素删除，帮助GC
    elementData[--size] = null; // clear to let GC do its work
}
    该方法的大概步骤就是：找到第一个等于指定元素值的元素，如果指定元素值为 null 则用 == 比较，否则用 equals() 比较；需要注意的是，这里的删除方法使用了快速删除，快速删除与前面的删除方法的区别在于：快速删除省略了越界检查的步骤。
  3. removeAll(Collection<?> c)：求两个集合的单方向差集，只保留当前集合中不在 c 中的元素，不保留在 c 中不在当前集体中的元素
    public boolean removeAll(Collection<?> c) {
    // 集合c不能为空
    Objects.requireNonNull(c);
    // 同样调用批量删除方法，这时complement传入false，表示删除包含在c中的元素
    return batchRemove(c, false);
}

    /**
* 批量删除元素
* complement为true表示删除c中不包含的元素
* complement为false表示删除c中包含的元素
*/
private boolean batchRemove(Collection<?> c, boolean complement) {
    final Object[] elementData = this.elementData;
    // 使用读写两个指针同时遍历数组
    // 读指针每次自增1，写指针放入元素的时候才加1
    // 这样不需要额外的空间，只需要在原有的数组上操作就可以了
    int r = 0, w = 0;
    boolean modified = false;
    try {
        // 遍历整个数组，如果c中不包含该元素，则把该元素放到写指针的位置（以complement为准）
        // 如果是求交集的方法，这里是：如果c中包含该元素，则把该元素放到写指针的位置
        for (; r < size; r++)
            if (c.contains(elementData[r]) == complement)
                elementData[w++] = elementData[r];
    } finally {
        // 正常来说r最后是等于size的，除非c.contains()抛出了异常
        if (r != size) {
            // 如果c.contains()抛出了异常，则把未读的元素都拷贝到写指针之后
            System.arraycopy(elementData, r,
                             elementData, w,
                             size - r);
            w += size - r;
        }
        if (w != size) {
            // 将写指针之后的元素置为空，帮助GC
            for (int i = w; i < size; i++)
                elementData[i] = null;
            modCount += size - w;
            // 新大小等于写指针的位置（因为每写一次写指针就加1，所以新大小正好等于写指针的位置）
            size = w;
            modified = true;
        }
    }
    // 有修改返回true
    return modified;
}
    求单向差集的方法其底层其实就是对在 c 中的元素进行了批量删除操作：首先遍历 elementData 数组；如果元素不在 c 中，则把这个元素添加到 elementData 数组的 w 位置并将 w 位置往后移一位；遍历完之后，w 之前的元素都是 c 中没有的，w 之后（包含）的元素是两者共有的；将 w 之后（包含）的元素置为 null，方便 GC 回收。
4. 求交集
  1. retainAll(Collection<?> c)：求两个集合的交集
    public boolean retainAll(Collection<?> c) {
    // 集合c不能为null
    Objects.requireNonNull(c);
    // 调用批量删除方法，这时complement传入true，表示删除不包含在c中的元素
    return batchRemove(c, true);
}
    求交集的方法其底层其实就是对不在 c 中的元素进行了批量删除操作：首先遍历 elementData 数组；如果元素在 c 中，则把这个元素添加到 elementData 数组的 w 位置并将 w 位置往后移一位；遍历完之后，w 之前的元素都是两者共有的，w 之后（包含）的元素不是两者共有的；将 w 之后（包含）的元素置为 null，方便 GC 回收。
5. ArrayList 中的自定义序列化
  1. writeObject(java.io.ObjectOutputStream s)：
    private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException{
    // 防止序列化期间有修改
    int expectedModCount = modCount;
    // 写出非transient非static属性（会写出size属性）
    s.defaultWriteObject();

    // 写出元素个数
    s.writeInt(size);

    // 依次写出元素
    for (int i=0; i<size; i++) {
        s.writeObject(elementData[i]);
    }

    // 如果有修改，抛出异常
    if (modCount != expectedModCount) {
        throw new ConcurrentModificationException();
    }
}
  2. readObject(java.io.ObjectInputStream s)：
    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
    // 声明为空数组
    elementData = EMPTY_ELEMENTDATA;

    // 读入非transient非static属性（会读取size属性）
    s.defaultReadObject();

    // 读入元素个数，没什么用，只是因为写出的时候写了size属性，读的时候也要按顺序来读
    s.readInt();

    if (size > 0) {
        // 计算容量
        int capacity = calculateCapacity(elementData, size);
        SharedSecrets.getJavaOISAccess().checkArray(s, Object[].class, capacity);
        // 检查是否需要扩容
        ensureCapacityInternal(size);

        Object[] a = elementData;
        // 依次读取元素到数组中
        for (int i=0; i<size; i++) {
            a[i] = s.readObject();
        }
    }
}

查看 writeObject() 方法可知，先调用 s.defaultWriteObject() 方法，再把 size 写入到流中，再把元素一个一个的写入到流中。

一般地，只要实现了 Serializable 接口即可自动序列化，重写 writeObject() 和 readObject() 是为了自己控制序列化的方式，这两个方法必须声明为 private，在 java.io.ObjectStreamClass#getPrivateMethod() 方法中通过反射获取到 writeObject() 这个方法。

在 ArrayList 的 writeObject() 方法中先调用了 s.defaultWriteObject() 方法，这个方法是写入非 static 非 transient 的属性，在 ArrayList 中也就是 size 属性。同样地，在 readObject() 方法中先调用了 s.defaultReadObject() 方法解析出了 size 属性。

elementData 定义为 transien t的优势，自己根据 size 序列化真实的元素，而不是根据数组的长度序列化元素，减少了空间占用。

4. Fail-Fast 机制

Fail - Fast 机制，即快速失败机制，是 java 集合(Collection)中的一种错误检测机制。当在迭代集合的过程中该集合在结构上发生改变的时候，就有可能会发生 fail-fast，即抛出 ConcurrentModificationException 异常。fail-fast 机制并不保证在不同步的修改下一定会抛出异常，它只是尽最大努力去抛出，所以这种机制一般仅用于检测 bug

常见的 java 集合中就可能出现 fail-fast 机制，比如 ArrayList，HashMap。在多线程和单线程环境下都有可能出现快速失败

因为 ArrayList 不是线程安全的，所以当在迭代 ArrayList 的过程中该集合在结构上发生改变的时候，就会抛出 ConcurrentModificationException，这就是所谓 fail-fast 策略

这一策略在源码中的实现是通过 modCount 域，modCount 顾名思义就是修改次数，对 ArrayList 内容的修改都将增加这个值，在迭代器初始化过程中会将这个值赋给迭代器的 expectedModCount。在迭代过程中，判断 modCount 跟 expectedModCount 是否相等，如果不相等就表示已经有其他线程修改了 ArrayList

fail-fast 与 fail-safe 有什么区别 ？java.util.concurrent 中的集合类都为 fail-safe 的。当检测到正在遍历的集合的结构被改变时，fail-fast 迭代器抛出 ConcurrentModificationException，而 fail-safe 迭代器从不抛出 ConcurrentModificationException

南京.
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java进阶--深入理解ArrayList实现原理
01-27
ArrayList是Java集合框架中常用的列表实现之一，它作为动态数组，允许我们在运行时根据需要增加或减少元素。ArrayList继承自AbstractList，并实现了List、RandomAccess、Cloneable和Serializable接口。这意味着...
ArrayList集合
cl66666666的博客
11-18 506
ArrayList： 可调整大小的数组实现； :是一种特殊的数据类型，泛型。 创建ArrayList集合 方法名 说明 public ArrayList() 创建一个空的集合对象 public boolean add(E e) 将指定的元素追加到此集合的末尾 public void add(int index,E element) 在此集合中的指定位置插入指定的元素 package com.itxuexi.it09; import com.sun.java.swing.
JAVA常用API : ArrayList
爪哇岛的白咖啡
04-06 5612
ArrayList //创建一个ArrayList集合,尖括号是泛型,只能是引用类型，表示这个集合存的数据的类型，右边可以不写； ArrayList<String> list = new ArrayList<>(); //直接打印list，得到的是： [] ，是内容而不是地址值 System.out.println(list);//[] //向集合内添加一些String类型数据，add();
list练习
weixin_45701868的博客
04-12 523
1．以下代码的执行结果是？【单项选择题】【简单】 public class Example { public static void main(String[] args) { String s1 = "abc"; String s2 = "def"; Stack<String> stack = new Stack<Str...
泛型
小沐CA
05-02 251
泛型 泛型是Java1.5之后添加的，它可以帮我们建立类型安全的集合。 泛型的本质就是“数据类型的参数化”，我们可以吧泛型理解为数据类型的一个占位符(形式参数)，即告诉编译器，在调用泛型时必须传入实际类型。 集合可以存储任何类型的对象，但是，当把一个对象存入集合后，集合会忘记这个对象的类型，将给对象从集合中取出时，这个...
java第十一章练习题（使用泛型和集合框架）
毕富国的博客
10-08 6235
第十一章练习题（使用泛型和集合框架）       1．集合API 中Set接口的特点是哪项？     A．不允许重复元素，元素有顺序     B.允许重复元素，元素无顺序     C．允许重复元素，元素有顺序     D．不允许重复元素，元素无顺序       2．实现了Set接口的类是哪项？     A．  ArrayList     B．  HashTable     C...
java集合 collection-list-LinkedList详解
08-31
Java集合框架是Java编程语言中的一个重要组成部分，它提供了一种高效、灵活的方式来存储和操作数据。在Java集合框架中，`List`接口是`Collection`接口的一个子接口，它代表了有序的元素列表，其中元素可以重复，并且...
java集合-ArrayList的使用
06-14
ArrayList基于数组实现的动态数组，支持快速随机访问和元素的插入、删除操作。 ArrayList基于数组实现的动态数组，支持快速随机访问和元素的插入、删除操作。
Java-Java集合体系-List-Set
最新发布
07-12
理解并熟练运用Java集合体系中的List、Set、Map接口及其实现类，对于日常开发和面试来说至关重要，因为它们是许多Java框架和库的基础。在实际项目中，根据需求选择合适的集合类型可以提高代码的效率和可维护性。在...
Extending-Java-ArrayList
06-21
在Java编程语言中，ArrayList是一个常用的集合类，它实现了可变大小的数组，方便我们存储和操作一组有序的对象。然而，Java并不支持像某些其他语言（如JavaScript或Python）那样的函数作为参数传递，而是通过方法回...
java 继承arraylist_ArrayList：继承关系
weixin_30273263的博客
02-16 732
继承关系public class ArrayList extends AbstractListimplements List, RandomAccess, Cloneable, java.io.Serializable{ArrayList继承了AbstractList，实现了List，RandomAccess，Cloneable，SerializableSerializable标记性接口类的序列化...
Java 集合系列03之 ArrayList详细介绍(源码解析)和使用示例
qq_43652793的博客
11-11 139
概要 上一章，我们学习了Collection的架构。这一章开始，我们对Collection的具体实现类进行讲解；首先，讲解List，而List中ArrayList又最为常用。因此，本章我们讲解ArrayList。先对ArrayList有个整体认识，再学习它的源码，最后再通过例子来学习如何使用它。内容包括： 第1部分 ArrayList简介 第2部分 ArrayList数据结构 第3部分 Array...
Java--集合
追求灵魂代码
10-06 607
目录实验目标正文截图总结 实验目标 编写程序练习List集合及泛型的基本使用： 1、 创建一个只能容纳String对象名为names的ArrayList集合； 2、按顺序往集合中添加5个字符串对象：“张三”、“李四”、“王五”、“马六”、“赵七”； 3、对集合进行遍历，分别打印集合中的每个元素的位置与内容； 4、首先打印集合的大小，然后删除集合中的第3个元素，并显示删除元素的内容，然后再打印目前集...
Java高级编程知识总结及复习（一）
MELF晓宇的博客
06-30 1938
Java高级编程知识总结及复习（一） 1.所有异常类的父类是（A）。 答案 A Throwable B Error C Exception D RunTimeException Throwable是Error和Exception的父类，用来定义所有可以作为异常被抛出来的类。 Error是编译时错误和系统错误。 Exception则是可以被抛出的基本类型。 RunTimeException：运行时异常，又称不受检查异常。 2.下面属于非检查型异常的类是（A、B）。
如何一句话实例化ArrayList
時を越える笑顔
07-01 2917
我愿意创建列表的选项，用来测试东西。 我正在做： ArrayList places = new ArrayList(); places.add("Buenos Aires"); places.add("Córdoba"); places.add("La Plata"); 我重构代码做： ArrayList places = new ArrayLi
JavaDay_ArrayList集合
Dia_mond的博客
04-05 253
ArrayList集合 1. 集合和数组的特点 数组 是一个容器 可以存放一种数据类型 存放的元素既可以是基本数据类型又可以是引用数据类型 长度固定 集合 是一个容器 可以存放多种数据类型(但是使用的时候还是存放一种) 只能存放引用数据类型 长度可变 ArrayList集合的使用 查看API 在java.util 包下, 所以使用前需要先导包 ArrayList<E&g...
2020年最新JAVA考试题库,精选新版2020年JAVASE综合模拟考试题库188题(含参考答案)...
weixin_39964869的博客
03-29 233
2020年JAVASE综合考试试题库188题[含答案]一、选择题1．创建一个只能存放String的泛型ArrayList的语句是哪项？答案:BA.ArrayListal = new ArrayList();B.ArrayListal = new ArrayList();C.ArrayList al = new ArrayList();D.ArrayListal = new List();2．"下列...
JAVA--集合基础
weixin_43421392的博客
11-28 670
修改，是对list Student 对象集合进行修改，因为元素都是对象，所以修改的时候需要输入修改的信息后，再次调用学生类生成对象，最后通过集合set方法进行修改；创建一个存储Sting 的集合，内部存储（test,张三，李四，test.test）字符串。需求：定义一个方法，方法接受一个集合对象（student），方法的内部将年龄低于18的学生对象找出来。新增，录入sid的时候需要调用查看索引的方法，如果索引存在，则提示账户已存在；传入的sid调用看索引的方法, 索引值不为-1，则进行修改，删除；
如运用java来控制jsp_java应用开发技术-中国大学mooc-题库零氪
weixin_28957683的博客
02-25 1550
第1讲 注释与注解注释与注解单元测试1、以下哪些不属于JAVA中可用的注释A、//B、/* */C、./** */D、#2、JAVA注解用的符号是A、@B、#C、$D、%3、修饰在方法上，表示被修饰的方法用来重写父类上的方法使用的注解是：A、@OverrideB、@DeprecatedC、@SuppressWaringsD、@Interface4、表示被修饰的内容是不被推荐使用的注解是：A、@Ov...
将1-10存入arraylist集合中
06-06
好的，以下是可以实现您要求的 Java 代码： ```java import java.util.ArrayList; public class Main { public static void main(String[] args) { ArrayList<Integer> list = new ArrayList<Integer>(); for (int i = 1; i <= 10; i++) { list.add(i); } System.out.println(list); } } ``` 这个程序创建了一个 `ArrayList<Integer>` 对象，然后使用 for 循环从 1 到 10 遍历，将每个整数添加到集合中。最后输出集合的内容。 希望这个代码可以满足您的需求。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值