ArrayList用法及源码解析

最新推荐文章于 2022-08-01 21:38:37 发布
原创 最新推荐文章于 2022-08-01 21:38:37 发布 · 568 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#arraylist #源码

本文详细介绍了ArrayList的基本概念、内部结构、与LinkedList的区别以及常用方法，并提供了示例代码。

转载请注明出处：http://blog.youkuaiyun.com/github_39430101/article/details/76166174

ArrayList简介

ArrayList实现了List接口，内部以数组存储数据，允许重复的值。由于内部是数组实现，所以ArrayList具有数组所有的特性，通过索引支持随机访问，查询速度快，但是插入和删除的效率比较低。ArrayList是非线程安全的，所以建议在单线程中使用ArrayList，在多线程中选择Vector或者CopyOnWriteArrayList。

ArrayList结构

这里写图片描述

和LinkedList主要区别

1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
2.对于随机访问get和set，ArrayList优于LinkedList，因为LinkedList要移动指针。
3.对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。

常用方法

返回类型方法用法
booleanadd(E e)将指定的元素添加到此列表的尾部
voidadd(int index, E element)将指定的元素插入此列表中的指定位置
voidclear()移除此列表中的所有元素
Objectclone()返回此 ArrayList 实例的浅表副本
booleancontains(Object o)如果此列表中包含指定的元素，则返回 true
Eget(int index)返回此列表中指定位置上的元素
intindexOf(Object o)返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1
intlastIndexOf(Object o)返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1
booleanisEmpty()如果此列表中没有元素，则返回 true
Eremove(int index)移除此列表中指定位置上的元素
booleanremove(Object o)删除ArrayList中指定的元素
protected voidremoveRange(int fromIndex, int toIndex)移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素
Eset(int index, E element)用指定的元素替代此列表中指定位置上的元素
intsize()返回此列表中的元素数
Object[]toArray()按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组
voidtrimToSize()将此 ArrayList 实例的容量调整为列表的当前大小

Demo

package com.code.array;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class ArrayTest {

    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        // add方法
        list.add("张三");
        list.add("李四");
        list.add("王麻子");
        list.add("赵云");
        list.add("关羽");
        list.add("曹操");

//      第一种遍历方法
        for(int i=0;i<list.size();i++){
            System.out.println(list.get(i));   
        }
//      第二种遍历方法 foreach循环
        for(String v :list) {
            System.out.println(v);
        }

//      第三种遍历方法
        Iterator<String> i = list.iterator();
        while(i.hasNext()) {
            System.out.println(i.next());
        } 

        list.add(0, "张飞");


        if(list.contains("赵云")) {
            System.out.println("我乃常山赵子龙");
        } else System.out.println("没有赵云");


        System.out.println(list.indexOf("赵云"));
        //lastIndexOf(Object o)

        System.out.println(list.lastIndexOf("张三"));

        System.out.println(list.isEmpty());
        //循环删除
        for (int x =list.size()-1;x>=0;x--) {
            list.remove(list.get(x));
        }
    }
}

ArrayList源码


package java.util;

