Java集合ArrayList类相关方法使用示例

x33g5p2x  于2021-08-20 转载在 Java  
字(10.4k)|赞(0)|评价(0)|浏览(183)

在本指南中,我们要看一下Java集合框架中的ArrayList类。

在本指南中,我们将通过实践案例来学习ArrayList的实现。JDK 8的特点是用于循环处理元素列表。

我们将学到什么?

List接口概述*。
ArrayList类概述
用一个例子演示List如何包含重复和空值?
List的位置访问和搜索操作

*如何在List中搜索元素?
*如何在List中进行范围查看操作?
*如何使用List进行批量操作?
在ArrayList上进行迭代
使用ListIterator接口沿任一方向遍历列表
从另一个集合中创建一个ArrayList
从一个数组中删除元素

列表接口概述

  • 一个有序的集合(也被称为序列)。它保证了一个插入的顺序。

  • 这个接口的用户可以精确控制每个元素在列表中的插入位置。

  • 它保证了插入顺序,所以用户可以通过其整数索引(在列表中的位置)访问元素,并在列表中搜索元素。

ArrayList类概述

Java ArrayList 类使用一个动态数组来存储元素。它继承了 AbstractList 类并实现了 List 接口。

关于Java ArrayListclass的重要观点是。

  • Java ArrayListclass可以包含重复的元素。

  • Java ArrayListclass可以保持插入的顺序。

  • Java ArrayListclass是非同步的。

  • Java ArrayList允许随机访问,因为数组在索引基础上工作。

  • 在Java ArrayListclass中,操作是很慢的,因为如果任何元素从数组列表中被移除,需要进行大量的移位。

###演示List如何包含重复和空值?

这个例子演示了ArrayList是如何包含重复值和空值的。

在这个例子中,我们传递了2个空值,输出应该是空值。注意,这个例子的输出打印了重复的元素。

public class ListInterfaceArrayListImpl {

    public static void main(String[] args) {
        nullValueDemo();
        duplicateValueDemo();
    }

    private static void nullValueDemo() {

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

         list.add(null);

         list.add(null);
 
         System.out.println(list.toString());
    }

    private static void duplicateValueDemo() {

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

         list.add("duplicate");
  
         list.add("duplicate");
 
          System.out.println(list.toString());

    }
}

输出。

[null, null]

[duplicate, duplicate]

列表位置的访问和搜索操作

根据元素在列表中的数字位置对其进行操作。这包括诸如get, set, add, addAll, 和 remove等方法。

基本的位置访问方法有get、set、add和remove。(set和remove操作返回被覆盖或删除的旧值)。其他操作(indexOf和lastIndexOf)返回列表中指定元素的第一个或最后一个索引。
源代码中的引用注释是自我描述的。

// The basic positional access operations are get, set, add and remove.
private static void positionalAccess() {
    List<String> list = new LinkedList<>();
    list.add("element 1");
    list.add("element 2");
    list.add("element 3");
    list.add("element 4");

    // Replaces the element at the specified position in this list with
    // the specified element (optional operation).
    list.set(3, "element 5");
    list.forEach( str -> System.out.println(" set element 5 --" + str));

    // Inserts the specified element at the specified position in this list
    // (optional operation).
    // Shifts the element currently at that position (if any) and any
    // subsequent
    // elements to the right (adds one to their indices).
    list.add(3, "element 4");
    list.forEach( str -> System.out.println(" set element 5 --" + str));

    // Returns the element at the specified position in this list.
    System.out.println(list.get(0));

    // Removes the element at the specified position in this list (optional
    // operation).
    // Shifts any subsequent elements to the left (subtracts one from their
    // indices).//
    // Returns the element that was removed from the list.
    list.remove(1);
}

如何在列表中搜索元素?

indexOf()和lastIndexOf()方法可以用来搜索列表中具有特定索引的元素。

请参考源代码中的注释,这些注释是自我描述的。

