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

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



一.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()+" ");//打印前一个
        }
    }


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

目录
打赏
0
2
2
0
45
分享
相关文章
|
4月前
|
让星星⭐月亮告诉你,LinkedList和ArrayList底层数据结构及方法源码说明
`LinkedList` 和 `ArrayList` 是 Java 中两种常见的列表实现。`LinkedList` 基于双向链表,适合频繁的插入和删除操作,但按索引访问元素效率较低。`ArrayList` 基于动态数组,支持快速随机访问,但在中间位置插入或删除元素时性能较差。两者均实现了 `List` 接口,`LinkedList` 还额外实现了 `Deque` 接口,提供了更多队列操作。
39 3
|
4月前
|
HashMap之链表转红黑树(树化 )-treefyBin方法源码解读(所有涉及到的方法均有详细解读,欢迎指正)
本文详细解析了Java HashMap中链表转红黑树的机制,包括树化条件(链表长度达8且数组长度≥64)及转换流程,确保高效处理大量数据。
149 1
揭秘!HashMap底层结构大起底:从数组到链表,再到红黑树,Java性能优化的秘密武器!
【8月更文挑战第24天】HashMap是Java集合框架中的核心组件,以其高效的键值对存储和快速访问能力广受开发者欢迎。在JDK 1.8及以后版本中,HashMap采用了数组+链表+红黑树的混合结构,实现了高性能的同时解决了哈希冲突问题。数组作为基石确保了快速定位;链表则用于处理哈希冲突;而当链表长度达到一定阈值时,通过转换为红黑树进一步提升性能。此外,HashMap还具备动态扩容机制,当负载因子超过预设值时自动扩大容量并重新哈希,确保整体性能。通过对HashMap底层结构的深入了解,我们可以更好地利用其优势解决实际开发中的问题。
155 0
如何删除 HashMap 中的重复元素?—— 99% 的人不知道的第 3 种实现思路
如何删除 HashMap 中的重复元素?—— 99% 的人不知道的第 3 种实现思路
49 0
Java数组操作:基础与进阶指南
Java数组操作:基础与进阶指南
|
8月前
数据结构初阶 链表的补充
数据结构初阶 链表的补充
41 0
|
8月前
|
数据结构和算法学习记录——习题-移除元素
数据结构和算法学习记录——习题-移除元素
39 0
什么是数组,什么是对象,并说出他们的区别
什么是数组,什么是对象,并说出他们的区别
56 6
【蓝桥杯Java_C组·从零开始卷】第八节、集合——list详解(ArrayList、 LinkedList 和 Vector之间的区别)
【蓝桥杯Java_C组·从零开始卷】第八节、集合——list详解(ArrayList、 LinkedList 和 Vector之间的区别)
122 0
【蓝桥杯Java_C组·从零开始卷】第八节、集合——list详解(ArrayList、 LinkedList 和 Vector之间的区别)
AI助理

你好,我是AI助理

可以解答问题、推荐解决方案等