Lặp lại thông qua một danh sách theo thứ tự ngược lại trong java

Tôi đang di chuyển một đoạn mã để sử dụng thuốc generic. Một đối số để làm như vậy là vòng lặp for sạch hơn nhiều so với theo dõi các chỉ mục hoặc sử dụng một trình vòng lặp rõ ràng.

Trong khoảng một nửa các trường hợp, danh sách (một ArrayList) đang được lặp lại theo thứ tự ngược lại bằng cách sử dụng một chỉ mục ngày hôm nay.

Ai đó có thể đề xuất một cách sạch hơn để làm điều này (vì tôi không thích indexed for loopkhi làm việc với các bộ sưu tập), mặc dù nó không hoạt động?

 for (int i = nodes.size() - 1; i >= 0; i--) {
    final Node each = (Node) nodes.get(i);
    ...
 }

Lưu ý: Tôi không thể thêm bất kỳ phụ thuộc mới nào bên ngoài JDK.

Thử cái này:

// Substitute appropriate type.
ArrayList<...> a = new ArrayList<...>();

// Add elements to list.

// Generate an iterator. Start just after the last element.
ListIterator li = a.listIterator(a.size());

// Iterate in reverse.
while(li.hasPrevious()) {
  System.out.println(li.previous());
}

Quả ổi cung cấp Lists#reverse(List)và ImmutableList#reverse(). Như trong hầu hết các trường hợp cho Guava, các đại biểu trước cho sau này nếu đối số là một ImmutableList, vì vậy bạn có thể sử dụng cái trước trong mọi trường hợp. Những thứ này không tạo ra các bản sao mới của danh sách mà chỉ là "các quan điểm đảo ngược" của nó.

Thí dụ

List reversed = ImmutableList.copyOf(myList).reverse();

Tôi không nghĩ rằng nó có thể sử dụng cú pháp vòng lặp for. Điều duy nhất tôi có thể đề nghị là làm một cái gì đó như:

Collections.reverse(list);
for (Object o : list) {
  ...
}

... nhưng tôi sẽ không nói đây là "sạch" hơn vì nó sẽ kém hiệu quả hơn.

Tùy chọn 1: Bạn có nghĩ về việc đảo ngược Danh sách với Bộ sưu tập # Reverse () và sau đó sử dụng foreach chưa?

Tất nhiên, bạn cũng có thể muốn cấu trúc lại mã của mình sao cho danh sách được sắp xếp chính xác để bạn không phải đảo ngược mã, sử dụng thêm không gian / thời gian.

BIÊN TẬP:

Tùy chọn 2: Ngoài ra, bạn có thể sử dụng Deque thay vì ArrayList không? Nó sẽ cho phép bạn lặp đi lặp lại

BIÊN TẬP:

Tùy chọn 3: Như những người khác đã đề xuất, bạn có thể viết một Iterator sẽ đi qua danh sách ngược lại, đây là một ví dụ:

import java.util.Iterator;
import java.util.List;

public class ReverseIterator<T> implements Iterator<T>, Iterable<T> {

    private final List<T> list;
    private int position;

    public ReverseIterator(List<T> list) {
        this.list = list;
        this.position = list.size() - 1;
    }

    @Override
    public Iterator<T> iterator() {
        return this;
    }

    @Override
    public boolean hasNext() {
        return position >= 0;
    }

    @Override
    public T next() {
        return list.get(position--);
    }

    @Override
    public void remove() {
        throw new UnsupportedOperationException();
    }

}


List<String> list = new ArrayList<String>();
list.add("A");
list.add("B");
list.add("C");
list.add("D");
list.add("E");

for (String s : new ReverseIterator<String>(list)) {
    System.out.println(s);
}

Bạn có thể sử dụng lớp cụ thể LinkedListthay vì giao diện chung List. Sau đó, bạn có một descendingIteratorlặp đi lặp lại với hướng ngược lại.

LinkedList<String > linkedList;
for( Iterator<String > it = linkedList.descendingIterator(); it.hasNext(); ) {
    String text = it.next();
}

Không biết tại sao không descendingIteratorcó ArrayList...

Đây là một câu hỏi cũ, nhưng nó thiếu một câu trả lời thân thiện với java8. Dưới đây là một số cách lặp lại danh sách, với sự trợ giúp của API truyền phát:

List<Integer> list = new ArrayList<Integer>(Arrays.asList(1, 3, 3, 7, 5));
list.stream().forEach(System.out::println); // 1 3 3 7 5

int size = list.size();

ListIterator<Integer> it = list.listIterator(size);
Stream.generate(it::previous).limit(size)
    .forEach(System.out::println); // 5 7 3 3 1

ListIterator<Integer> it2 = list.listIterator(size);
Stream.iterate(it2.previous(), i -> it2.previous()).limit(size)
    .forEach(System.out::println); // 5 7 3 3 1

// If list is RandomAccess (i.e. an ArrayList)
IntStream.range(0, size).map(i -> size - i - 1).map(list::get)
    .forEach(System.out::println); // 5 7 3 3 1

// If list is RandomAccess (i.e. an ArrayList), less efficient due to sorting
IntStream.range(0, size).boxed().sorted(Comparator.reverseOrder())
    .map(list::get).forEach(System.out::println); // 5 7 3 3 1