import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.function.UnaryOperator;

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
    //序列版本号
    private static final long serialVersionUID = 8683452581122892189L;
    // 默认初始数组大小
    private static final int DEFAULT_CAPACITY = 10;
    //空数组，用来实例化不带容量大小的构造函数
    private static final Object[] EMPTY_ELEMENTDATA = {};
    //用于默认大小的空实例的共享空数组实例。
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    //保存ArrayList数组数据
    transient Object[] elementData; 
    //数组包含元素的个数
    private int size;

    /********** 三个构造函数 *********/

    //带参构造函数
    public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

    //无参构造函数
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
    //参数为Collection的构造方法
    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }
    /*************** ArrayList扩容原理 ************/
    //修改当前容量为实际个数
    public void trimToSize() {
        modCount++;
        //如果当前个数小于数组的容量，则把数组大小设置为当前的size
        if (size < elementData.length) {
            elementData = (size == 0)
              ? EMPTY_ELEMENTDATA
              : Arrays.copyOf(elementData, size);
        }
    }

    //将此 ArrayList 实例的容量调整为列表的当前大小，是提供给外界的方法，真正的扩容是在下面的private方法里
    public void ensureCapacity(int minCapacity) {
        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
            ? 0
            : DEFAULT_CAPACITY;

        if (minCapacity > minExpand) {
            ensureExplicitCapacity(minCapacity);
        }
    }

    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
   ensureExplicitCapacity(minCapacity);
    }

    //ArrayList扩容
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
        //如果新的数组大小大于之前数组大小，则调用扩容方法
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    //分配的最大数组空间
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    //扩容
    private void grow(int minCapacity) {
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);//新的容量=原来的容量+原来的容量/2
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
    //
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }
    /********* 常用方法 **************/
    //返回当前数组大小
    public int size() {
        return size;
    }
    //判断数组是否为空
    public boolean isEmpty() {
        return size == 0;
    }
    //判断数组是否包含某个元素
    public boolean contains(Object o) {
        return indexOf(o) >= 0;
    }
    //返回此列表中首次出现的指定元素的索引
    public int indexOf(Object o) {
        if (o == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }
    //返回此列表中最后一次出现的指定元素的索引
    public int lastIndexOf(Object o) {
        if (o == null) {
            for (int i = size-1; i >= 0; i--)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = size-1; i >= 0; i--)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

    //克隆
    public Object clone() {
        try {
            ArrayList<?> v = (ArrayList<?>) super.clone();
            v.elementData = Arrays.copyOf(elementData, size);
            v.modCount = 0;
            return v;
        } catch (CloneNotSupportedException e) {
            // this shouldn't happen, since we are Cloneable
            throw new InternalError(e);
        }
    }

    //返回一个Object数组，包含ArrayList中所有的元素
    public Object[] toArray() {
        return Arrays.copyOf(elementData, size);
    }

    //返回ArrayList的模板数组
    @SuppressWarnings("unchecked")
    public <T> T[] toArray(T[] a) {
        if (a.length < size)
            // Make a new array of a's runtime type, but my contents:
            return (T[]) Arrays.copyOf(elementData, size, a.getClass());
        System.arraycopy(elementData, 0, a, 0, size);
        if (a.length > size)
            a[size] = null;
        return a;
    }

    // Positional Access Operations

    @SuppressWarnings("unchecked")
    E elementData(int index) {
        return (E) elementData[index];
    }

    //返回此列表中指定位置上的元素
    public E get(int index) {
        rangeCheck(index);
        return elementData(index);
    }

    //用指定的元素替代此列表中指定位置上的元素
    public E set(int index, E element) {
        rangeCheck(index);

        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }
    //将指定的元素添加到此列表的尾部
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
    // 将指定的元素插入此列表中的指定位置
    public void add(int index, E element) {
        rangeCheckForAdd(index);

        ensureCapacityInternal(size + 1);  // Increments modCount!!
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
    }

     //移除此列表中指定位置上的元素
    public E remove(int index) {
        rangeCheck(index);

        modCount++;
        E oldValue = elementData(index);

        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work

        return oldValue;
    }

    //删除ArrayList中指定的元素
    public boolean remove(Object o) {
        if (o == null) {
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                    fastRemove(index);
                    return true;
                }
        } else {
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }

       //快速删除，跳过边界检查且没有返回值
    private void fastRemove(int index) {
        modCount++;
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work
    }

      //移除此列表中所有元素
    public void clear() {
        modCount++;

        // clear to let GC do its work
        for (int i = 0; i < size; i++)
            elementData[i] = null;

        size = 0;
    }

    //将集合C中的所有元素添加到此列表的尾部
    public boolean addAll(Collection<? extends E> c) {
        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);  // Increments modCount
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;
        return numNew != 0;

    //从指定的位置开始，将指定 collection 中的所有元素插入到此列表中
    public boolean addAll(int index, Collection<? extends E> c) {
        rangeCheckForAdd(index);
        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);  // Increments modCount
        int numMoved = size - index;
        if (numMoved > 0)
        System.arraycopy(elementData, index, elementData, index + numNew,
                             numMoved);
        System.arraycopy(a, 0, elementData, index, numNew);
        size += numNew;
        return numNew != 0;
    }

    //除从fromIndex到toIndex之间的数据，不包括toIndex位置的数据
    protected void removeRange(int fromIndex, int toIndex) {
        modCount++;
        int numMoved = size - toIndex;
        System.arraycopy(elementData, toIndex, elementData, fromIndex,
                         numMoved);

        // clear to let GC do its work
        int newSize = size - (toIndex-fromIndex);
        for (int i = newSize; i < size; i++) {
            elementData[i] = null;
        }
        size = newSize;
    }

    //范围检查
    private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

      //由add和addAll使用的rangeCheck的一个版本
    private void rangeCheckForAdd(int index) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

    private String outOfBoundsMsg(int index) {
        return "Index: "+index+", Size: "+size;
    }

    //删除ArrayList中所有集合C中包含的数据
    public boolean removeAll(Collection<?> c) {
        Objects.requireNonNull(c);
        return batchRemove(c, false);
    }

    //删除ArrayList中除了集合C中包含的数据外的其他所有数据
    public boolean retainAll(Collection<?> c) {
        Objects.requireNonNull(c);
        return batchRemove(c, true);
    }
    //批量删除
    private boolean batchRemove(Collection<?> c, boolean complement) {
        final Object[] elementData = this.elementData;
        int r = 0, w = 0;
        boolean modified = false;
        try {
            for (; r < size; r++)
                if (c.contains(elementData[r]) == complement)
                    elementData[w++] = elementData[r];
        } finally {
      //保留与AbstractCollection的行为兼容性
            if (r != size) {
                System.arraycopy(elementData, r,
                                 elementData, w,
                                 size - r);
                w += size - r;
            }
            if (w != size) {
                // clear to let GC do its work
                for (int i = w; i < size; i++)
                    elementData[i] = null;
                modCount += size - w;
                size = w;
                modified = true;
            }
        }
        return modified;
    }
/************ ArrayList与IO *********/

//将ArrayList的容量和元素都写入到输出流中
private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException{
        int expectedModCount = modCount;
        s.defaultWriteObject();
        s.writeInt(size);
        for (int i=0; i<size; i++) {
            s.writeObject(elementData[i]);
        }

        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
    }

    //先将ArrayList的“容量”读出，然后将“所有的元素值”读出 
    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        elementData = EMPTY_ELEMENTDATA;
        s.defaultReadObject();

        s.readInt(); 

        if (size > 0) {
            ensureCapacityInternal(size);

            Object[] a = elementData;

            for (int i=0; i<size; i++) {
                a[i] = s.readObject();
            }
        }
    }

