Java的ArrayList

2023-05-10 本文已影响0人寻心_0a46

ArrayList 类是一个可以动态修改的数组，与普通数组的区别就是它是没有固定大小的限制，我们可以添加或删除元素。ArrayList 继承了 AbstractList ，并实现了 List 接口。

ArrayList-1-768x406-1.png

ArrayList 类位于 java.util 包中，使用前需要引入它，语法格式如下：

import java.util.ArrayList; // 引入 ArrayList 类

ArrayList<E> objectName =new ArrayList<>();　 // 初始化

E : 泛型数据类型，用于设置 objectName 的数据类型，只能为引用数据类型。
objectName ：对象名。

ArrayList 是一个数组队列，提供了相关的添加、删除、修改、遍历等功能。

添加元素：ArrayList 类提供了很多有用的方法，添加元素到 ArrayList 可以使用 add() 方法。

import java.util.ArrayList;

public class RunoobTest {
    public static void main(String[] args) {
        ArrayList<String> sites = new ArrayList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        System.out.println(sites);
    }
}
// 实例执行输出结果为：
// [Google, Runoob, Taobao, Weibo]

访问元素：访问 ArrayList 中的元素可以使用 get() 方法，数组的索引值从 0 开始。

import java.util.ArrayList;

public class RunoobTest {
    public static void main(String[] args) {
        ArrayList<String> sites = new ArrayList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        System.out.println(sites.get(1));  // 访问第二个元素
    }
}
// 实例执行输出结果为：
// Runoob

修改元素：如果要修改 ArrayList 中的元素可以使用 set() 方法。

import java.util.ArrayList;

public class RunoobTest {
    public static void main(String[] args) {
        ArrayList<String> sites = new ArrayList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        sites.set(2, "Wiki"); // 第一个参数为索引位置，第二个为要修改的值
        System.out.println(sites);
    }
}
// 实例执行输出结果为：
// [Google, Runoob, Wiki, Weibo]

删除元素：如果要删除 ArrayList 中的元素可以使用 remove() 方法。

import java.util.ArrayList;

public class RunoobTest {
    public static void main(String[] args) {
        ArrayList<String> sites = new ArrayList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        sites.remove(3); // 删除第四个元素
        System.out.println(sites);
    }
}
// 实例执行输出结果为：
// [Google, Runoob, Taobao]

计算大小：如果要计算 ArrayList 中的元素数量可以使用 size() 方法。

import java.util.ArrayList;

public class RunoobTest {
    public static void main(String[] args) {
        ArrayList<String> sites = new ArrayList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        System.out.println(sites.size());
    }
}
// 实例执行输出结果为：
// 4

迭代数组列表

可以使用 for 来迭代数组列表中的元素：

import java.util.ArrayList;

public class RunoobTest {
    public static void main(String[] args) {
        ArrayList<String> sites = new ArrayList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        for (int i = 0; i < sites.size(); i++) {
            System.out.println(sites.get(i));
        }
    }
}
// 实例执行输出结果为：
// Google
// Runoob
// Taobao
// Weibo

可以使用 for-each 来迭代元素：

import java.util.ArrayList;

public class RunoobTest {
    public static void main(String[] args) {
        ArrayList<String> sites = new ArrayList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        for (String i : sites) {
            System.out.println(i);
        }
    }
}
// 实例执行输出结果为：
// Google
// Runoob
// Taobao
// Weibo

其他的引用类型：ArrayList 中的元素实际上是对象，如果我们要存储基本类型，而 <E> 只能为引用数据类型，这时我们就需要使用到基本类型的包装类。

基本类型对应的包装类表如下：

基本类型	引用类型
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

此外，BigInteger、BigDecimal 用于高精度的运算，BigInteger 支持任意精度的整数，也是引用类型，但它们没有相对应的基本类型。

使用 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 排序：Collections 类也是一个非常有用的类，位于 java.util 包中，提供的 sort() 方法可以对字符或数字列表进行排序。

例如对字母进行排序：

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

改动排序方式为倒序：

Collections.sort(myNumbers, Comparator.reverseOrder());  // 数字倒序排序
// 实例执行输出结果为：
// 34
// 33
// 20
// 15
// 12
// 8

