วนซ้ำรายการในลำดับย้อนกลับใน java

ฉันกำลังโยกย้ายรหัสเพื่อใช้ประโยชน์จาก Generics อาร์กิวเมนต์หนึ่งสำหรับการทำเช่นนั้นคือ for for loop นั้นสะอาดกว่าการติดตามดัชนีหรือใช้ตัววนซ้ำอย่างชัดเจน

ในกรณีประมาณครึ่งหนึ่งรายการ (ArrayList) จะถูกทำซ้ำในลำดับย้อนกลับโดยใช้ดัชนีวันนี้

ใครช่วยแนะนำวิธีที่สะอาดกว่าในการทำสิ่งนี้ (ตั้งแต่ฉันไม่ชอบindexed for loopเมื่อทำงานกับคอลเลกชัน) แม้ว่ามันจะใช้งานได้?

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

หมายเหตุ:ฉันไม่สามารถเพิ่มการอ้างอิงใหม่นอก JDK

ลองสิ่งนี้:

// 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());
}

ฝรั่งข้อเสนอและLists#reverse(List) ImmutableList#reverse()ในกรณีส่วนใหญ่สำหรับ Guava ผู้ได้รับมอบหมายคนก่อนจะเป็นฝ่ายหลังหากข้อโต้แย้งเป็นImmutableListดังนั้นคุณสามารถใช้แบบดั้งเดิมในทุกกรณี สิ่งเหล่านี้จะไม่สร้างสำเนาใหม่ของรายการ แต่เพียงแค่ "มุมมองย้อนกลับ" ของรายการ

ตัวอย่าง

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

ฉันไม่คิดว่าเป็นไปได้ที่จะใช้สำหรับไวยากรณ์วนรอบ สิ่งเดียวที่ฉันแนะนำได้คือทำสิ่งที่ชอบ:

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

... แต่ฉันจะไม่บอกว่านี่คือ "สะอาด" เนื่องจากมันจะมีประสิทธิภาพน้อยลง

ตัวเลือกที่ 1: คุณคิดที่จะย้อนกลับรายการด้วยชุด # ย้อนกลับ ()แล้วใช้ foreach หรือไม่

แน่นอนคุณอาจต้องการ refactor รหัสของคุณเพื่อให้รายการถูกต้องดังนั้นคุณไม่จำเป็นต้องย้อนกลับซึ่งใช้พื้นที่ / เวลาเพิ่มเติม

แก้ไข:

ตัวเลือกที่ 2: อีกวิธีหนึ่งคุณสามารถใช้Dequeแทน ArrayList ได้หรือไม่ มันจะช่วยให้คุณย้ำไปข้างหน้าและข้างหลัง

แก้ไข:

ตัวเลือก 3: ตามที่คนอื่น ๆ แนะนำคุณสามารถเขียน Iterator ที่จะย้อนกลับไปในรายการโดยย้อนกลับนี่คือตัวอย่าง:

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);
}

คุณสามารถใช้ชั้นคอนกรีตแทนของอินเตอร์เฟซทั่วไปLinkedList Listจากนั้นคุณมีการdescendingIteratorวนซ้ำสำหรับทิศทางย้อนกลับ

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

ไม่ทราบว่าทำไมไม่มีdescendingIteratorกับArrayList...

นี่เป็นคำถามเก่า แต่ไม่มีคำตอบที่เป็นมิตรกับ java8 ต่อไปนี้เป็นวิธีการย้อนรายการซ้ำด้วยความช่วยเหลือของ Streaming API:

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

นี่คือ (ทดสอบ) ReverseIterableการดำเนินงานของ เมื่อiterator()ถูกเรียกว่ามันจะสร้างผลตอบแทนและเอกชนReverseIteratorดำเนินการซึ่งก็โทรไปยังแผนที่hasNext()ไปhasPrevious()และโทรไปถูกแมปไปnext() previous()มันหมายความว่าคุณสามารถทำซ้ำArrayListในสิ่งที่ตรงกันข้ามดังนี้:

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

นิยามคลาส

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()));
  }
}

หากรายการมีขนาดค่อนข้างเล็กเพื่อให้ประสิทธิภาพไม่ใช่ปัญหาจริงคุณสามารถใช้reverse-metod ของLists-class in Google Guavaได้ ผลตอบแทนfor-each-code สวยและรายการเดิมยังคงเหมือนเดิม นอกจากนี้รายการที่กลับรายการจะได้รับการสนับสนุนโดยรายการดั้งเดิมดังนั้นการเปลี่ยนแปลงใด ๆ ในรายการเดิมจะปรากฏในรายการที่กลับรายการ

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);

ให้ผลลัพธ์ต่อไปนี้:

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

ซึ่งหมายความว่าการทำซ้ำย้อนกลับของ myList สามารถเขียนเป็น:

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

reverseIterableสร้างที่กำหนดเอง

ตัวอย่างง่าย ๆ :

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) {
  ...
}

คุณสามารถใช้ReverseListIteratorจาก Apache Commons-Collections:

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

พบวิธีการย้อนกลับของคอลเลกชัน google

ในการมีรหัสซึ่งมีลักษณะดังนี้:

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

ใส่รหัสนี้เป็นไฟล์ชื่อ "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();
                }
            };
        }
    }
}

ในฐานะที่ได้รับการแนะนำอย่างน้อยสองครั้งคุณสามารถใช้descendingIteratorด้วยโดยเฉพาะอย่างยิ่งกับDeque LinkedListหากคุณต้องการใช้ for-each loop (เช่นมีIterable) คุณสามารถสร้างและใช้ wraper ได้ดังนี้

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);
        }
    }
}

เหตุผล: "ไม่ทราบสาเหตุที่ไม่มีตัวลดราคาตัวจัดการกับ ArrayList ... "

เนื่องจากรายการอาร์เรย์ไม่เก็บรายการไว้ในลำดับเดียวกันกับที่ข้อมูลถูกเพิ่มเข้าในรายการ ดังนั้นอย่าใช้ Arraylist

รายการที่เชื่อมโยงจะเก็บข้อมูลในลำดับเดียวกันของ ADD ไปยังรายการ

ดังนั้นในตัวอย่างของฉันฉันใช้ ArrayList () เพื่อให้ผู้ใช้บิดใจและทำให้พวกเขาออกกำลังกายบางอย่างจากด้านข้างของพวกเขา

แทนที่จะเป็นแบบนี้

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

ใช้:

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) {
  ...
}