Java数据结构之ArrayList(如果想知道Java中有关ArrayList的知识点,那么只看这一篇就足够了!)

简介: Java数据结构之ArrayList(如果想知道Java中有关ArrayList的知识点,那么只看这一篇就足够了!)

1.认识ArrayList

       在正式的学习ArrayList之前,我们需要了解一下什么是Java中的ArrayList(顺序表):

       ArrayList是Java中的一个动态数组类,它实现了List接口,可以存储任意类型的对象,并且大小可以动态地调整。ArrayList允许在列表的任意位置进行元素的插入、删除、获取等操作,而且它还能自动扩展内部数组的容量,以适应存储需求的增长。

ArrayList是一个普通的类,实现了List接口,具体框架图如下:

读到这就会有读者发问了,ArrayList到底是怎么去实现这些功能的呢?,它的底层原理到底是怎么样的呢?答案如下:

ArrayList的实现原理:

       ArrayList的内部实现是基于数组的,它使用一个Object类型的数组来存储元素。当创建一个ArrayList实例时,会初始化一个默认大小的数组,当数组容量不足以存储新的元素时,ArrayList会自动扩展数组的大小,通常会将当前数组的容量增加一倍,并将原来的元素复制到新数组中,当然其他的操作也是类似。

通过上面的描述,我们就大致的了解了Java中ArrayList(顺序表)了。

2.ArrayList的创建

       了解完了Java中ArrayList(顺序表),那么我们如何去创建并使用它呢?在Java中给我们提供了三种创建ArrayList(顺序表)的方式。

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

现在让我们使用三种不同的方式来创建一下ArrayList(顺序表):

 

(1)使用默认构造函数创建一个空的 ArrayList:

import java.util.ArrayList;
 
public class Main {
    public static void main(String[] args) {
        // 创建一个空的 ArrayList
        ArrayList<String> list1 = new ArrayList<>();
        
        // 添加元素到 ArrayList(这里可以先看一下就可以)
        list1.add("Apple");
        list1.add("Banana");
        list1.add("Orange");
        
        // 打印 ArrayList
        System.out.println("ArrayList 1: " + list1);
    }
}

(2)使用带有初始容量的构造函数创建 ArrayList:

import java.util.ArrayList;
 
public class Main {
    public static void main(String[] args) {
        // 创建一个具有初始容量的 ArrayList
        ArrayList<Integer> list2 = new ArrayList<>(5);
        
        // 添加元素到 ArrayList(这里先看一下就可以)
        list2.add(10);
        list2.add(20);
        list2.add(30);
        
        // 打印 ArrayList
        System.out.println("ArrayList 2: " + list2);
    }
}

(3)使用 ArrayList(Collection<? extends E> c) 构造函数创建 ArrayList 的简单示例:

import java.util.ArrayList;
import java.util.List;
 
public class Main {
    public static void main(String[] args) {
        // 创建一个包含初始元素的集合
        List<String> originalList = new ArrayList<>();
        originalList.add("Apple");
        originalList.add("Banana");
        originalList.add("Orange");
        
        // 使用原始集合创建一个新的 ArrayList
        ArrayList<String> newList = new ArrayList<>(originalList);
        
        // 打印新的 ArrayList
        System.out.println("New ArrayList: " + newList);
    }
}

这样我们就了解了如何在Java中创建ArrayList(顺序表)了。

3.ArrayList的遍历

       在认识ArrayList的段落中,我们知道了ArrayList的底层是一个动态数组,既然是数组的话,我们是不是可以像遍历数组一样遍历ArrayList呢?答案是——是的,但是在此之上我们还可以使用迭代器对其进行遍历。

遍历ArrayList的方式:

       (1)使用for循环

for (int i = 0; i < list.size(); i++) {
    int element = list.get(i);
    System.out.println(element);
}

       (2)使用增强型for循环:

for (int element : list) {
    System.out.println(element);
}

     

       (3)使用迭代器

Iterator<Integer> iterator = list.iterator();
while (iterator.hasNext()) {
    int element = iterator.next();
    System.out.println(element);
}

       以上就是三种遍历Java中ArrayList的方式,每种方式都有其适用的场景,我们需要根据实际需求选择最合适的方式来遍历ArrayList对象。

4.ArrayList常用API

       在上文中,我们大致的了解了什么是Java中的ArrayList,以及学会了创建和遍历Java中的ArrayList,现在让我们学习一下Java中提供给我们的ArrayList中的常用API。