Java ArrayList 常用方法列表如下：

方法	描述
add()	将元素插入到指定位置的 arrayList 中
addAll()	添加集合中的所有元素到 arrayList 中
clear()	删除 arrayList 中的所有元素
clone()	复制一份 arrayList
contains()	判断元素是否在 arrayList
get()	通过索引值获取 arrayList 中的元素
indexOf()	返回 arrayList 中元素的索引值
removeAll()	删除存在于指定集合中的 arrayList 里的所有元素
remove()	删除 arrayList 里的单个元素
size()	返回 arrayList 里元素数量
isEmpty()	判断 arrayList 是否为空
subList()	截取部分 arrayList 的元素
set()	替换 arrayList 中指定索引的元素
sort()	对 arrayList 元素进行排序
toArray()	将 arrayList 转换为数组
toString()	将 arrayList 转换为字符串
ensureCapacity()	设置指定容量大小的 arrayList
lastIndexOf()	返回指定元素在 arrayList 中最后一次出现的位置
retainAll()	保留 arrayList 中在指定集合中也存在的那些元素
containsAll()	查看 arrayList 是否包含指定集合中的所有元素
trimToSize()	将 arrayList 中的容量调整为数组中的元素个数
removeRange()	删除 arrayList 中指定索引之间存在的元素
replaceAll()	将给定的操作内容替换掉 arrayList 中每一个元素
removeIf()	删除所有满足特定条件的 arrayList 元素
forEach()	遍历 arraylist 中每一个元素并执行特定操作

$\color{red}{方法实例：}$

addAll() 方法：

// 该方法有以下几种语法格式：
public boolean addAll(Collection<? extends E> c)
public boolean addAll(int index, Collection<? extends E> c)

描述：

addAll() 方法将给定集合中的所有元素添加到 arraylist（ArrayList 类的一个对象）中。

参数：

index -- （可选参数）表示元素所插入处的索引值。如果 index 没有传入实际参数，元素将追加至数组的最末尾。
c -- 要插入的集合元素。

返回值：

如果成功插入元素，返回 true。

注意：

如果给定的集合为 null，则抛出 NullPointerException 异常。如果 index 超出范围，则抛出 IndexOutOfBoundsException 异常。

public class ArrayTest {
    public static void main(String[] args) {
        ArrayList<String> languages1 = new ArrayList<>();
        languages1.add("Java");
        languages1.add("Python");
        System.out.println("ArrayList 1: " + languages1);

        // 创建另一个数组
        ArrayList<String> languages2 = new ArrayList<>();
        languages2.add("JavaScript");
        languages2.add("C");
        System.out.println("ArrayList 2: " + languages2);

        // 在索引值为1的位置将数组 languages1 的所有元素添加到 languages2
        languages2.addAll(1, languages1);
        System.out.println("更新 ArrayList 2: " + languages2);
    }
}

// 以上程序执行结果为：
// ArrayList 1: [Java, Python]
// ArrayList 2: [JavaScript, C]
// 更新 ArrayList 2: [JavaScript, Java, Python, C]

clear() 方法：

public void clear()

描述：

用于删除动态数组中的所有元素。clear() 方法的比 removeAll() 更常被用到，因为 clear() 比 removeAll() 更快，更高效。

参数：

无

返回值：

无

public class ArrayTest {
    public static void main(String[] args) {
        // 创建一个数组
        ArrayList<String> sites = new ArrayList<>();

        sites.add("Google");
        sites.add("JueJin");
        sites.add("Taobao");
        System.out.println("网站列表: " + sites);

        // 删除所有元素
        sites.clear();
        System.out.println("所有 clear() 方法后: " + sites);
    }
}

// 以上程序执行结果为：
// 网站列表: [Google, JueJin, Taobao]
// 所有 clear() 方法后: []

clone() 方法：

public Object clone()

描述：

用于拷贝一份动态数组，属于浅拷贝。

参数：

无

返回值：

返回 ArrayList 对象。

扩展：

浅拷贝只复制指向某个对象的指针，而不复制对象本身，新旧对象还是共享同一块内存，所以如果其中一个对象改变了这个地址，就会影响到另一个对象...

