java의 각 루프에 대해 역순으로 할 수 있습니다.

java의 각 루프에 대해 역순으로 할 수 있습니다.

Java를 사용하여 목록을 역순으로 실행해야 합니다.

그러면 어떤 효과가 있을까요?

for(String string: stringList){
//...do something
}

구문별로 를 사용하여 stringList를 역순으로 반복하는 방법이 있습니까?

알기 쉽게 하기 위해:목록을 역순으로 반복하는 방법은 알고 있지만 (호기심을 위해) 각 스타일에 대해 에서 수행하는 방법을 알고 싶습니다.

Collections.reverse 메서드는 원래 목록의 요소를 역순으로 복사한 새 목록을 반환하므로 원래 목록의 크기에 대한 O(n) 성능이 있습니다.

보다 효율적인 해결책으로 목록을 반복 가능한 목록으로 역방향으로 표시하는 장식기를 작성할 수 있습니다.데코레이터에 의해 반환된 반복자는 장식된 목록의 ListIterator를 사용하여 요소를 역순으로 이동합니다.

예를 들어 다음과 같습니다.

public class Reversed<T> implements Iterable<T> {
    private final List<T> original;

    public Reversed(List<T> original) {
        this.original = original;
    }

    public Iterator<T> iterator() {
        final ListIterator<T> i = original.listIterator(original.size());

        return new Iterator<T>() {
            public boolean hasNext() { return i.hasPrevious(); }
            public T next() { return i.previous(); }
            public void remove() { i.remove(); }
        };
    }

    public static <T> Reversed<T> reversed(List<T> original) {
        return new Reversed<T>(original);
    }
}

그리고 다음과 같이 사용할 수 있습니다.

import static Reversed.reversed;

...

List<String> someStrings = getSomeStrings();
for (String s : reversed(someStrings)) {
    doSomethingWith(s);
}

목록을 보려면 Google Guava 라이브러리를 사용할 수 있습니다.

for (String item : Lists.reverse(stringList))
{
    // ...
}

는 전체 컬렉션을 되돌리거나 이와 유사한 작업을 수행하는 것이 아니라 역순으로 반복 및 랜덤 액세스를 허용합니다.이것은 수집을 먼저 되돌리는 것보다 더 효율적입니다.

임의의 반복가능성을 되돌리려면 모든 내용을 읽고 "재생"해야 합니다.

(아직 사용하지 않으셨다면 Guava를 꼭 보시길 권합니다.훌륭한 물건입니다.)

목록(세트와 달리)은 주문된 컬렉션이며, 이 목록을 반복하여 계약에 따라 주문을 보존합니다.스택이 역순으로 반복될 것으로 예상했지만 안타깝게도 그렇지 않습니다.제가 생각할 수 있는 가장 간단한 해결책은 다음과 같습니다.

for (int i = stack.size() - 1; i >= 0; i--) {
    System.out.println(stack.get(i));
}

이것은 「각의」루프 솔루션이 아니라는 것을 알고 있습니다.Google 컬렉션과 같은 새로운 라이브러리를 도입하는 것보다 for 루프를 사용하는 것이 좋습니다.

collections.reverse()도 작업을 수행하지만 복사본을 역순으로 반환하는 것이 아니라 목록을 업데이트합니다.

그러면 원래 목록이 엉망이 되어 루프 외부에서 호출해야 합니다.. 으로 하는 ?게사 ??Iterables.reverse ideas적용되었습니까?

Collections.reverse(stringList);

for(String string: stringList){
//...do something
}

AFAIK 표준 라이브러리에는 표준적인 "reverse_iterator" 같은 것이 없습니다.각 구문을 지원하는 것은 이미 언어에서 뒤늦게 가져온 구문설탕입니다.

