Java程序反向遍历ArrayList

ArrayList 是集合框架的一部分，存在于Java.util 包中。它为我们提供了Java中的动态数组，就像 C++ 中的 Vector 一样。虽然，它可能比标准数组慢，但在需要对数组进行大量操作的程序中很有帮助。任务是在 ArrayList 中插入一个元素，然后反转它或说反转方向。

例子 ：

Input :  1, 2, 3, 4, 5, 6 
Output :  6, 5, 4, 3, 2, 1 

Input :  10, 22, 34, 3, 2, 6
Output :  6, 2, 3, 34, 22, 10 

Input :  11, 22, 34, 42, 51 , 63
Output :  63, 51, 42, 34, 22, 11

有几种方法可以在下面列出的反向迭代和打印列表。

方法一：（使用ListIterator）

1.声明一个ArrayList

// size of n
ArrayList List  = new ArrayList(n);

2.通过使用 add函数，我们将元素推入 ArrayList。

3.到达ArrayList的最后一个元素后，使用迭代器遍历。如果元素出现在当前元素的后面，hasPrevious() 方法返回 true，遍历直到 hasPrevious() 返回 false。

4.遍历时打印ArrayList的当前元素。

Java

// Traverse through ArrayList in 
// reverse direction using List 
// Iterator in Java
  
import java.util.ListIterator;
import java.io.*;
import java.util.ArrayList;
  
class GFG {
    public static void main(String[] args)
    {
        // create an instance of arraylist
        ArrayList List = new ArrayList();
  
        // add elements
        List.add(10);
        List.add(9);
        List.add(8);
        List.add(7);
        List.add(6);
  
        // create a listiterator on list
        ListIterator List_Iterator
            = List.listIterator(List.size());
  
        System.out.println("Reversed : ");
  
        // print ArrayList in reverse direction using
        // listiterator
        while (List_Iterator.hasPrevious()) {
            System.out.println(List_Iterator.previous());
        }
    }
}

输出

Reversed : 
6
7
8
9
10

方法二：（使用流）

Stream API 用于处理对象集合。流是支持各种方法的对象序列，这些方法可以通过流水线来产生所需的结果。

• 使用 List.stream() 获取 Stream。
• 使用Stream.collect()将此流的元素收集到 LinkedList。
• 使用 LinkedList.descendingIterator() 方法以相反的顺序遍历 LinkedList。
• 使用 forEachRemaining() 对 ArrayList 的每个元素执行打印操作。我们可以为 forEachRemaining() 提供方法引用System.out::println Iterator。

Java

// Traverse through ArrayList in
// reverse direction Using
// stream in Java
  
import java.lang.*;
import java.util.stream.*;
import java.util.*;
import java.io.*;
  
class GFG {
    public static void main(String[] args)
    {
        // create a list
        List Arlist = Arrays.asList(5, 2, 4, 8);
        System.out.println("Reversed : ");
  
        // create a stream
        // collect the elements after these operations
        // create a descending iterator on the stream
        // loop through the descending iterator
        // print the element
        Arlist.stream()
            .collect(
                Collectors.toCollection(LinkedList::new))
            .descendingIterator()
            .forEachRemaining(System.out::println);
    }
}

输出

Reversed : 
8
4
2
5

方法 3：（使用 For 循环）我们知道 List 是一个有序集合，我们可以通过它的索引来访问列表的元素，所以定义一个 ArrayList 并使用 for 循环从最后一个元素迭代到第一个元素并打印每个元素。

Java

// Traverse through ArrayList in
// reverse direction using For
// Loop in Java
import java.util.*;
import java.io.*;
  
class GFG {
    public static void main(String[] args)
    {
  
        // create a list
        List Arlist = Arrays.asList(5, 4, 8, 2);
  
        System.out.println("Reversed :");
  
        // Printing in reverse
        for (int i = Arlist.size() - 1; i >= 0; i--) {
            System.out.println(Arlist.get(i));
        }
    }
}

输出

Reversed :
2
8
4
5

方法四：（使用Apache Common的ReverseListIterator）

此方法提供了 ReverseListIterator，我们可以使用它以相反的顺序迭代 List。当我们使用 ReverseListIterator 然后 next() 将返回数组列表中的最后一个元素，然后当我们调用 next element then next 括号将返回当前元素的前一个元素，并且 has next 将检查我们的 ArrayList 是否包含一个元素或不。

Java

// Traverse through ArrayList in reverse direction using
// ReverseListIterator in Java
  
import org.apache.commons.collections.iterators.ReverseListIterator;
  
import java.util.Arrays;
import java.util.List;
  
class Main {
    public static void main(String[] args)
    {
  
        // create a list
        List list = Arrays.asList(1, 5, 8, 7);
  
        // create a reverse listiterator
        ReverseListIterator it
            = new ReverseListIterator(list);
        System.out.println("Reversed : ");
  
        // print the elements
        while (it.hasNext()) {
            System.out.println(it.next());
        }
    }
}

输出

Reversed :
7
8
5
1

时间复杂度： O(n)