拷贝对应的就是深拷贝，深拷贝是将一个对象从内存中完整的拷贝一份出来,从堆内存中开辟一个新的区域存放新对象,且修改新对象不会影响原对象。

注意：

clone() 方法并不是ArrayList 类中特定的方法。任何继承了 CLonable 接口的类都能够使用 clone() 方法。

public class ArrayTest {
    public static void main(String[] args) {
        // 创建一个数组
        ArrayList<String> sites = new ArrayList<>();

        sites.add("Google");
        sites.add("JueJin");
        sites.add("Taobao");
        System.out.println("网站列表: " + sites);


        // 输出 clone() 方法所返回的值
        System.out.println("clone() 返回值: " + sites.clone());
    }
}

// 以上程序执行结果为：
// 网站列表: [Google, JueJin, Taobao]
// clone() 返回值: [Google, JueJin, Taobao]

contains() 方法：

public boolean contains(Object o)

描述：

用于判断元素是否在动态数组中。

参数：

o -- 要检测的元素。

返回值：

如果指定的元素存在于动态数组中，则返回 true。如果指定的元素不存在于动态数组中，则返回 false。

注意：

该 contains() 方法内部其实使用 equals() 方法来查找元素。如果指定的元素与数组中的元素有匹配到，则该方法返回 true。

public class ArrayTest {
    public static void main(String[] args) {
        // 创建一个数组
        ArrayList<String> sites = new ArrayList<>();

        sites.add("Google");
        sites.add("JueJin");
        sites.add("Taobao");
        System.out.println("网站列表: " + sites);


        // 检查 Runoob 是否在这个数组中
        System.out.println("Runoob 是否存在于 arraylist: " + sites.contains("JueJin"));
        // 检查 Weibo 是否在这个数组中
        System.out.println("Weibo 是否存在于 arraylist: " + sites.contains("Weibo"));
    }
}

// 以上程序执行结果为：
// 网站列表: [Google, JueJin, Taobao]
// Runoob 是否存在于 arraylist: true
// Weibo 是否存在于 arraylist: false

get() 方法：

public E get(int index)

描述：

通过索引值获取动态数组中的元素。

参数：

index -- 索引值。

返回值：

返回动态数组中指定索引处的元素。

注意：

如果 index 值超出了范围，则抛出 IndexOutOfBoundsException 异常。

public class ArrayTest {
    public static void main(String[] args) {
        // 创建一个数组
        ArrayList<String> sites = new ArrayList<>();

        sites.add("Google");
        sites.add("JueJin");
        sites.add("Taobao");
        System.out.println("网站列表: " + sites);


        // 获取在索引值为1处的元素
        String element = sites.get(1);
        System.out.println("索引值为 1 的元素为: " + element);
    }
}

// 以上程序执行结果为：
// 网站列表: [Google, JueJin, Taobao]
// 索引值为 1 的元素为: JueJin

indexOf() 方法：

public int indexOf(Object o)

描述：

返回动态数组中元素的索引值。

参数：

o -- 查找的元素。

返回值：

从动态数组中返回指定元素的位置的索引值。如果 obj 元素在动态数组中重复出现，返回在数组中最先出现 obj 的元素索引值。如果动态数组中不存在指定的元素，则该 indexOf() 方法返回 -1。

public class ArrayTest {
    public static void main(String[] args) {
        // 创建一个数组
        ArrayList<String> sites = new ArrayList<>();

        sites.add("Google");
        sites.add("JueJin");
        sites.add("Taobao");
        System.out.println("网站列表: " + sites);


        // 查找位置索引值为 Runoob 的元素
        int position1 = sites.indexOf("JueJin");
        System.out.println("JueJin 的索引位置: " + position1);

        // 查找位置索引值为 Weibo 的元素
        int position2 = sites.indexOf("Weibo");
        System.out.println("Weibo 的索引位置: " + position2);
    }
}

// 以上程序执行结果为：
// 网站列表: [Google, JueJin, Taobao]
// JueJin 的索引位置: 1
// Weibo 的索引位置: -1

