快邀请你的冤种朋友一起来学习顺序表的底层逻辑：ArrayList集合

进来了就一起来学习如何去使用ArrayList这个集合吧！ 

目录

一.ArrayList是什么

二.ArrayList的构造方法与扩容机制

 1.无参构造方法与扩容机制

2.带参数的构造方法

3.利用其他 Collection 构建 ArrayList

三.ArrayList常用方法介绍

1.插入数据方法

2.boolean contains(Object o) 方法

3.List subList(int fromIndex, int toIndex) 方法

4.remove方法

四.ArrayList的遍历方式

1.for循环遍历

2.使用迭代器遍历

---

一.ArrayList是什么

（1）为什么说ArrayList是一个动态顺序表

• ArrayList底层是一段连续的空间，并且可以动态扩容，所以是一个动态的顺序表
• 我们知道，我们实现顺序表的话，需要自己写它增删查改的方法，然后再调用；而ArrayList可以看作是一个已经实现好的顺序表，我们可以直接调用和使用

（2）从实现方面理解ArrayList

• ArrayList是一个类，并且是一个泛型类（限制类型的作用），类中有许许多多的方法（可以类比String类）
• 泛型类，所以使用的时候必须实例化

ArrayList<Integer> arrayList = new ArrayList<>();//实例化操作

（3）ArrayList实现的接口及拥有的功能 

• ArryList实现了List接口，List是一个线性表，所以ArrayList就具备了顺序表的功能（本节重点）

•  ArrayList实现了RandomAccess接口，表明ArrayList支持随机访问
• ArrayList实现了Cloneable接口，表明ArrayList是可以clone的
• ArrayList实现了Serializable接口，表明ArrayList是支持序列化的

（4）简单使用ArrayList

• 常规的实例化

格式：ArrayList<类型>  引用  =  new  ArrayList<>() 

ArrayList<Integer> arrayList = new ArrayList<>();//实例化操作
ArrayList<String> arrayList1 = new ArrayList<>();

• 使用向上转型实例化

格式：List<类型>  引用  =  new  ArrayList<>()

List<Integer> list = new ArrayList<>();
List<String> list2 = new ArrayList<>();

• 简单的添加数据和打印

 public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(3);
        list.add(1);
        list.add(4);
        list.add(5);
        list.add(2);
        list.add(0);
        System.out.println(list);
    }

二.ArrayList的构造方法与扩容机制

构造方法：

ArrayList()	无参构造
ArrayList(int initialCapacity)	指定顺序表初始容量
ArrayList(Collection<? extends E> c)	利用其他 Collection 构建 ArrayList

ArrayList的成员变量：

private static final int DEFAULT_CAPACITY = 10;
private static final Object[] EMPTY_ELEMENTDATA = {};
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
transient Object[] elementData;
private int size;//记录当前顺序的大小

 1.无参构造方法与扩容机制

（1）认识和使用无参构造方法

• 无参的构造方法是这样实例化对象的

ArrayList<Integer> arrayList = new ArrayList<>();

• 原码的无参构造方法

 public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

（2）如何执行无参构造方法

从上面我们可以得到一个结论： 

 结论一：使用无参构造方法实例化对象时，是没有给顺序表分配内存空间的

（3）扩容机制

• 先看一段代码

 public static void main(String[] args) {
        ArrayList<Integer> arrayList1 = new ArrayList<>();
        arrayList1.add(1);
        arrayList1.add(2);
        System.out.println(arrayList1);
    }

提出一个疑问？明明没有对该顺序表分配内存空间，为什么还可以对其赋值呢？下面走进add的原码一看究竟

• 查看add的工作原理及增容机制

由上面我们可以得出结论：

结论二：第一次add（第一次增容）时，默认分配10的内存空间

• 进行扩容操作的适时候

结论三：当扩容时，会按原内存的1.5倍进行扩容

2.带参数的构造方法

（1）认识和使用带参构造方法

• 指定容量是是这样实例化对象的

 ArrayList<Integer> arrayList = new ArrayList<>(15);//指定开辟15个空间

• 查看带参数的构造方法原码

  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);
        }
    }

 （2）如何执行构造方法

• 当参数为负数时：运行时抛异常

3.利用其他 Collection 构建 ArrayList

这种构造方法是什么意思呢？也就是将其他的顺序表作为参数，下面一起来看看吧

（1）认识和使用该种构造方法

•  使用该方法实例化对象

 public static void main(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(520);
        arrayList.add(1314);
        ArrayList<Integer> arrayList1 = new ArrayList<>(arrayList);//第三种构造方式
        System.out.println(arrayList1);
    }

• 认识该构造方法的原码

public ArrayList(Collection<? extends E> c) {
        Object[] a = c.toArray();
        if ((size = a.length) != 0) {
            if (c.getClass() == ArrayList.class) {
                elementData = a;
            } else {
                elementData = Arrays.copyOf(a, size, Object[].class);
            }
        } else {
            // replace with empty array.
            elementData = EMPTY_ELEMENTDATA;
        }
    }

（2）认识原码的工作原理

• 原码 

• 参数需要满足的条件 

（3）使用该构造方法及错误原因

• 通用的

  public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        List<Integer> list2 = new ArrayList<>(list);
        ArrayList<Integer> list3 = new ArrayList<>(list2);
        List<Integer> list4 = new ArrayList<>(list3);
        ArrayList<Number>  list5 = new ArrayList<>(list4);
    }

• 错误案例

三.ArrayList常用方法介绍

常用的方法表格，如下所示：