Đây là một thực hiện (chưa được kiểm tra) của a ReverseIterable. Khi iterator()được gọi, nó tạo và trả về một ReverseIteratortriển khai riêng , chỉ đơn giản là ánh xạ các cuộc gọi hasNext()đến hasPrevious()và các cuộc gọi next()được ánh xạ tới previous(). Nó có nghĩa là bạn có thể lặp đi lặp ArrayListlại như sau:

ArrayList<String> l = ...
for (String s : new ReverseIterable(l)) {
  System.err.println(s);
}

Định nghĩa lớp

public class ReverseIterable<T> implements Iterable<T> {
  private static class ReverseIterator<T> implements Iterator {
    private final ListIterator<T> it;

    public boolean hasNext() {
      return it.hasPrevious();
    }

    public T next() {
      return it.previous();
    }

    public void remove() {
      it.remove();
    }
  }

  private final ArrayList<T> l;

  public ReverseIterable(ArrayList<T> l) {
    this.l = l;
  }

  public Iterator<T> iterator() {
    return new ReverseIterator(l.listIterator(l.size()));
  }
}

Nếu các danh sách khá nhỏ để hiệu suất không phải là vấn đề thực sự, người ta có thể sử dụng reverse-metod của- Listsclass in Google Guava. for-eachMang lại mã khá , và danh sách ban đầu vẫn giữ nguyên. Ngoài ra, danh sách đảo ngược được hỗ trợ bởi danh sách ban đầu, vì vậy mọi thay đổi đối với danh sách ban đầu sẽ được phản ánh trong danh sách đảo ngược.

import com.google.common.collect.Lists;

[...]

final List<String> myList = Lists.newArrayList("one", "two", "three");
final List<String> myReverseList = Lists.reverse(myList);

System.out.println(myList);
System.out.println(myReverseList);

myList.add("four");

System.out.println(myList);
System.out.println(myReverseList);

Mang lại kết quả sau:

[one, two, three]
[three, two, one]
[one, two, three, four]
[four, three, two, one]

Điều đó có nghĩa là phép lặp ngược của myList có thể được viết là:

for (final String someString : Lists.reverse(myList)) {
    //do something
}

Tạo một tùy chỉnh reverseIterable.

Ví dụ rất đơn giản:

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

list.add("ravi");

list.add("kant");

list.add("soni");

// Iterate to disply : result will be as ---     ravi kant soni

for (String name : list) {
  ...
}

//Now call this method

Collections.reverse(list);

// iterate and print index wise : result will be as ---     soni kant ravi

for (String name : list) {
  ...
}

Bạn có thể sử dụng ReverseListIteratortừ Bộ sưu tập chung của Apache:

https://commons.apache.org/proper/commons-collections/apidocs/org/apache/commons/collections4/iterators/ReverseListIterator.html

Cũng tìm thấy google bộ sưu tập phương pháp đảo ngược .

Để có mã trông như thế này:

List<Item> items;
...
for (Item item : In.reverse(items))
{
    ...
}

Đặt mã này vào một tệp có tên "In.java":

import java.util.*;

public enum In {;
    public static final <T> Iterable<T> reverse(final List<T> list) {
        return new ListReverseIterable<T>(list);
    }

    class ListReverseIterable<T> implements Iterable<T> {
        private final List<T> mList;

        public ListReverseIterable(final List<T> list) {
            mList = list;
        }

        public Iterator<T> iterator() {
            return new Iterator<T>() {
                final ListIterator<T> it = mList.listIterator(mList.size());

                public boolean hasNext() {
                    return it.hasPrevious();
                }
                public T next() {
                    return it.previous();
                }
                public void remove() {
                    it.remove();
                }
            };
        }
    }
}

Như đã được đề xuất ít nhất hai lần, bạn có thể sử dụng descendingIteratorvới a Deque, đặc biệt là với a LinkedList. Nếu bạn muốn sử dụng vòng lặp for- Iterableevery (nghĩa là có một ), bạn có thể xây dựng và sử dụng một trình bao bọc như thế này:

import java.util.*;

public class Main {

    public static class ReverseIterating<T> implements Iterable<T> {
        private final LinkedList<T> list;

        public ReverseIterating(LinkedList<T> list) {
            this.list = list;
        }

        @Override
        public Iterator<T> iterator() {
            return list.descendingIterator();
        }
    }

    public static void main(String... args) {
        LinkedList<String> list = new LinkedList<String>();
        list.add("A");
        list.add("B");
        list.add("C");
        list.add("D");
        list.add("E");

        for (String s : new ReverseIterating<String>(list)) {
            System.out.println(s);
        }
    }
}

Lý do: "Không biết tại sao không có Trình giảm dần với ArrayList ..."

Vì danh sách mảng không giữ danh sách theo thứ tự như dữ liệu đã được thêm vào danh sách. Vì vậy, không bao giờ sử dụng Arraylist.

Danh sách được liên kết sẽ giữ dữ liệu theo thứ tự THÊM vào danh sách.

Vì vậy, ở trên trong ví dụ của tôi, tôi đã sử dụng ArrayList () để khiến người dùng vặn vẹo tâm trí và khiến họ tập luyện một thứ gì đó từ phía họ.

Thay vì cái này

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

SỬ DỤNG:

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

list.add("ravi");

list.add("kant");

list.add("soni");

// Iterate to disply : result will be as ---     ravi kant soni

for (String name : list) {
  ...
}

//Now call this method

Collections.reverse(list);

// iterate and print index wise : result will be as ---     soni kant ravi

for (String name : list) {
  ...
}