Java ArrayList

Java ArrayList 教程显示了如何使用 Java 中的ArrayList集合。 ArrayList位于java.util包中,是 Java 集合框架的重要集合。

Java 集合框架是用于表示和操作集合的统一体系结构,使集合可以独立于实现细节进行操作。 集合是代表一组对象的对象。

Java ArrayList

ArrayList是元素的有序序列。 它是动态的并且可调整大小。 它提供对元素的随机访问。 随机访问意味着我们可以在恒定时间抓取任何元素。 添加数据后,ArrayList会自动扩展。 与简单数组不同,ArrayList可以保存多种数据类型的数据。 它允许所有元素,包括null

ArrayList中的元素通过整数索引访问。 索引从零开始。 在ArrayList的末尾元素的索引以及插入和删除需要固定的时间。

ArrayList实例具有容量。 容量是用于在列表中存储元素的数组的大小。 当元素添加到ArrayList时,其容量会自动增长。 选择适当的容量可以节省一些时间。

Java ArrayList添加单个项目

可以使用add()方法将单个元素添加到ArrayList

com/zetcode/ListAddItem.java

package com.zetcode;

import java.util.ArrayList;
import java.util.List;

public class ListAddItem {

    public static void main(String[] args) {

        List<String> langs = new ArrayList<>();

        langs.add("Java");
        langs.add("Python");
        langs.add(1, "C#");
        langs.add(0, "Ruby");

        for (String lang : langs) {

            System.out.printf("%s ", lang);
        }

        System.out.println();
    }
}

该示例将元素逐一添加到数组列表中。

List<String> langs = new ArrayList<>();

创建一个ArrayList。 在菱形括号(< >)中指定的数据类型将元素限制为该数据类型。 在我们的例子中,我们有一个字符串列表。

langs.add("Java");

使用add()方法将元素添加到列表的末尾。

langs.add(1, "C#");

这次,重载的add()方法将元素插入指定位置; “ C# ”字符串将位于列表的第二个位置; 请记住,ArrayList是元素的有序序列。

for (String lang : langs) {

    System.out.printf("%s ", lang);
}

通过for循环,我们浏览ArrayList列表并打印其元素。

Ruby Java C# Python

这是输出。 请注意,元素保持插入顺序。

Java 列表

从 Java 9 开始,我们有几种工厂方法来创建包含少量元素的列表。 创建的列表是不可变的。

com/zetcode/ListOf.java

package com.zetcode;

import java.util.List;

public class ListOf {

    public static void main(String[] args) {

        var words = List.of("wood", "forest", "falcon", "eagle");
        System.out.println(words);

        var values = List.of(1, 2, 3);
        System.out.println(values);
    }
}

在示例中,我们创建了两个包含四个和三个元素的列表。

Java ArrayList get()size()

get()返回此列表中指定位置的元素,size()返回列表的大小。

com/zetcode/GetAndSizeEx.java

package com.zetcode;

import java.util.ArrayList;
import java.util.List;

public class GetAndSizeEx {

    public static void main(String[] args) {

        List<String> colours = new ArrayList<>();

        colours.add("blue");
        colours.add("orange");
        colours.add("red");
        colours.add("green");

        String col = colours.get(1);
        System.out.println(col);

        int size = colours.size();

        System.out.printf("The size of the ArrayList is: %d%n", size  );
    }
}

该示例使用了ArrayListget()size()方法

String col = colours.get(1);

get()方法返回第二个元素,即“橙色”。

int size = colours.size();

size()方法确定colours列表的大小; 我们有四个要素。

orange
The size of the ArrayList is: 4

这是示例的输出。

Java ArrayList复制

可以使用List.copy()方法生成列表的副本。

com/zetcode/ListCopy.java

package com.zetcode;

import java.util.List;

public class ListCopy {

    public static void main(String[] args) {

        var words = List.of("forest", "wood", "eagle", "sky", "cloud");
        System.out.println(words);

        var words2 = List.copyOf(words);
        System.out.println(words2);
    }
}