注意： ArrayList循环遍历并删除元素的常见错误

错误一、
public static void main(String[] args){
    List<String> list = new ArrayList<String>();
    list.add("刘备");
    list.add("关羽");
    list.add("张飞");
    for (String s:list){
        list.remove(s);
    }
}

这里写图片描述
错误原因：foreach写法是对迭代器的简写，我们的remove方法修改了modCount的值

   public E remove(int index) {
        rangeCheck(index);

        modCount++;
        E oldValue = elementData(index);

        int numMoved = size - index - 1;
        if (numMoved > 0)
    System.arraycopy(elementData, index+1, elementData, index,
numMoved);
        elementData[--size] = null; // clear to let GC do its work

        return oldValue;
    }

父类AbstractList checkForComodification方法

final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

这里会做迭代器内部修改次数检查，如果检查到不相等则抛出异常。要避免这种情况的出现则在使用迭代器迭代时（显示或for-each的隐式）不要使用ArrayList的remove，改为用Iterator的remove即可。

错误二、
public static void main(String[] args){
    ArrayList<Integer> list = new ArrayList<>();
    list.add(1);
    list.add(2);
    list.add(3);
    for(int i=0;i<list.size();i++){
        System.out.println(list.get(i));
    }
}

这里写图片描述
错误原因：每删除一个元素时，它后面的一个元素会向前移一位

    public E remove(int index) {
        rangeCheck(index);

        modCount++;
        E oldValue = elementData(index);

        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,numMoved);
        elementData[--size] = null; // clear to let GC do its work

        return oldValue;
    }

这种情况可以用倒序删除来解决。