先让我们看一下有哪些常用的ArrayList中的API:

常用方法 解释
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)boolean add(E e)——尾插 e

import java.util.ArrayList;
 
public class Main {
    public static void main(String[] args) {
        // 创建一个空的 ArrayList
        ArrayList<String> list = new ArrayList<>();
        
        // 向 ArrayList 中添加元素
        list.add("Apple");
        
        // 打印添加操作的结果
        System.out.println(list); // 输出:Apple
    }
}

       在这个示例中,我们创建了一个空的 ArrayList,然后使用 add() 方法向其中添加了一个元素 "Apple",最后打印了list。

     

       (2)void add(int index, E element)——将 e 插入到 index 位置

import java.util.ArrayList;
 
public class Main {
    public static void main(String[] args) {
        // 创建一个空的 ArrayList
        ArrayList<String> list = new ArrayList<>();
        
        // 向 ArrayList 中指定位置添加元素
        list.add("Apple");
        list.add("Banana");
        list.add("Orange");
        System.out.println(list); // 输出:[Apple, Banana, Orange]
        
        list.add(1, "Grapes"); // 在索引 1 处添加元素 "Grapes"
        
        // 打印添加后的 ArrayList
        System.out.println(list); // 输出:[Apple, Grapes, Banana, Orange]
    }
}

       在这个示例中,我们创建了一个空的 ArrayList,然后使用 add() 方法向其中添加了三个元素:"Apple"、"Banana" 和 "Orange"。接着,我们使用 add(int index, E element) 方法在索引 1 处添加了元素 "Grapes"。最后,我们打印了添加后的 ArrayList,可以看到 "Grapes" 被成功添加到了索引 1 处。

       (3)boolean addAll(Collection<? extends E> c)——尾插 c 中的元素

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
 
public class Main {
    public static void main(String[] args) {
        // 创建一个空的 ArrayList
        ArrayList<String> list1 = new ArrayList<>();
        list1.add("Apple");
        list1.add("Banana");
        
        // 创建一个包含元素的集合
        List<String> elementsToAdd = Arrays.asList("Orange", "Grapes");
        
        // 使用 addAll() 方法将集合中的元素添加到 ArrayList 中
        list1.addAll(elementsToAdd);   
       
        // 打印最终的 ArrayList
        System.out.println(list1); // 输出:[Apple, Banana, Orange, Grapes]
    }
}

       在这个示例中,我们创建了一个空的 ArrayList,然后向其中添加了两个元素:"Apple" 和 "Banana"。接着,我们创建了一个包含两个元素的集合 elementsToAdd。最后,我们使用 addAll() 方法将集合 elementsToAdd 中的元素添加到 ArrayList 中。

       (4)E remove(int index)——删除 index 位置元素

import java.util.ArrayList;
 
public class Main {
    public static void main(String[] args) {
        // 创建一个包含几个元素的 ArrayList
        ArrayList<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Orange");
        
        // 打印原始的 ArrayList
        System.out.println("Original ArrayList: " + list); // 输出:[Apple, Banana, Orange]
        
        // 移除索引为 1 处的元素
        String removedElement = list.remove(1);
        
        // 打印被移除的元素和最终的 ArrayList
        System.out.println("Removed element: " + removedElement); // 输出:Banana
        System.out.println("Final ArrayList: " + list); // 输出:[Apple, Orange]
    }
}

       在这个示例中,我们创建了一个包含三个元素的 ArrayList,然后使用 remove(int index) 方法移除了索引为 1 处的元素 "Banana"。最后,我们打印了被移除的元素和最终的 ArrayList,可以看到 "Banana" 被成功移除了。

       (5)boolean remove(Object o)——删除遇到的第一个 o

import java.util.ArrayList;
 
public class Main {
    public static void main(String[] args) {
        // 创建一个包含几个元素的 ArrayList
        ArrayList<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Orange");
        
        // 打印原始的 ArrayList
        System.out.println("Original ArrayList: " + list); // 输出:[Apple, Banana, Orange]
        
        // 移除元素 "Banana"
        list.remove("Banana");
        
        // 打印最终的 ArrayList
        System.out.println(list); // 输出:[Apple, Orange]
    }
}

       在这个示例中,我们创建了一个包含三个元素的 ArrayList,然后使用 remove(Object o) 方法移除了元素 "Banana"。最后,我们打印了最终的 ArrayList,可以看到 "Banana" 被成功移除了。

       (6)E get(int index)——获取下标 index 位置元素