(Item 요소: myList.clone().reverse()와 같은 작업을 수행하여 관련 가격을 지불할 수 있습니다.

이것은 고가의 조작에 편리한 방법을 제공하지 않는 명백한 현상과도 꽤 일치합니다.정의상 리스트는 O(N) 랜덤 액세스의 복잡성(단일 링크를 사용하여 인터페이스를 구현할 수 있음), 역반복은 O(N^2)가 될 수 있기 때문입니다.물론 Array List가 있는 경우에는 그 값을 지불하지 않습니다.

코멘트 현재:Apache Commons를 사용할 수 있어야 합니다.

Iterable<String> reverse 
    = new IteratorIterable(new ReverseListIterator(stringList));

for(String string: reverse ){
    //...do something
}

@rogerdpack이 말했듯이ReverseListIterator로서Iterable.

Roland Nordborg-Lövstad가 코멘트에서 추천한 바와 같이 현재 Java에서는 Lambdas를 사용하여 심플화할 수 있습니다.

Iterable<String> reverse = () -> new ReverseListIterator<>(stringList)

이것은 옵션일 수 있습니다.마지막으로 루프하는 것보다 마지막 요소에서 시작하는 방법이 더 낫기를 바랍니다.

public static void main(String[] args) {        
    List<String> a = new ArrayList<String>();
    a.add("1");a.add("2");a.add("3");a.add("4");a.add("5");

    ListIterator<String> aIter=a.listIterator();        
    while(aIter.hasNext()) aIter.next();

    for (;aIter.hasPrevious();)
    {
        String aVal = aIter.previous();
        System.out.println(aVal);           
    }
}

A의 개요:

Collections.reverse(stringList).forEach(str -> ...);

또는 guava:

Lists.reverse(stringList).forEach(str -> ...);

요소를 반전시키는 열거자를 제공하는 사용자 지정 코드를 작성하지 않고서는 안 됩니다.

요소를 역순으로 반환하는 Itable의 커스텀 구현을 작성함으로써 Java에서 이를 수행할 수 있습니다.

그런 다음 래퍼를 인스턴스화(또는 메서드, What-have-you 라고 부릅니다)합니다.이것에 의해, 각 루프에 대해서 의 요소를 반전시키는 Itable 실장이 반환됩니다.

기본 각 구문에 대해 를 사용하여 역순으로 진행하려면 수집을 역방향으로 합니다.

위의 모든 답변은 다른 메서드를 포장하거나 외부로 외부 코드를 호출하는 방법으로만 요건을 충족합니다.

다음은 Java 4판 11.13.1 AdapterMethodIdiom의 Thinking in Java 4장에서 복사한 솔루션입니다.

코드는 다음과 같습니다.

// The "Adapter Method" idiom allows you to use foreach
// with additional kinds of Iterables.
package holding;
import java.util.*;

@SuppressWarnings("serial")
class ReversibleArrayList<T> extends ArrayList<T> {
  public ReversibleArrayList(Collection<T> c) { super(c); }
  public Iterable<T> reversed() {
    return new Iterable<T>() {
      public Iterator<T> iterator() {
        return new Iterator<T>() {
          int current = size() - 1; //why this.size() or super.size() wrong?
          public boolean hasNext() { return current > -1; }
          public T next() { return get(current--); }
          public void remove() { // Not implemented
            throw new UnsupportedOperationException();
          }
        };
      }
    };
  }
}   

public class AdapterMethodIdiom {
  public static void main(String[] args) {
    ReversibleArrayList<String> ral =
      new ReversibleArrayList<String>(
        Arrays.asList("To be or not to be".split(" ")));
    // Grabs the ordinary iterator via iterator():
    for(String s : ral)
      System.out.print(s + " ");
    System.out.println();
    // Hand it the Iterable of your choice
    for(String s : ral.reversed())
      System.out.print(s + " ");
  }
} /* Output:
To be or not to be
be to not or be To
*///:~

Collections 클래스를 사용하여 목록을 반전시킨 후 루프를 수행할 수 있습니다.

이 질문에 대한 답변이 늦었군요.하나의 방법은 for 루프에서 ListIterator를 사용하는 것입니다.대장신택스만큼 깨끗하진 않지만 효과가 있어요

List<String> exampleList = new ArrayList<>();
exampleList.add("One");
exampleList.add("Two");
exampleList.add("Three");

//Forward iteration
for (String currentString : exampleList) {
    System.out.println(currentString); 
}

//Reverse iteration
for (ListIterator<String> itr = exampleList.listIterator(exampleList.size()); itr.hasPrevious(); /*no-op*/ ) {
    String currentString = itr.previous();
    System.out.println(currentString); 
}

ListIterator 구문에 대한 크레딧은 "Java에서 목록을 반복하는 방법"으로 지정됩니다.

예.

Integer[][] a = {
                { 1, 2, 3 }, 
                { 4, 5, 6 }, 
                { 9, 8, 9 }, 
                };

List<List<Integer>> arr = Arrays.stream(a)
                .map(Arrays::asList)
                .collect(Collectors.toList());

지금 뒤집어라.

Collections.reverse(arr);
System.out.println("Reverse Array" + arr);
for (List<Integer> obj : arr) {
    // TODO
}

언급URL : https://stackoverflow.com/questions/1098117/can-one-do-a-for-each-loop-in-java-in-reverse-order