该示例使用List.copy()创建列表的副本。

原始ArrayList

ArrayList可以包含各种数据类型。 这些称为原始列表。

Note: It is generally not recommended to use raw lists.

原始列表通常需要强制转换,而且类型安全。

com/zetcode/DataTypesEx.java

package com.zetcode;

import java.util.ArrayList;
import java.util.List;

class Base {}

enum Level {

    EASY,
    MEDIUM,
    HARD
}

public class DataTypesEx {

    public static void main(String[] args) {

        Level level = Level.EASY;

        List da = new ArrayList();

        da.add("Java");
        da.add(3.5);
        da.add(55);
        da.add(new Base());
        da.add(level);

        for (Object el : da) {

            System.out.println(el);
        }
    }

}

该示例将五种不同的数据类型添加到数组列表中-字符串,双精度型,整数,对象和枚举。

List da = new ArrayList();

当我们将多个数据类型添加到列表时,我们省略了尖括号。

Java
3.5
55
com.zetcode.Base@659e0bfd
EASY

这是输出。

Java ArrayList添加多个元素

下面的示例使用addAll()方法一步将多个元素添加到列表中。

com/zetcode/AddingMultipleItemsEx.java

package com.zetcode;

import java.util.ArrayList;
import java.util.List;

public class AddingMultipleItemsEx {

    public static void main(String[] args) {

        List<String> colours1 = new ArrayList<>();

        colours1.add("blue");
        colours1.add("red");
        colours1.add("green");

        List<String> colours2 = new ArrayList<>();

        colours2.add("yellow");
        colours2.add("pink");
        colours2.add("brown");

        List<String> colours3 = new ArrayList<>();
        colours3.add("white");
        colours3.add("orange");

        colours3.addAll(colours1);
        colours3.addAll(2, colours2);

        for (String col : colours3) {

            System.out.println(col);
        }
    }
}

创建两个列表。 稍后,使用addAll()方法将列表中的元素添加到第三个列表中。

colours3.addAll(colours1);

addAll()方法将所有元素添加到列表的末尾。

colours3.addAll(2, colours2);

此重载方法添加了从指定位置开始的所有元素。

white
orange
yellow
pink
brown
blue
red
green

This is the output of the example.

Java ArrayList修改元素

下一个示例使用方法来修改ArrayList

com/zetcode/ModifyingListEx.java

package com.zetcode;

import java.util.ArrayList;
import java.util.List;

public class ModifyingListEx {

    public static void main(String[] args) {

        List<String> items = new ArrayList<>();
        fillList(items);

        items.set(3, "watch");
        items.add("bowl");
        items.remove(0);
        items.remove("pen");

        for (Object el : items) {

            System.out.println(el);
        }

        items.clear();

        if (items.isEmpty()) {

            System.out.println("The list is empty");
        } else {
            System.out.println("The list is not empty");
        }
    }

    public static void fillList(List<String> list) {

        list.add("coin");
        list.add("pen");
        list.add("pencil");
        list.add("clock");
        list.add("book");
        list.add("spectacles");
        list.add("glass");
    }
}

使用set()add()remove()clear()方法创建和修改ArrayList

items.set(3, "watch");

set()方法将第四个元素替换为“ watch”项。

items.add("bowl");

add()方法在列表的末尾添加一个新元素。

items.remove(0);

remove()方法删除索引为 0 的第一个元素。

items.remove("pen");

重载的remove()方法删除“ pen”项的第一次出现。

items.clear();

clear()方法从列表中删除所有元素。