Java之集合——详细概括和ArrayList的底层源码解析
2202_75483664的博客
07-19 1140
目录一、集合的家族谱1.List2. Set3.Map4.Collection接口的方法（List、Set实现类通用）5.Map接口实现方法（Map实现类通用）二、ArrayList底层原码的详解1.前菜 2.底层原码解析示例代码(1)概况​编辑 (2)源码用到的常量和变量(3)分步源码详解A. ArrayList list = new ArrayList<>();B.第一层for循环 list.add(0);C.剩下九层循环list.add(i);
java arrayList遍历的四种方法及Java中ArrayList类的用法
09-03
arraylist是动态数组，它具有三个好处分别是:动态的增加和减少元素 、实现了ICollection和IList接口、灵活的设置数组的大小，本文给大家介绍java arraylist遍历及Java arraylist 用法，感兴趣的朋友一起学习吧
Java 集合系列 03 ArrayList详细介绍(源码解析)和使用示例
weixin_30695195的博客
04-28 261
java 集合系列目录： Java 集合系列 01 总体框架 Java 集合系列 02 Collection架构 Java 集合系列 03 ArrayList详细介绍(源码解析)和使用示例 Java 集合系列 04 LinkedList详细介绍(源码解析)和使用示例 Java 集合系列 05 Vector详细介绍(源码解析)和使用示例 Java 集合系列 06 Stack详细介绍(源...
ArrayList用法详解与源码分析
weixin_33795093的博客
11-09 125
说明 此文章分两部分，1.ArrayList用法。2.源码分析。先用法后分析是为了以后忘了查阅起来方便～～ ArrayList 基本用法 1.创建ArrayList对象 //创建默认容量的数组列表（默认为10） ArrayList<E> a = new ArrayList<E>(); //创建容量为initialCapacity的数组列表 Ar...
Java ArrayList的使用方法教程及示例代码
亮亮的专栏
06-22 151
ArrayList 是一个数组队列，相当于 动态数组。与Java中的数组相比，它的容量能动态增长。它继承于AbstractList，实现了List, RandomAccess, Cloneable, java.io.Serializable这些接口。本文主要介绍Java ArrayList的使用方法教程及示例代码 原文地址：Java ArrayList的使用方法教程及示例代码 ...
简单介绍ArrayList的使用方法及源码分析
qq_52972504的博客
08-01 319
ArrayList 的底层是数组队列，相当于动态数组。与 Java 中的数组相比，它的容量能动态增长。在添加大量元素前，应用程序可以使用ensureCapacity 操作来增加 ArrayList 实例的容量。这可以减少递增式再分配的数量。...
ArrayList的使用及源码解析
接受自己的普通，然后拼尽全力去与众不同
08-06 607
1. 简介 不管是做Android开发还是做Java开发，都会经常使用到ArrayList 。ArrayList底层基于数组实现容量大小动态变化。下面将介绍ArrayList的使用以及分析ArrayList的源码，从而对ArrayList有一个深入的理解。 2. ArrayList的使用 先看以下实例： package zzw.cn.listtest; import java.util...
Java中ArrayList类的用法与源码完全解析
09-02
这里我们将深入探讨ArrayList的用法和源码解析。 首先，ArrayList的主要优点在于它的灵活性。由于它是动态的，当需要添加或删除元素时，ArrayList会自动调整其容量以适应变化。这意味着你可以在任何位置插入或移除...
Java ArrayList泛型源码示例解析
在给定的文件信息中，标题“javaarraylist源码-contoh_generics”以及描述明确指出：这是一个通过使用用户自定义数据类型并结合泛型机制来演示Java中ArrayList工作原理的源代码示例程序。“contoh_generics”一词...
VB2010中ArrayList类的使用源码解析
在描述中提到“关于arraylist相关用法”，这表明整个源码的核心内容围绕着ArrayList的各种常用方法、属性及其实际应用场景展开。具体来说，ArrayList具备如下关键特性：第一，它是动态增长的数组，初始容量可以设定...
详解Java ArrayList类：用法与源码深度剖析
"本文将深入解析Java中ArrayList类的用法及其源码细节，ArrayList作为List接口的实现，是一种动态数组，适用于需要频繁增删元素的场景。本文首先概述了ArrayList的主要特点：支持动态扩容、灵活插入和删除元素，但相...
你真的知道ArrayList的使用和实现吗？
爱敲代码的三毛的博客
08-08 300
文章目录一、ArrayList是什么？二、通过源码了解ArrayList常用的方法1.ArrayList的创建2.add方法3.addAll方法4.remove方法5.subList方法总结 一、ArrayList是什么？ ArrayList 是 Java 集合框架中比较常用的数据结构，底层是一个顺序表也就是一个数组，那么它和数组最大的区别就是数组的长度是定长，而ArrayList 底层的数组是可以自动增长的。同时 ArrayList 实现了List接口。 二、通过源码了解ArrayList常用的方法
ArrayList 的常见用法及对应源码介绍
liuyuanq123的博客
03-29 434
1、介绍 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;ArrayList其实就是对数组的封装，在数组的基础上实现了很多功能，增删改查等，是一个动态数组，它继承了AbstractList抽象类，实现了List, RandomAccess, Cloneable, java.io.Serializable这些接口。 2、使用 &nbsp;&nbsp;&nbsp;...
数据结构与算法--使用Java实现ArrayList
....
03-23 779
本篇博客要点如下: 数组简介 基本概念 存储结构 使用Java代码实现ArrayList List接口 实现ArrayList 构造方法 获取集合大小 获取集合元素 判断集合是否包含指定元素 判断集合是否为空 集合数据插入 集合数据删除 集合数据替换 一. 数组简介 众所周知,ArrayList的底层是数组. 因此,在实现ArrayList之前,我们有必要对数组做一个基本的了解 ...
java数据结构篇-ArrayList使用和源码分析
weixin_45898658的博客
06-11 443
这篇文章我参考了前辈们的一些博客文，在他们的基础上加上自己的一些理解并且进行了整理 ArrayList定义 ArrayList 底层是数组列表，当我们存储基本数据类型int、long、boolean …只能存储他们对应的包装类他们底层实现是数组Object[]elementData 相比于LinkList 它的查找和访问元素速度较快，但新增、删除的数据慢 我们来看看源码注释对ArrayList的官方解释 1.这类实现了List接口，可实现底层数组的大小的调整 2.运用了泛型允许所有类型的元素存储，包括nul
java常用类---ArrayList 源码分析及用法
wuyundong123的博客
10-10 225
整体理解 ArrayList就是一个数组结构；允许null值，非线程安全； 常用的属性除了index和elementData外，下面几个也需要特别注意： private static final int DEFAULT_CAPACITY = 10; private int size; transient Object[] elementData; // non-private to sim...
ArrayList
qq_43602877的博客
03-19 228
面试的时候又说到这个，没事就整理了一下，有一些地方不是很清楚，但是大概也就是这么些知识点了 1、是什么 ​ Array是实现原理就是数组（动态数组），容量能够动态的增长 2、效率如何 ​ ArrayList不是线程安全的，所以效率比较高 3、继承哪些类和实现哪些类 ​ ArrayList主要继承了AbstractList类，实现了List，RandomAccess，Cloneable，Serializable接口 ​ RandomAccess：他就是一个标志接口，支持快速随机访问。在Collections里
Arraylist的基本使用方法
热门推荐
m0_59392076的博客
05-15 6万+
目录 前言 Arraylist 是javase基础中重要的知识点，以后在工作中也可能常常用到。 一、Arraylist是什么？ 二、使用步骤 1.ArrayList 类位于 java.util 包中，使用前需要引入它，语法格式如下： 2.添加元素 3.删除元素 4.计算大小 5.其他的引用类型 6.ArrayList 排序 7.Java ArrayList 方法 Arraylist 是javase基础中重要的知识点，以后在工作中也可能常常用到。 提示：以下是...
什么是 ArrayList
weixin_33826268的博客
02-24 3075
简介 ArrayList 是 java 集合框架中比较常用的数据结构了。继承自 AbstractList，实现了 List 接口。底层基于数组实现容量大小动态变化。允许 null 的存在。同时还实现了 RandomAccess、Cloneable、Serializable 接口，所以ArrayList 是支持快速访问、复制、序列化的。 成员变量 ArrayList 底层是基于数组来实现容量大小动态...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值