private static void searchListDemo() {
    List<String> searchList = new ArrayList();
    searchList.add("element 1");
    searchList.add("element 2");
    searchList.add("element 3");
    searchList.add("element 4");

    // Returns the index of the first occurrence of the specified element in
    // this list,
    // or -1 if this list does not contain the element.
    int index = searchList.indexOf("element 2");
    System.out.println(" search element at index 0 --->" + index);

    // Returns the index of the last occurrence of the specified element in
    // this list,
    // or -1 if this list does not contain the element
    int lastIndex = searchList.lastIndexOf("element 2");
    System.out.println(" search element at lastIndex 0 --->" + lastIndex);
}

如何在列表中执行范围视图操作?

范围视图操作,subList(int fromIndex, int toIndex),返回该列表中索引范围从fromIndex(包括)到toIndex(不包括)的部分的Listview。

//Returns a view of the portion of this list between the specified fromIndex, 
//inclusive, and toIndex, exclusive. 
public void rangeViewDemo(){
    List<String> list = new LinkedList<>();
    list.add("element 1");
    list.add("element 2");
    list.add("element 3");
    list.add("element 4");
   
    //If fromIndex and toIndex are equal, the returned list is empty.) 
    for(String str : list.subList(0, 0)){
        System.out.println(" sub list demo --" + str);
    }
   
    for(String str : list.subList(0, 1)){
        System.out.println(" sub list demo --" + str);
    }
}

###如何使用List进行批量操作?

private static void bulkOperationDemo() {
    List<String> list = new ArrayList<>();
    list.add("element 1");
    list.add("element 2");
    list.add("element 3");
    list.add("element 4");

     // addAll() - Appends all of the elements in the specified collection to
     // the end of this list,
     // in the order that they are returned by the specified collection's
     // iterator (optional operation).
    List<String> union = new ArrayList<>();
    union.addAll(list);
    printMessage(union, "addALL operation example ");

    // Retains only the elements in this list that are contained in
    // the specified collection (optional operation).
    List<String> intersection = new ArrayList<>();
    intersection.add("element 1");
    intersection.add("element 2");
    intersection.add("element 3");
    intersection.add("element 4");
    System.out.println("retainAll -- > " + intersection.retainAll(list));

    // Removes from this list all of its elements that are
    // contained in the specified collection (optional operation).
    List<String> difference = new ArrayList<>();
    difference.add("element 1");
    difference.add("element 2");
    difference.add("element 3");
    difference.add("element 4");
    System.out.println("removeAll operation example ---> " + difference.removeAll(list));
    printMessage(difference, "removeAll operation example ");  

    List<String> checking = new ArrayList<>();
    checking.add("element 1");
    checking.add("element 2");
    checking.add("element 3");
    checking.add("element 4");
    System.out.println("containsAll operation example ---- > " + checking.containsAll(list));
}

private static void printMessage(List<String> list, String message) {
 list.forEach(key -> System.out.println(message + key));
}

输出:

addALL operation example element 1

addALL operation example element 2

addALL operation example element 3

addALL operation example element 4

retainAll -- > false

removeAll operation example ---> true

containsAll operation example ---- > true

###在ArrayList上进行迭代

// Three ways to iterator list
private static void iterateDemo() {
    List<String> list = new LinkedList<>();
    list.add("element 1");
    list.add("element 2");
    list.add("element 3");
    list.add("element 4");

    // using Iterator
    Iterator<String> iterator = list.iterator();
    while (iterator.hasNext()) {
         String str = iterator.next();
         System.out.println(" only forward direction ---" + str);
    }
  
    // Using advanced for loop
    for (String str : list) {
          System.out.println(" only forward direction ---" + str);
    }
 
     // Java 8
    list.forEach(str -> System.out.println(" only forward direction ---" + str));
}

使用ListIteratorinterface沿任一方向遍历列表

一个用于列表的迭代器,允许程序员在任何方向上遍历列表,在遍历过程中修改列表,并获得迭代器在列表中的当前位置。ListIterator没有当前元素;它的光标位置总是位于调用 previous()返回的元素和调用 next()返回的元素之间。