import java.util.ArrayList;
 
public class Main {
    public static void main(String[] args) {
        // 创建一个包含几个元素的 ArrayList
        ArrayList<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Orange");
        
        // 获取索引为 1 处的元素
        String element = list.get(1);
        
        // 打印获取到的元素
        System.out.println(element); // 输出:Banana
    }
}

       在这个示例中,我们创建了一个包含三个元素的 ArrayList,然后使用 get(int index) 方法获取了索引为 1 处的元素。最后,我们打印了获取到的元素,可以看到获取操作成功返回了 "Banana" 这个元素。

       (7)E set(int index, E element)——将下标 index 位置元素设置为 element

import java.util.ArrayList;
 
public class Main {
    public static void main(String[] args) {
        // 创建一个包含几个元素的 ArrayList
        ArrayList<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Orange");
        
        // 打印原始的 ArrayList
        System.out.println(list); // 输出:[Apple, Banana, Orange]
        
        // 将索引为 1 处的元素替换为 "Grapes"
        list.set(1, "Grapes");
        
        // 打印最终的 ArrayList
        System.out.println(list); // 输出:[Apple, Grapes, Orange]
    }
}

       在这个示例中,我们创建了一个包含三个元素的 ArrayList,然后使用 set(int index, E element) 方法将索引为 1 处的元素 "Banana" 替换为 "Grapes"。最后,我们打印了最终的 ArrayList,可以看到替换操作成功地将 "Banana" 替换为了 "Grapes"。

       (8)void clear()——清空

import java.util.ArrayList;
 
public class Main {
    public static void main(String[] args) {
        // 创建一个包含几个元素的 ArrayList
        ArrayList<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Orange");
        
        // 打印原始的 ArrayList
        System.out.println(list); // 输出:[Apple, Banana, Orange]
        
        // 使用 clear() 方法清空 ArrayList
        list.clear();
        
        // 打印清空后的 ArrayList
        System.out.println(list); // 输出:[]
    }
}

       在这个示例中,我们创建了一个包含三个元素的 ArrayList,然后使用 clear() 方法清空了该列表。最后,我们打印了清空后的 ArrayList,可以看到列表中不再包含任何元素。

       (9)boolean contains(Object o)——判断 o 是否在线性表中

import java.util.ArrayList;
 
public class Main {
    public static void main(String[] args) {
        // 创建一个包含几个元素的 ArrayList
        ArrayList<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Orange");
        
        // 检查 ArrayList 是否包含元素 "Banana"
        boolean containsBanana = list.contains("Banana");
        
        // 打印检查结果
        System.out.println(containsBanana); // 输出:true
    }
}

       在这个示例中,我们创建了一个包含三个元素的 ArrayList,然后使用 contains(Object o) 方法检查列表中是否包含元素 "Banana"。最后,我们打印了检查结果,可以看到列表中确实包含 "Banana" 元素。

       (10)int indexOf(Object o)——返回第一个 o 所在下标

import java.util.ArrayList;
 
public class Main {
    public static void main(String[] args) {
        // 创建一个包含几个元素的 ArrayList
        ArrayList<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Orange");
        
        // 获取元素 "Banana" 在 ArrayList 中的索引
        int index = list.indexOf("Banana");
        
        // 打印索引值
        System.out.println(index); // 输出:1
    }
}

       在这个示例中,我们创建了一个包含三个元素的 ArrayList,然后使用 indexOf(Object o) 方法获取了元素 "Banana" 在列表中的索引。最后,我们打印了索引值,可以看到 "Banana" 元素的索引是 1。

       (11)int lastIndexOf(Object o)——返回最后一个 o 的下标

import java.util.ArrayList;
 
public class Main {
    public static void main(String[] args) {
        // 创建一个包含几个元素的 ArrayList
        ArrayList<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Orange");
        list.add("Banana");
        
        // 获取元素 "Banana" 在 ArrayList 中的最后一个索引
        int lastIndex = list.lastIndexOf("Banana");
        
        // 打印最后一个索引值
        System.out.println(lastIndex); // 输出:3
    }
}

       在这个示例中,我们创建了一个包含四个元素的 ArrayList,其中包含两个 "Banana" 元素。然后使用 lastIndexOf(Object o) 方法获取了元素 "Banana" 在列表中的最后一个索引。最后,我们打印了最后一个索引值,可以看到最后一个 "Banana" 元素的索引是 3。

       (12)List<E> subList(int fromIndex, int toIndex)——截取部分 list

