java集合—— ArrayList的介绍与基本用法

迈不过友情╰ 2022-11-08 11:52 244阅读 0赞

## 1.ArrayList概述 ##

### 简介 ###

*  ArrayList 类是一个可以动态修改的**数组**，与普通数组的区别就是它是没有固定大小的限制，我们可以添加或删除元素。
 *  ArrayList 继承了 AbstractList ，并实现了 List 接口。底层基于数组实现容量大小动态变化。允许 null的存在。同时还实现了 RandomAccess、Cloneable、Serializable 接口，所以ArrayList是支持快速访问、复制、序列化的。

### 知识点 ###

*  该类封装了一个动态再分配的Object\[\]数组，每一个类对象都有一个capacity属性，表示它们所封装的Object\[\]数组的长度，当向ArrayList中添加元素时，该属性值会自动增加。
 *  如果想ArrayList中添加大量元素，可使用ensureCapacity方法一次性增加capacity，可以减少增加重分配的次数提高性能。
 *  ArrayList的用法和Vector向类似，但是Vector是一个较老的集合，具有很多缺点，不建议使用。
 *  ArrayList和Vector的区别是：ArrayList是线程不安全的，当多条线程访问同一个ArrayList集合时，程序需要手动保证该集合的同步性，而Vector则是线程安全的。
 *  ArrayList的iterator和listIterator方法返回的迭代器是fail-fast的

### ArrayList数据结构 ###

![在这里插入图片描述][20210313172640624.png]  
容量：CAPACITY ； 实际大小：size；  
ArrayList底层的数据结构就是数组，数组元素类型为Object类型，即可以存放所有类型数据。我们对ArrayList类的实例的所有的操作底层都是基于数组的。

## 2.ArrayList源码分析 ##

### ArrayList继承结构和层次关系 ###

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhaGFfNw_size_16_color_FFFFFF_t_70]

1.  继承了AbstractList。[为什么要先继承AbstractList，而让AbstractList先实现List？而不是让ArrayList直接实现List？][AbstractList_AbstractList_List_ArrayList_List]  
    接口中全都是抽象的方法，而抽象类中可以有抽象方法，还可以有具体的实现方法，正是利用了这一点，让AbstractList是实现接口中一些通用的方法，而具体的类，如ArrayList就继承这个AbstractList类，拿到一些通用的方法，然后自己在实现一些自己特有的方法，这样一来，让代码更简洁，就继承结构最底层的类中通用的方法都抽取出来，先一起实现了，减少重复代码
2.  实现了Cloneable接口，就可以使用Object.Clone()方法了。
3.  implements  
    java.io.Serializable：表明该类具有序列化功能，该类可以被序列化，什么是序列化？简单的说，就是能够从类变成字节流传输，然后还能从字节流变成原来的类。

### 成员变量 ###

/**
    * The size of the ArrayList (the number of elements it contains).
    */
    private int size;  // 实际元素个数，size 是指 elementData 中实际有多少个元素，而 elementData.length 为集合容量，表示最多可以容纳多少个元素。
    transient Object[] elementData; 
    
    /**
    * Default initial capacity.
    */
    private static final int DEFAULT_CAPACITY = 10;//默认初始容量大小为 10;
    
    protected transient int modCount = 0;//这个变量是定义在 AbstractList 中的。记录对 List 操作的次数。主要使用是在 Iterator，是防止在迭代的过程中集合被修改。
    
    //下面两个变量是用在构造函数里面的
    /**
    * Shared empty array instance used for empty instances.
    */
    private static final Object[] EMPTY_ELEMENTDATA = {
        };
    
    /**
    * Shared empty array instance used for default sized empty instances. We
    * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
    * first element is added.
    */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {
        };
    //两个空的数组有什么区别呢？ We distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when first element is added. 简单来讲就是第一次添加元素时知道该 elementData 从空的构造函数还是有参构造函数被初始化的。以便确认如何扩容。

### 构造函数 ###

**无参构造函数**