public boolean removeAll(Collection<?> c)

描述：

用于删除存在于指定集合中的动态数组元素。

参数：

c -- 动态数组列表中要删除的元素集合。

返回值：

如果从动态数组成功删除元素返回 true。

注意：

如果动态数组中存在的元素类与指定 collection 的元素类不兼容，则抛出 ClassCastException 异常。

如果动态数组中包含 null 元素，并且指定 collection 不允许 null 元素，则抛出 NullPointerException 异常。

public class ArrayTest {
    public static void main(String[] args) {
        // 创建一个数组
        ArrayList<String> sites = new ArrayList<>();

        sites.add("Google");
        sites.add("JueJin");
        sites.add("Taobao");
        System.out.println("网站列表: " + sites);

        ArrayList<String> delete = new ArrayList();
        delete.add("Google");
        delete.add("Taobao");
        System.out.println("要删除的网站列表: " + delete);

        // 删除所有元素
        sites.removeAll(delete);
        System.out.println("sites 调用 removeAll() 方法后: " + sites);
    }
}

// 以上程序执行结果为：
// 网站列表: [Google, JueJin, Taobao]
// 要删除的网站列表: [Google, Taobao]
// sites 调用 removeAll() 方法后: [JueJin]

remove() 方法：

// 该方法有以下几种语法格式：
public E remove(int index) 
public boolean remove(Object o)

描述：

用于删除动态数组里的单个元素。

参数：

index -- 要删除元素索引值。如果 obj 元素出现多次，则删除在动态数组中最第一次出现的元素。
obj -- 要删除的元素。

返回值：

如果传入的元素删除成功，则返回 true。

如果传入索引值，则返回删除的元素。

注意：

如果指定的索引超出范围，则该方法将抛出 IndexOutOfBoundsException 异常。

public class ArrayTest {
    public static void main(String[] args) {
        // 创建一个数组
        ArrayList<String> sites = new ArrayList<>();

        sites.add("Google");
        sites.add("JueJin");
        sites.add("Taobao");
        System.out.println("网站列表: " + sites);

        // 删除元素
        sites.remove("Google");
        System.out.println("sites 调用一次 remove() 方法后: " + sites);
        // 第一次删除元素后索引产生了变化，所以索引1移除的是 Taobao
        sites.remove(1);
        System.out.println("sites 再次调用 remove() 方法后: " + sites);
    }
}

// 以上程序执行结果为：
// 网站列表: [Google, JueJin, Taobao]
// sites 调用一次 remove() 方法后: [JueJin, Taobao]
// sites 再次调用 remove() 方法后: [JueJin]

size() 方法：

public int size()

描述：

用于返回动态数组中元素的数量。

参数：

无

返回值：

返回数组中元素的个数。

public class ArrayTest {
    public static void main(String[] args) {
        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();

        sites.add("Google");
        sites.add("JueJin");
        sites.add("Taobao");
        System.out.println("网站列表: " + sites);


        // 得到数组中的元素个数
        int size = sites.size();
        System.out.println("动态数组长度: " + size);
    }
}

// 以上程序执行结果为：
// 网站列表: [Google, JueJin, Taobao]
// 动态数组长度: 3

isEmpty() 方法：

public boolean isEmpty()

描述：

用于判断动态数组是否为空。

参数：

无

返回值：

如果数组中不存在任何元素，则返回 true。如果数组中存在元素，则返回 false。

public class ArrayTest {
    public static void main(String[] args) {
        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();

        // 检查数组中是否含有元素
        boolean result = sites.isEmpty(); // true
        System.out.println("sites 是否为空? " + result);

        sites.add("Google");
        sites.add("JueJin");
        sites.add("Taobao");
        System.out.println("网站列表: " + sites);

        // 检查该数组是否为空
        result = sites.isEmpty();  // false
        System.out.println("sites 是否为空? " + result);
    }
}

// 以上程序执行结果为：
// sites 是否为空? true
// 网站列表: [Google, JueJin, Taobao]
// sites 是否为空? false

subList() 方法：

public List<E> subList(int fromIndex, int toIndex)

描述：

用于截取并返回动态数组中的一部分。

参数：