// listOperation example
private static void listIterateDemo() {
    List<String> list = new LinkedList<>();
    list.add("element 1");
    list.add("element 2");
    list.add("element 3");
    list.add("element 4");
    ListIterator<String> iterator = list.listIterator();
    while (iterator.hasNext()) {
         String str = iterator.next();

         System.out.println("forward direction ---" + str);
    }

    while (iterator.hasPrevious()) {
          String str = iterator.previous();
         System.out.println("backward direction ---" + str);
    }

    for (ListIterator<String> it = list.listIterator(list.size()); it.hasPrevious();) {
         String t = it.previous();
         System.out.println(t);
    }
}

从另一个集合创建一个ArrayList

让我们看看如何使用*ArrayList(Collection c)*构造函数从另一个集合创建一个ArrayList。

如何使用addAll()方法,将现有集合中的所有元素添加到新的ArrayList中。

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

public class CreateArrayListFromCollectionExample {

    public static void main(String[] args) {
        List<Integer> firstFivePrimeNumbers = new ArrayList<>();
        firstFivePrimeNumbers.add(2);
        firstFivePrimeNumbers.add(3);
        firstFivePrimeNumbers.add(5);
        firstFivePrimeNumbers.add(7);
        firstFivePrimeNumbers.add(11);

        // Creating an ArrayList from another collection
        List<Integer> firstTenPrimeNumbers = new ArrayList<>(firstFivePrimeNumbers);


        List<Integer> nextFivePrimeNumbers = new ArrayList<>();
        nextFivePrimeNumbers.add(13);
        nextFivePrimeNumbers.add(17);
        nextFivePrimeNumbers.add(19);
        nextFivePrimeNumbers.add(23);
        nextFivePrimeNumbers.add(29);

        // Adding an entire collection to an ArrayList
        firstTenPrimeNumbers.addAll(nextFivePrimeNumbers);

        System.out.println(firstTenPrimeNumbers);
    }
}

输出

[2, 3, 5, 7, 11, 13, 17, 19, 23, 29]

###从ArrayList中删除元素

ArrayListclass提供了许多方法来根据需求从List中移除元素。让我们来讨论ArrayLis提供的所有移除方法。

remove(int index)

删除该列表中指定位置的元素(可选操作)。

List<String> programmingLanguages = new ArrayList<>();
programmingLanguages.add("C");
programmingLanguages.add("C++");
programmingLanguages.add("Java");
programmingLanguages.add("Kotlin");
// Remove the element at index `5`
programmingLanguages.remove(5);
System.out.println("After remove(5): " + programmingLanguages);

remove(Object o)

如果指定的元素存在的话,使用此方法从这个列表中移除它的第一次出现(可选操作)。

List<String> programmingLanguages = new ArrayList<>();
programmingLanguages.add("C");
programmingLanguages.add("C++");
programmingLanguages.add("Java");
programmingLanguages.add("Kotlin");
boolean isRemoved = programmingLanguages.remove("Kotlin");

removeAll()

从这个列表中移除所有包含在指定集合中的元素(可选操作)。

List<String> programmingLanguages = new ArrayList<>();
programmingLanguages.add("C");
programmingLanguages.add("C++");
programmingLanguages.add("Java");
programmingLanguages.add("Kotlin");

// Remove all the elements that exist in a given collection
List<String> scriptingLanguages = new ArrayList<>();
scriptingLanguages.add("Java");
scriptingLanguages.add("Kotlin");

programmingLanguages.removeAll(scriptingLanguages);

removeIf()

移除这个集合中满足给定谓词的所有元素。在迭代过程中或由谓词抛出的错误或运行时异常将被转达给调用者。

List<String> programmingLanguages = new ArrayList<>();
programmingLanguages.add("C");
programmingLanguages.add("C++");
programmingLanguages.add("Java");
programmingLanguages.add("Kotlin");

// Remove all the elements that satisfy the given predicate
programmingLanguages.removeIf(new Predicate<String>() {
 @Override
 public boolean test(String s) {
  return s.startsWith("C");
 }
});

clear()

删除这个列表中的所有元素(可选操作)。这个调用返回后,列表将是空的。

List<String> programmingLanguages = new ArrayList<>();
programmingLanguages.add("C");
programmingLanguages.add("C++");
programmingLanguages.add("Java");
programmingLanguages.add("Kotlin");

// Remove all elements from the ArrayList
programmingLanguages.clear();
System.out.println("After clear(): " + programmingLanguages);

相关文章