public ArrayList() {
        
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
    //构造一个容量大小为 10 的空的 list 集合，但构造函数了只是给 elementData 赋值了一个空的数组，其实是在第一次添加元素时容量扩大至 10 的。

**构造一个初始容量大小为 initialCapacity 的 ArrayList**

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);
        }
    }
    /*初始容量大于0,实例化数组，将自定义的容量大小当成初始化elementData的大小
    初始容量等于0，将空数组赋给elementData
    初始容量小于0，抛异常

**使用指定 Collection 来构造 ArrayList 的构造函数**

*  ArrayList(Collection<? extends E> c)：构造一个包含指定 collection的元素的列表，这些元素是按照该 collection的迭代器返回它们的顺序排列的。第二个有参构造方法构造时赋的值是它的父类Collection对象。
 *  将collection对象转换成数组，然后将数组的地址的赋给elementData。
 *  如果数组的实际大小等于0（c中没有元素），将空数组EMPTY\_ELEMENTDATA赋值给elementData
 *  如果size的值大于0，则执行Arrays.copy方法，把collection对象的内容（可以理解为深拷贝）copy到elementData中。

public ArrayList(Collection<? extends E> c) {
        
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
        
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            //每个集合的toarray()的实现方法不一样，所以需要判断一下，如果不是Object[].class类型，那么就需要使用ArrayList中的方法去改造一下。
            if (elementData.getClass() != Object[].class)
            //copyOf(要复制的数组,要返回的副本的长度,要返回的副本的类)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
        
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }
    //ArrayList的构造方法就做一件事情，就是初始化一下储存数据的容器，其实本质上就是一个数组，在其中就叫elementData。

## 3.主要操作方法 ##

这里只写如何使用，方法的源码分析参考[文章1][1]和[文章2][2]

#### add() 方法：添加元素 ####

import java.util.ArrayList;
    
    public class RunTest {
        
        public static void main(String[] args) {
        
            ArrayList<String> sites = new ArrayList<String>();
            sites.add("a");
            sites.add("b");
            sites.add("c");
            sites.add("d");
            System.out.println(sites);
        }
    }
    以上实例，执行输出结果为：[a, b, c, d]

### get() 方法：访问元素 ###

import java.util.ArrayList;
    
    public class RunTest {
        
        public static void main(String[] args) {
        
            ArrayList<String> sites = new ArrayList<String>();
            sites.add("a");
            sites.add("b");
            sites.add("c");
            sites.add("d");
            System.out.println(sites.get(1));  // 访问第二个元素
        }
    }
    注意：数组的索引值从 0 开始。
    以上实例，执行输出结果为：b

### set() 方法：修改元素 ###

mport java.util.ArrayList;
    
    public class RunTest {
        
        public static void main(String[] args) {
        
            ArrayList<String> sites = new ArrayList<String>();
            sites.add("a");
            sites.add("b");
            sites.add("c");
            sites.add("d");
            sites.set(2, "hello"); // 第一个参数为索引位置，第二个为要修改的值
            System.out.println(sites);
        }
    }
    以上实例，执行输出结果为：[a, b, hello, d]

### remove() 方法：删除元素 ###

sites.remove(3); // 删除第四个元素

### 迭代数组列表 ###

import java.util.ArrayList;
    
    public class RunoobTest {
        
        public static void main(String[] args) {
        
            ArrayList<String> sites = new ArrayList<String>();
            sites.add("a");
            sites.add("b");
            sites.add("c");
            sites.add("d");
            for (int i = 0; i < sites.size(); i++) {
        
                System.out.println(sites.get(i));
            }
        }
    }

### 使用 ArrayList 存储数字(使用 Integer 类型): ###

import java.util.ArrayList;
    
    public class RunoobTest {
        
        public static void main(String[] args) {
        
            ArrayList<Integer> myNumbers = new ArrayList<Integer>();
            myNumbers.add(10);
            myNumbers.add(15);
            myNumbers.add(20);
            myNumbers.add(25);
            for (int i : myNumbers) {
        
                System.out.println(i);
            }
        }
    }
    以上实例，执行输出结果为：
    10
    15
    20
    25

### ArrayList 排序 ###

对字母排序

import java.util.ArrayList;
    import java.util.Collections;  // 引入 Collections 类
    
    public class RunoobTest {
        
        public static void main(String[] args) {
        
            ArrayList<String> sites = new ArrayList<String>();
            sites.add("Taobao");
            sites.add("Wiki");
            sites.add("Runoob");
            sites.add("Weibo");
            sites.add("Google");
            Collections.sort(sites);  // 字母排序
            for (String i : sites) {
        
                System.out.println(i);
            }
        }
    }
    以上实例，执行输出结果为：
    Google
    Runoob
    Taobao
    Weibo
    Wiki

对数字排序

import java.util.ArrayList;
    import java.util.Collections;  // 引入 Collections 类
    
    public class RunoobTest {
        
        public static void main(String[] args) {
        
            ArrayList<Integer> myNumbers = new ArrayList<Integer>();
            myNumbers.add(33);
            myNumbers.add(15);
            myNumbers.add(20);
            myNumbers.add(34);
            myNumbers.add(8);
            myNumbers.add(12);
    
            Collections.sort(myNumbers);  // 数字排序
    
            for (int i : myNumbers) {
        
                System.out.println(i);
            }
        }
    }
    以上实例，执行输出结果为：
    8
    12
    15
    20
    33
    34

更多 API 方法可以查看：[https://www.runoob.com/manual/jdk11api/java.base/java/util/ArrayList.html][https_www.runoob.com_manual_jdk11api_java.base_java_util_ArrayList.html]

感谢参考：[https://stackoverflow.com/questions/2165204/why-does-linkedhashsete-extend-hashsete-and-implement-sete][https_stackoverflow.com_questions_2165204_why-does-linkedhashsete-extend-hashsete-and-implement-sete]  
[https://blog.csdn.net/u010250240/article/details/89762912][2]

[20210313172640624.png]: /images/20221023/4fbcc0d70ce04bcb8c7c79c0702d5880.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hhaGFfNw_size_16_color_FFFFFF_t_70]: /images/20221023/1125da4167c747aa915d390ffe6c1957.png
[AbstractList_AbstractList_List_ArrayList_List]: https://www.cnblogs.com/zhangyinhua/p/7687377.html#_label2
[1]: https://blog.csdn.net/sihai12345/article/details/79382649
[2]: https://blog.csdn.net/u010250240/article/details/89762912
[https_www.runoob.com_manual_jdk11api_java.base_java_util_ArrayList.html]: https://www.runoob.com/manual/jdk11api/java.base/java/util/ArrayList.html
[https_stackoverflow.com_questions_2165204_why-does-linkedhashsete-extend-hashsete-and-implement-sete]: https://stackoverflow.com/questions/2165204/why-does-linkedhashsete-extend-hashsete-and-implement-sete