fromIndex -- 截取元素的起始位置，包含该索引位置元素。
toIndex -- 截取元素的结束位置，不包含该索引位置元素。

返回值：

返回给定的动态数组截取的部分。

注意：

如果fromIndex 小于 0 或大于数组的长度，则抛出 IndexOutOfBoundsException 的异常。

如果 fromIndex 大于 toIndex 的值则抛出 IllegalArgumentException 异常。

public class ArrayTest {
    public static void main(String[] args) {
        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();

        sites.add("Google");
        sites.add("JueJin");
        sites.add("Taobao");
        sites.add("Wiki");
        System.out.println("网站列表: " + sites);

        // 元素位置为1到3
        System.out.println("SubList: " + sites.subList(1, 3));
    }
}

// 以上程序执行结果为：
// 网站列表: [Google, JueJin, Taobao, Wiki]
// SubList: [JueJin, Taobao]

set() 方法：

public E set(int index, E element)

描述：

用于替换动态数组中指定索引的元素。

参数：

index -- 索引位置。
element -- 将在 index 位置替换进去的新元素。

返回值：

返回之前在 index 位置的元素。

注意：

如果 index 值超出范围，则抛出 IndexOutOfBoundsException 异常。

public class ArrayTest {
    public static void main(String[] args) {
        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();

        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        System.out.println("网站列表: " + sites);

        // 索引 2 的元素被替换
        String element = sites.set(1, "JueJin");
        System.out.println("替换后: " + sites);
        System.out.println("被替换的元素: " + element);
    }
}

// 以上程序执行结果为：
// 网站列表: [Google, Runoob, Taobao]
// 替换后: [Google, JueJin, Taobao]
// 被替换的元素: Runoob

sort() 方法：

public void sort(Comparator<? super E> c)

描述：

根据指定的顺序对动态数组中的元素进行排序。

参数：

c -- 顺序方式。

返回值：

sort() 方法不返回任何值，它只是更改动态数组列表中元素的顺序。

public class ArrayTest {
    public static void main(String[] args) {
        // 创建一个动态数组
        ArrayList<Integer> sites = new ArrayList<>();

        sites.add(-1);
        sites.add(3);
        sites.add(1);
        sites.add(2);
        sites.add(0);

        System.out.println("不排序时: " + sites);

        // 元素进行升序排列
        sites.sort(Comparator.naturalOrder());
        System.out.println("升序排序后: " + sites);

        // 元素进行降序排列
        sites.sort(Comparator.reverseOrder());
        System.out.println("降序排序后: " + sites);

    }
}

// 以上程序执行结果为：
// 不排序时: [-1, 3, 1, 2, 0]
// 升序排序后: [-1, 0, 1, 2, 3]
// 降序排序后: [3, 2, 1, 0, -1]

toArray() 方法：

// 该方法有以下几种语法格式：
public Object[] toArray()
public <T> T[] toArray(T[] a)

描述：

将 Arraylist 对象转换为数组。

参数：

T[] a -- （可选参数）用于存储数组元素的数组。

返回值：

如果参数 T[] a 作为参数传入到方法，则返回 T 类型的数组。如果未传入参数，则返回 Object 类型的数组。

注意：

传入数组参数的数组长度应该等于或者大于 arraylist（ArrayList 类的对象）。建议使用带参数的 toArray() 方法。

public class ArrayTest {
    public static void main(String[] args) {
        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();

        sites.add("JueJin");
        sites.add("Google");
        sites.add("Wiki");
        sites.add("Taobao");
        System.out.println("网站列表: " + sites);

        // 创建一个新的 String 类型的数组
        // 数组长度和 ArrayList 长度一样
        String[] arr = new String[sites.size()];

        // 将ArrayList对象转换成数组
        sites.toArray(arr);

        // 输出所有数组的元素
        System.out.print("Array: ");
        for(String item:arr) {
            System.out.print(item+", ");
        }
    }
}

// 以上程序执行结果为：
// 网站列表: [JueJin, Google, Wiki, Taobao]
// Array: JueJin, Google, Wiki, Taobao,

toString() 方法：

public String toString()

描述：