方法	功能
boolean add(E e)	尾插 e
void add(int index, E element)	将 e 插入到 index 位置
boolean addAll(Collection<? extends E> c)	尾插 c 中的元素
E remove(int index)	删除 index 位置元素并返回该元素
boolean remove(Object o)	删除遇到的第一个 o
E get(int index)	获取下标 index 位置元素
E set(int index, E element)	将下标 index 位置元素设置为 element
void clear()	清空顺序表
boolean contains(Object o)	判断 o 是否在线性表中
int indexOf(Object o)	返回第一个 o 所在下标
int lastIndexOf(Object o)	返回最后一个 o 的下标
List<E> subList(int fromIndex, int toIndex)	截取部分 list

1.插入数据方法

（1）boolean add(E e) 

默认尾插的方法

public static void main(String[] args) {
      ArrayList<Integer> arrayList = new ArrayList<>();
      arrayList.add(1);
        arrayList.add(2);
        arrayList.add(3);
        System.out.println(arrayList);
    }

（2）void add(int index, E element) 

指定位置插入数据

 public static void main(String[] args) {
      ArrayList<Integer> arrayList = new ArrayList<>();
      arrayList.add(0,9);
        arrayList.add(0,9);
        arrayList.add(0,7);
        System.out.println(arrayList);
    }

2.boolean contains(Object o) 方法

（1）方法目的：判断 o 是否在线性表中（o是一个字符串）；也就是删除线性表中的存在字符串o（字符串o中的每一个字符都不能留）

（2）方法举例

• str1 = "welcome to world"，str2 = "come"，要求，删除str1中存在的str2字符，并返回一个线性表
• 代码：

private static ArrayList<Character> func(String str1,String str2) {
        //删除str1中的str2
        ArrayList<Character> arrayList = new ArrayList<>();
        for (int i = 0; i < str1.length(); i++) {
            char ch = str1.charAt(i);
            if(!str2.contains(ch+"")) {
                arrayList.add(ch);
            }
        }
        return arrayList;
    }
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        String str1 = "welcome to world";
        String str2 = "come";
        ArrayList<Character> arrayList1 = func(str1,str2);
        System.out.println(arrayList1);

    }

• 本题细节点：字符+""（空字符串）可以变成字符串类型

3.List<E> subList(int fromIndex, int toIndex) 方法

（1）功能：截取指定范围内的数据

返回值：List接口定义的变量

（2）简单举例：

public static void main(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(10);
        arrayList.add(20);
        arrayList.add(30);
        arrayList.add(40);
        arrayList.add(50);
        System.out.println(arrayList);
        List<Integer> list = arrayList.subList(1,3);
        System.out.println(list);
    }

（3）subList的特点

• 先看一段代码

public static void main(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(10);
        arrayList.add(20);
        arrayList.add(30);
        arrayList.add(40);
        System.out.println("修改前：");
        System.out.println("arrayList:"+arrayList);

        List<Integer> list = arrayList.subList(1,3);
        System.out.println("list:"+list);

        list.set(0,999);
        list.set(0,888);

        System.out.println("修改后：");
        System.out.println("arrayList:"+arrayList);
        System.out.println("list:"+list);


    }

为什么对截取后的空间进行数据的修改？原线性表的内容也会发生同样的改变？

• 原因解释

截取后的变量，依然指向同一块空间；当修改的时候，修改的依然是原数组的内容

4.remove方法

（1）作用：删除线性表中的一个元素，并返回它的值

四.ArrayList的遍历方式

在ArrayListd的方法中，没有可以直接用来遍历的方法，但是我们可以通过自己编写的代码来遍历，如for循环等等，下面一一介绍

• 最常规的方式，直接打印

  public static  void main(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(5);
        arrayList.add(2);
        arrayList.add(0);
        System.out.println(arrayList);
}

1.for循环遍历

（1）常规for循环

求得该线性表的元素个数即可

public static void main(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(5);
        arrayList.add(2);
        arrayList.add(0);
        for (int i = 0; i < arrayList.size(); i++) {
            System.out.print(arrayList.get(i)+" ");
        }
    }

（2）加强for循环

for循环中也可可以这么写：int x : arrayList（那么里面的数据类就是发生了拆箱的操作）

 public static void main(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(5);
        arrayList.add(2);
        arrayList.add(0);
        for (Integer x:arrayList) {
            System.out.print(x+" ");
        }
    }

2.使用迭代器遍历

 可以使用迭代器遍历的前提是该集合实现了Iterable，载使用前，需要先获取线性表的迭代器

（1）从前往后迭代：Iterator接口

 public static void main(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(5);
        arrayList.add(2);
        arrayList.add(0);
        Iterator<Integer> it = arrayList.iterator();//获取到线性表的迭代器
        //开始遍历
        while(it.hasNext()) {
            System.out.print(it.next()+" ");//每次打印它的下一个
        }
    }

 图解：

（2）从前往后遍历：ListIterator接口

 public static  void main(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(5);
        arrayList.add(2);
        arrayList.add(0);
        ListIterator<Integer> it2 = arrayList.listIterator();
        while(it2.hasNext()) {
            System.out.print(it2.next()+" ");
        }
    }

与Iterator接口的关系：继承关系

（3）从后往前遍历：ListIterator接口（加参数即可）

 public static  void main(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(5);
        arrayList.add(2);
        arrayList.add(0);
        ListIterator it3 = arrayList.listIterator(arrayList.size());//让迭代器指向最后一个元素后面
        while (it3.hasPrevious()) {
            System.out.print(it3.previous()+" ");//打印前一个
        }
    }

---

本次的介绍就到这里了，小伙伴们快去试试吧