import java.util.ArrayList;
import java.util.List;
 
public class Main {
    public static void main(String[] args) {
        // 创建一个包含几个元素的 ArrayList
        ArrayList<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Orange");
        list.add("Grapes");
        list.add("Kiwi");
        
        // 获取子列表,包括索引 1 到 3 的元素,但不包括索引 3
        List<String> subList = list.subList(1, 3);
        
        // 打印子列表
        System.out.println(subList); // 输出:[Banana, Orange]
    }
}

       在这个示例中,我们创建了一个包含五个元素的 ArrayList,然后使用 subList(int fromIndex, int toIndex) 方法获取了子列表,包括索引 1 到 3 的元素,但不包括索引 3。最后,我们打印了子列表,可以看到子列表包含了 "Banana" 和 "Orange" 元素。

注意:

       在使用List<E> subList(int fromIndex, int toIndex)方法的时候,我们对获取的子列表进行修改的时候,原来的列表也会被修改。

这样我们就大致的了解了Java中ArrayList的常用API了。

相关文章
|
8天前
|
存储 算法 安全
Java面试题:Java内存模型及相关知识点深度解析,Java虚拟机的内存结构及各部分作用,详解Java的垃圾回收机制,谈谈你对Java内存溢出(OutOfMemoryError)的理解?
Java面试题:Java内存模型及相关知识点深度解析,Java虚拟机的内存结构及各部分作用,详解Java的垃圾回收机制,谈谈你对Java内存溢出(OutOfMemoryError)的理解?
14 0
|
2天前
|
存储 Java 编译器
Java中ArrayList的常用函数
确切地说,`ArrayList` 提供的这些方法构成了一套强大并且灵活的工具集,可以满足各种程序设计情况中的需求。例如,通过使用 `iterator()`方法,开发者可以在不知道集合大小的情况下遍历集合中全部或部分元素;而 `sort()`方法则能够对集合中的元素进行排序。这些函数在日常的Java编程中极其常见且重要,掌握它们对于进行集合操作和数据处理来说是基础且必须的。
9 2
Java中ArrayList的常用函数
|
9天前
|
缓存 算法 安全
Java中的数据结构与算法优化策略
Java中的数据结构与算法优化策略
|
6天前
|
Java 大数据 API
Java语言的核心知识点与特性
Java 是一种广泛使用的编程语言,自 1995 年发布以来,它已经成为了企业级应用开发、移动应用开发、大数据处理和云计算等领域的主流技术。
16 0
|
8天前
|
设计模式 并行计算 安全
Java面试题: 如何使用装饰器模式来增强ConcurrentHashMap的功能?在什么情况下应该使用CopyOnWriteArrayList而不是ArrayList?
Java面试题: 如何使用装饰器模式来增强ConcurrentHashMap的功能?在什么情况下应该使用CopyOnWriteArrayList而不是ArrayList?
11 0
|
8天前
|
存储 并行计算 安全
Java面试题:Java内存管理、多线程与并发框架的面试题解析与知识点梳理,深入Java内存模型与垃圾回收机制,Java多线程机制与线程安全,Java并发工具包与框架的应用
Java面试题:Java内存管理、多线程与并发框架的面试题解析与知识点梳理,深入Java内存模型与垃圾回收机制,Java多线程机制与线程安全,Java并发工具包与框架的应用
13 0
|
8天前
|
Java
Java面试题:Java内存模型与并发编程知识点,解释Java中“happens-before”的关系,分析Java中的内存一致性效应(Memory Consistency Effects)及其重要性
Java面试题:Java内存模型与并发编程知识点,解释Java中“happens-before”的关系,分析Java中的内存一致性效应(Memory Consistency Effects)及其重要性
8 0
|
10天前
|
存储 算法 搜索推荐
使用Java实现高效的数据结构与算法
使用Java实现高效的数据结构与算法
|
10天前
|
存储 算法 搜索推荐
Java中的数据结构与算法实现
Java中的数据结构与算法实现
|
11天前
|
算法 搜索推荐 Java
在Java中实现高效的算法与数据结构
在Java中实现高效的算法与数据结构

热门文章

最新文章