将 Arraylist 对象转换为字符串。

参数：

无

返回值：

返回 arraylist（ArrayList 类的对象）的字符串表示形式。

注意：

ArrayList 类没有它自己的 toString() 方法，它重写了 Object 类的 toString() 方法。

public class ArrayTest {
    public static void main(String[] args) {
        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();

        sites.add("JueJin");
        sites.add("Google");
        sites.add("Wiki");
        sites.add("Taobao");
        System.out.println("网站列表: " + sites);

        // 将ArrayList转换为String类型
        String list = sites.toString();
        System.out.println("String: " + list);
    }
}

// 以上程序执行结果为：
// 网站列表: [JueJin, Google, Wiki, Taobao]
// String: [JueJin, Google, Wiki, Taobao]

ensureCapacity() 方法：

public void ensureCapacity(int minCapacity)

描述：

用于设置具有指定容量大小的动态数组。

参数：

minCapacity -- 动态数组的容量。

返回值：

无

解析：

如果 arraylist 可以自动调整自身大小，为什么还要使用 ensureCapacity() 方法调整 arraylist 的大小呢？这是因为如果我们使用 ensureCapacity() 方法来调整 arraylist 的大小，那么 arraylist 将会马上调整为指定的容量大小。否则，每次添加元素时都会调整 arraylist 的大小。

public class ArrayTest {
    public static void main(String[] args) {
        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();

        // 设置 arraylist的容量大小
        sites.ensureCapacity(3);

        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");

        // 添加第四个元素
        sites.add("Juejin");

        System.out.println("网站列表: " + sites);
    }
}

// 以上程序执行结果为：
// 网站列表: [Google, Runoob, Taobao, Juejin]

lastIndexOf() 方法：

public int lastIndexOf(Object o)

描述：

返回指定元素在动态数组中最后一次出现的位置。

参数：

o -- 查找的元素。

返回值：

从动态数组中返回指定元素最后出现的位置的索引值。如果 o 元素在动态数组中重复出现，返回在数组中最后出现 o 的元素索引值。如果动态数组中不存在指定的元素，则该 lastIndexOf() 方法返回 -1。

public class ArrayTest {
    public static void main(String[] args) {
        // 创建一个数组
        ArrayList<String> sites = new ArrayList<>();

        sites.add("Google");
        sites.add("JueJin");
        sites.add("Taobao");
        sites.add("JueJin");
        System.out.println("网站列表: " + sites);


        // 获取 JueJin 最后一次出现的位置
        int position1 = sites.lastIndexOf("JueJin");
        System.out.println("JueJin 最后出现的位置: " + position1);

        // Runoob 不在 arraylist 中
        // 返回 -1
        int position2 = sites.lastIndexOf("Runoob");
        System.out.println("Runoob 最后出现的位置: " + position2);
    }
}

// 以上程序执行结果为：
// 网站列表: [Google, JueJin, Taobao, JueJin]
// JueJin 最后出现的位置: 3
// Runoob 最后出现的位置: -1

retainAll() 方法：

public boolean retainAll(Collection<?> c)

描述：

用于保留 arraylist（ArrayList 类的对象）中在指定集合中也存在的那些元素，也就是删除指定集合中不存在的那些元素（调用方法对象保留两个集合中元素的交集）。

参数：

c - 集合参数。

返回值：

如果 arraylist（ArrayList 类的对象）中删除了元素则返回 true。

注意：

如果 arraylist 类中存在的元素与指定 collection 的类中元素不兼容，则抛出 ClassCastException 异常。

如果 arraylist 包含 null 元素，并且指定 collection 不允许 null 元素，则抛出 NullPointerException 。

public class ArrayTest {
    public static void main(String[] args) {
        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();

        sites.add("Google");
        sites.add("JueJin");
        sites.add("Taobao");

        System.out.println("sites: " + sites);

        // 创建另一个动态数组
        ArrayList<String> sites2 = new ArrayList<>();

        // 往动态数组中添加元素
        sites2.add("Wiki");
        sites2.add("JueJin");
        sites2.add("Google");
        System.out.println("sites2: " + sites2);

        // 保留元素
        sites.retainAll(sites2);
        System.out.println("sites 保留的元素: " + sites);
    }
}