if (items.isEmpty()) {

isEmpty()方法确定列表是否为空。

pencil
watch
book
spectacles
glass
bowl
The list is empty

This is the output of the example.

Java ArrayList removeIf

removeIf()方法删除满足给定谓词的集合中的所有元素。

com/zetcode/RemoveIfEx.java

package com.zetcode;

import java.util.ArrayList;
import java.util.List;

public class RemoveIfEx {

    public static void main(String[] args) {

        List<Integer> values = new ArrayList<>();
        values.add(5);
        values.add(-3);
        values.add(2);
        values.add(8);
        values.add(-2);
        values.add(6);

        values.removeIf(val -> val < 0);

        System.out.println(values);
    }
}

在我们的示例中,我们有一个ArrayList整数。 我们使用removeIf方法删除所有负值。

values.removeIf(val -> val < 0);

所有负数将从数组列表中删除。

[5, 2, 8, 6]

This is the output.

Java ArrayList removeAll

removeAll()方法从该列表中删除指定集合中包含的所有其元素。 请注意,所有元素都已通过clear()删除。

com/zetcode/RemoveAll.java

package com.zetcode;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class RemoveAll {

    public static void main(String[] args) {

        List<String> letters = new ArrayList<>();
        letters.add("a");
        letters.add("b");
        letters.add("c");
        letters.add("a");
        letters.add("d");

        System.out.println(letters);

        letters.removeAll(Collections.singleton("a"));
        System.out.println(letters);
    }
}

在示例中,我们从列表中删除了所有“ a”字母。

Java ArrayList replaceAll

replaceAll()方法用将运算符应用于该元素的结果替换列表的每个元素。

com/zetcode/ReplaceAllEx.java

package com.zetcode;

import java.util.ArrayList;
import java.util.List;
import java.util.function.UnaryOperator;

public class ReplaceAllEx {

    public static void main(String[] args) {

        List<String> items = new ArrayList<>();
        items.add("coin");
        items.add("pen");
        items.add("cup");
        items.add("notebook");
        items.add("class");

        UnaryOperator<String> uo = (x) -> x.toUpperCase();

        items.replaceAll(uo);

        System.out.println(items);
    }
}

该示例在每个列表元素上应用了一个运算符。 元素的字母转换为大写。

UnaryOperator<String> uo = (x) -> x.toUpperCase();

创建将字母转换为大写的UnaryOperator

items.replaceAll(uo);

使用replaceAll()方法将运算符应用于列表元素。

[COIN, PEN, CUP, NOTEBOOK, CLASS]

This is the output.

第二个示例使用replaceAll()方法将字符串项目大写。

com/zetcode/ReplaceAllEx2.java

package com.zetcode;

import java.util.ArrayList;
import java.util.List;
import java.util.function.UnaryOperator;

class MyOperator<T> implements UnaryOperator<String> {

    @Override
    public String apply(String var) {

        if (var == null || var.length() == 0) {
            return var;
        }
        return var.substring(0, 1).toUpperCase() + var.substring(1);
    }
}

public class ReplaceAllEx2 {

    public static void main(String[] args) {

        List<String> items = new ArrayList<>();

        items.add("coin");
        items.add("pen");
        items.add("cup");
        items.add("notebook");
        items.add("glass");

        items.replaceAll(new MyOperator<>());

        System.out.println(items);
    }
}

我们有一个字符串项目列表。 这些项目在replaceAll()方法的帮助下大写。

class MyOperator<T> implements UnaryOperator<String> {

创建自定义UnaryOperator

@Override
public String apply(String var) {

    if (var == null || var.length() == 0) {
        return var;
    }
    return var.substring(0, 1).toUpperCase() + var.substring(1);
}

UnaryOperator's apply()方法中,我们使用第一个大写字母还原字符串。

items.replaceAll(new MyOperator<>());

将运算符应用于列表项。

[Coin, Pen, Cup, Notebook, Glass]

This is the output of the example.

Java ArrayList contains()

如果列表包含指定的元素,则contains()方法返回 true。

com/zetcode/ContainsEx.java

package com.zetcode;

import java.util.ArrayList;
import java.util.List;

public class ContainsEx {

    public static void main(String[] args) {

        List<String> items = new ArrayList<>();

        items.add("coin");
        items.add("pen");
        items.add("cup");
        items.add("notebook");
        items.add("class");

        String item = "pen";

        if (items.contains(item)) {

            System.out.printf("There is a %s in the list%n", item);
        }
    }
}

该示例检查指定的项目是否在列表中。

if (items.contains(item)) {

    System.out.printf("There is a %s in the list%n", item);
}

如果该项目在列表中,则会打印该消息。

There is a pen in the list

This is the output.

获取 ArrayList 中元素的索引

ArrayList中的每个元素都有其自己的索引号。 indexOf()返回指定元素首次出现的索引,如果列表不包含该元素,则返回-1。 lasindexOf()返回指定元素最后一次出现的索引;如果列表中不包含该元素,则返回-1。

com/zetcode/GetIndexEx.java

package com.zetcode;

import java.util.ArrayList;
import java.util.List;

public class GetIndexEx {

    public static void main(String[] args) {

        List<String> colours = new ArrayList<>();

        colours.add(0, "blue");
        colours.add(1, "orange");
        colours.add(2, "red");
        colours.add(3, "green");
        colours.add(4, "orange");

        int idx1 = colours.indexOf("orange");
        System.out.println(idx1);

        int idx2 = colours.lastIndexOf("orange");
        System.out.println(idx2);
    }
}

该示例打印“ orange”元素的第一个和最后一个索引。

1
4

这是示例输出。

Java 列表的列表

We can add other lists into a list.

com/zetcode/ListOfLists.java

package com.zetcode;

import java.util.ArrayList;
import java.util.List;

public class ListOfLists {

    public static void main(String[] args) {

        List<Integer> l1 = new ArrayList<>();
        l1.add(1);
        l1.add(2);
        l1.add(3);

        List<Integer> l2 = new ArrayList<>();
        l2.add(4);
        l2.add(5);
        l2.add(6);

        List<Integer> l3 = new ArrayList<>();
        l3.add(7);
        l3.add(8);
        l3.add(9);

        List<List<Integer>> nums = new ArrayList<>();
        nums.add(l1);
        nums.add(l2);
        nums.add(l3);

        System.out.println(nums);

        for (List<Integer> list : nums) {

            for (Integer n : list) {

                System.out.printf("%d ", n);
            }

            System.out.println();
        }
    }
}

该示例创建三个整数列表。 以后,这些列表将添加到另一个第四列表中。

List<Integer> l1 = new ArrayList<>();
l1.add(1);
l1.add(2);
l1.add(3);

将创建一个整数列表。

List<List> nums = new ArrayList<>();
nums.add(l1);
nums.add(l2);
nums.add(l3);

创建列表列表。

for (List<Integer> list : nums) {

    for (Integer n : list) {

        System.out.printf("%d ", n);
    }

    System.out.println();
}

我们使用两个 for 循环遍历所有元素。

[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
1 2 3
4 5 6
7 8 9

这是程序的输出。

Java ArrayList子列表

subList()方法返回指定的 fromIndex(包括)和 toIndex(不包括)之间的列表部分的视图。 子列表中的更改将反映在原始列表中。

com/zetcode/SubListEx.java

package com.zetcode;

import java.util.ArrayList;
import java.util.List;

public class SubListEx {

    public static void main(String[] args) {

        List<String> items = new ArrayList<>();

        items.add("coin");
        items.add("pen");
        items.add("cup");
        items.add("notebook");
        items.add("glass");
        items.add("chair");
        items.add("ball");
        items.add("bowl");

        List<String> items2 = items.subList(2, 5);

        System.out.println(items2);

        items2.set(0, "bottle");

        System.out.println(items2);
        System.out.println(items);
    }
}

该示例从项目列表创建子列表。

List<String> items2 = items.subList(2, 5);

使用subList()方法创建一个子列表。 它包含索引为 2、3 和 4 的项目。

items2.set(0, "bottle");

我们替换子列表的第一项; 修改也反映在原始列表中。

[cup, notebook, glass]
[bottle, notebook, glass]
[coin, pen, bottle, notebook, glass, chair, ball, bowl]

This is the output of the example.

Java ArrayList遍历

在下面的示例中,我们展示了遍历ArrayList的五种方法。

com/zetcode/TraversingArrayListEx.java

package com.zetcode;

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class TraversingArrayListEx {

    public static void main(String[] args) {

        List<Integer> nums = new ArrayList<>();
        nums.add(2);
        nums.add(6);
        nums.add(7);
        nums.add(3);
        nums.add(1);
        nums.add(8);

        for (int i = 0; i < nums.size(); i++) {

            System.out.printf("%d ", nums.get(i));
        }

        System.out.println();

        for (int num : nums) {

            System.out.printf("%d ", num);
        }

        System.out.println();

        int j = 0;
        while (j < nums.size()) {

            System.out.printf("%d ", nums.get(j));
            j++;
        }

        System.out.println();

        ListIterator<Integer> it = nums.listIterator();

        while(it.hasNext()) {

            System.out.printf("%d ", it.next());
        }

        System.out.println();

        nums.forEach(e -> System.out.printf("%d ", e));
        System.out.println();
    }
}

在示例中,我们遍历具有 for 循环,while 循环,迭代器和forEach()构造的整数数组列表。

List<Integer> nums = new ArrayList<>();
nums.add(2);
nums.add(6);
nums.add(7);
nums.add(3);
nums.add(1);
nums.add(8);

我们创建了一个ArrayList整数。

for (int i = 0; i < nums.size(); i++) {

    System.out.printf("%d ", nums.get(i));
}

在这里,我们使用经典的 for 循环遍历列表。

for (int num : nums) {

    System.out.printf("%d ", num);
}

第二种方法使用 Java 5 中引入的 Enhanced-for 循环。

int j = 0;
while (j < nums.size()) {

    System.out.printf("%d ", nums.get(j));
    j++;
}

第三种方式使用 while 循环。

ListIterator<Integer> it = nums.listIterator();

while(it.hasNext()) {

    System.out.printf("%d ", it.next());
}

这里,ListIterator用于遍历列表。

nums.forEach(e -> System.out.printf("%d ", e));

最后,我们使用 Java 8 中引入的forEach()方法。

2 6 7 3 1 8
2 6 7 3 1 8
2 6 7 3 1 8
2 6 7 3 1 8
2 6 7 3 1 8

该示例使用各种技术将列表的元素打印到控制台。

Java ArrayList排序

ArrayList进行分类有不同的浪费。

使用其sort方法对ArrayList进行排序

ArrayList's sort()方法根据由指定比较器引起的顺序对列表进行排序。

com/zetcode/ArrayListSortingEx.java

package com.zetcode;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

class Person {

    private int age;
    private String name;

    public Person(int age, String name) {

        this.age = age;
        this.name = name;
    }

    public int getAge() {

        return age;
    }

    @Override
    public String toString() {
        return "Age: " + age + " Name: " + name;
    }
}

public class ArrayListSortingEx {

    public static void main(String[] args) {

        List<Person> persons = createList();

        persons.sort(Comparator.comparing(Person::getAge).reversed());

        System.out.println(persons);

    }

    private static List<Person> createList() {

        List<Person> persons = new ArrayList<>();

        persons.add(new Person(17, "Jane"));
        persons.add(new Person(32, "Peter"));
        persons.add(new Person(47, "Patrick"));
        persons.add(new Person(22, "Mary"));
        persons.add(new Person(39, "Robert"));
        persons.add(new Person(54, "Greg"));

        return persons;
    }
}

我们有一个自定义Person类的ArrayList。 我们按照年龄的相反顺序对其进行排序。

persons.sort(Comparator.comparing(Person::getAge).reversed());

此行按年龄(从最大到最小)对人员进行分类。

[Age: 54 Name: Greg, Age: 47 Name: Patrick, Age: 39 Name: Robert, Age: 32 Name: Peter,
    Age: 22 Name: Mary, Age: 17 Name: Jane]

This is the output.

使用 Java 8 流对ArrayList进行排序

在第二个示例中,我们使用 Java 流对ArrayList进行排序。 Streams API 是一种更强大的排序方式。

com/zetcode/ArrayListSortingEx2.java

package com.zetcode;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

class Country {

    private String name;
    private int population;

    public Country(String name, int population) {
        this.name = name;
        this.population = population;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getPopulation() {
        return population;
    }

    public void setPopulation(int population) {
        this.population = population;
    }

    @Override
    public String toString() {
        return "Country{" + "name=" + name
                + ", population=" + population + '}';
    }
}

public class ArrayListSortingEx2 {

    public static void main(String[] args) {

        List<Country> countries = createList();

        List<Country> sorted_countries = countries.stream()
                .sorted((e1, e2) -> Integer.compare(e1.getPopulation(),
                        e2.getPopulation())).collect(Collectors.toList());

        System.out.println(sorted_countries);
    }

    private static List<Country> createList() {

        List<Country> countries = new ArrayList<>();

        countries.add(new Country("Slovakia", 5424000));
        countries.add(new Country("Hungary", 9845000));
        countries.add(new Country("Poland", 38485000));
        countries.add(new Country("Germany", 81084000));
        countries.add(new Country("Latvia", 1978000));

        return countries;
    }
}

在此示例中,我们有一个国家/地区列表。 每个国家都有名字和人口。 这些国家是按人口排序的。

List<Country> sorted_countries = countries.stream()
        .sorted((e1, e2) -> Integer.compare(e1.getPopulation(),
                e2.getPopulation())).collect(Collectors.toList());

使用stream()方法,我们从列表创建流。 sorted()方法根据提供的比较器对元素进行排序。 使用Integer.compare(),我们比较了国家/地区的人口。 使用collect(),我们将信息流转换为国家列表。

[Country{name=Latvia, population=1978000}, Country{name=Slovakia, population=5424000},
Country{name=Hungary, population=9845000}, Country{name=Poland, population=38485000},
Country{name=Germany, population=81084000}]

这是输出。 这些国家按人口升序排序。

使用ArrayList和简单的 Java 数组

下面的示例使用带有简单 Java 数组的ArrayList

com/zetcode/ListToArray.java

package com.zetcode;

import java.util.Arrays;
import java.util.List;

public class ListToArray {

    public static void main(String[] args) {

        List<String> planets = Arrays.asList("Mercury", "Venus", "Earth",
                "Mars", "Jupiter", "Saturn", "Uranus", "Neptune");

        System.out.println(planets);

        String[] planets2 = planets.toArray(new String[0]);

        System.out.println(Arrays.toString(planets2));
    }
}

ArrayList转换为数组,反之亦然。

List<String> planets = Arrays.asList("Mercury", "Venus", "Earth",
        "Mars", "Jupiter", "Saturn", "Uranus", "Neptune");

使用Arrays.asList()方法,我们创建了一个由指定数组支持的固定大小的列表。

String[] planets2 = planets.toArray(new String[0]);

ArrayList's toArray()用于将列表转换为数组。

流到列表的转换

可以使用收集器将 Java 流转换为列表。

com/zetcode/ToList.java

package com.zetcode;

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class ToList {

    public static void main(String[] args) {

        var words = Stream.of("forest", "eagle", "river", "cloud", "sky");

        List<String> words2 = words.collect(Collectors.toList());
        System.out.println(words2.getClass());
    }
}

我们有一串串的字符串。 我们使用Collectors.toList()将流转换为列表。

class java.util.ArrayList

This is the output.

在本教程中,我们使用了 Java ArrayList容器。

赞(0)

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址

Java 教程