// 以上程序执行结果为：
// sites: [Google, JueJin, Taobao]
// sites2: [Wiki, JueJin, Google]
// sites 保留的元素: [Google, JueJin]

containsAll() 方法：

public boolean containsAll(Collection<?> c)

描述：

用于检测 arraylist（ArrayList 类的对象）是否包含指定集合中的所有元素。可以这样理解， containsAll() 方法检查了参数集合是否是动态数组中的一个子集。

参数：

c -- 集合参数。

返回值：

如果动态数组中包含的集合中的所有元素，则返回 true。

注意：

如果 arraylist（ArrayList 类的对象）中存在的元素与指定 collection 中的元素不兼容，则抛出 ClassCastException。

如果 collection 中包含 null 元素，并且 arraylist（ArrayList 类的对象）中不允许 null值，则抛出 NullPointerException 异常。

public class ArrayTest {
    public static void main(String[] args) {
        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();

        sites.add("Google");
        sites.add("JueJin");
        sites.add("Taobao");

        System.out.println("ArrayList 1: " + sites);

        // 创建另一个动态数组
        ArrayList<String> sites2 = new ArrayList<>();

        // 往动态数组中添加元素
        sites2.add("JueJin");
        sites2.add("Google");
        System.out.println("ArrayList 2: " + sites2);

        // 检查动态数组1是否包含动态数组2
        boolean result1 = sites.containsAll(sites2);
        System.out.println("ArrayList 1 包含了 ArrayList 2 的所有元素: " + result1);

        // 检查数组2是否包含数组1
        boolean result2 = sites2.containsAll(sites);
        System.out.println("ArrayList 2 包含了 ArrayList 1 的所有元素: " + result2);
    }
}

// 以上程序执行结果为：
// ArrayList 1: [Google, JueJin, Taobao]
// ArrayList 2: [JueJin, Google]
// ArrayList 1 包含了 ArrayList 2 的所有元素: true
// ArrayList 2 包含了 ArrayList 1 的所有元素: false

trimToSize() 方法：

public void trimToSize()

描述：

用于将动态数组中的容量调整为数组中的元素个数。

参数：

无

返回值：

无

解析：

ArrayList 的内部使用数组存储元素，当数组将被存满，就会创建一个新数组，其容量是当前数组的 1.5 倍。同时，所有元素都将移至新数组，假设内部数组已满，而我们现在又添加了 1 个元素，ArrayList 容量就会以相同的比例扩展（即前一个数组的1.5倍）。在这种情况下，内部数组中将有一些未分配的空间。这时，trimToSize() 方法可以删除未分配的空间并更改 ArrayList 的容量，使其等于 ArrayList 中的元素个数。

public class ArrayTest {
    public static void main(String[] args) {
        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();

        sites.add("Google");
        sites.add("JueJin");
        sites.add("Taobao");

        System.out.println("ArrayList : " + sites);

        // 调整容量为3
        sites.trimToSize();
        System.out.println("ArrayList 大小: " + sites.size());
    }
}

// 以上程序执行结果为：
// ArrayList : [Google, JueJin, Taobao]
// ArrayList 大小: 3

removeRange() 方法：

protected void removeRange(int fromIndex, int toIndex)

描述：

用于删除指定索引之间存在的元素。该方法仅删除了一部分动态数组元素，从 fromIndex 到 toIndex-1 的动态数组元素。也就是说不包括 toIIndex 索引位置的元素在内。

参数：

fromIndex -- 索引起始位置，包含该索引位置的值。
toIndex -- 索引结束位置，不包含该索引位置的值。

返回值：

无

注意：

如果fromIndex 或者 toIndex 索引超出范围，或者说 toIndex < fromIndex，则抛出 IndexOutOfBoundException 异常。

public class ArrayTest extends ArrayList {
    public static void main(String[] args) {
        // 创建一个动态数组
        ArrayTest sites = new ArrayTest();

        sites.add("Google");
        sites.add("JueJin");
        sites.add("Taobao");
        sites.add("JueJin");
        sites.add("Weibo");

        System.out.println("ArrayList : " + sites);

        // 删除从索引值1到3的元素
        sites.removeRange(1, 3);
        System.out.println("删除后的 ArrayList: " + sites);
    }
}

// 以上程序执行结果为：
// ArrayList : [Google, JueJin, Taobao, JueJin, Weibo]
// 删除后的 ArrayList: [Google, JueJin, Weibo]

扩展：

removeRange() 方法是受保护的，所以如果要使用需要继承 ArrayList 类，继承后我们就可以使用继承类来创建一个动态数组。removeRange() 方法不常用，我们通常可以使用 ArrayList subList() 和 ArrayList clear() 方法来实现删除元素。

public class ArrayTest {
    public static void main(String[] args) {
        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();

        sites.add("Google");
        sites.add("JueJin");
        sites.add("Taobao");
        sites.add("JueJin");
        sites.add("Weibo");

        System.out.println("ArrayList : " + sites);

        // 删除位置索引1到3的元素
        sites.subList(1, 3).clear();
        System.out.println("Updated ArrayList: " + sites);
    }
}

// 以上程序执行结果为：
// ArrayList : [Google, JueJin, Taobao, JueJin, Weibo]
// Updated ArrayList: [Google, JueJin, Weibo]

replaceAll() 方法：

public void replaceAll(UnaryOperator<E> operator)

描述：

用于将给定的操作内容替换掉数组中每一个元素。

参数：

operator -- 要替换到动态数组的元素或者一系列操作。

返回值：

无

public class ArrayTest {
    public static void main(String[] args) {
        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();

        sites.add("Google");
        sites.add("JueJin");
        sites.add("Taobao");

        System.out.println("ArrayList : " + sites);

        // 将所有元素更改为大写
        sites.replaceAll(e -> e.toUpperCase());
        System.out.println("更新后的 ArrayList: " + sites);
    }
}

// 以上程序执行结果为：
// ArrayList : [Google, JueJin, Taobao]
// 更新后的 ArrayList: [GOOGLE, JUEJIN, TAOBAO]

removeIf() 方法：

public boolean removeIf(Predicate<? super E> filter)

描述：

用于删除所有满足特定条件的数组元素。

参数：

filter -- 过滤器，判断元素是否要删除。

返回值：

如果元素被删除则返回 true。

public class ArrayTest {
    public static void main(String[] args) {
        // 创建一个动态数组
        ArrayList<String> sites = new ArrayList<>();

        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("JueJin");

        System.out.println("ArrayList : " + sites);

        // 删除名称中带有 Run 的元素
        sites.removeIf(e -> e.contains("Run"));;
        System.out.println("删除后的 ArrayList: " + sites);
    }
}

// 以上程序执行结果为：
// ArrayList : [Google, Runoob, Taobao, JueJin]
// 删除后的 ArrayList: [Google, Taobao, JueJin]

forEach() 方法：

public void forEach(Consumer<? super E> action)

描述：

用于遍历动态数组中每一个元素并执行特定操作。

参数：

action -- 对每个元素执行的操作。

返回值：

无

注意：

forEach() 方法与 for-each 循环不同。forEach() 方法对每个元素执行操作。Java for-each用于遍历数组中的每个元素。

public class ArrayTest {
    public static void main(String[] args) {
        // 创建一个数组
        ArrayList<Integer> numbers = new ArrayList<>();

        // 往数组中添加元素
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        System.out.println("ArrayList: " + numbers);

        // 所有元素乘以 10
        System.out.print("更新 ArrayList: ");

        // 将 lambda 表达式传递给 forEach
        numbers.forEach((e) -> {
            e = e * 10;
            System.out.print(e + " ");
        });
    }
}

// 以上程序执行结果为：
// ArrayList: [1, 2, 3, 4]
// 更新 ArrayList: 10 20 30 40

扩展：

numbers.forEach((e) -> {
    e = e * 10;
    System.out.print(e + " ");  
});

实例中，我们将匿名函数 lambda 的表达式作为 forEach() 方法的参数传入，lambda 表达式将动态数组中的每个元素乘以 10，然后输出结果。

Java的ArrayList

猜你喜欢

热点阅读