Her döngü için javada ters sırada yapılabilir mi?

Java kullanarak bir Listeyi ters sırada çalıştırmam gerekiyor.

Peki bu nereye gidiyor:

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

Her sözdizimi için kullanarak stringList'i ters sırada yinelemenin bir yolu var mı ?

Açıklık getirmek için: Bir listeyi ters sırada nasıl yineleyeceğimi biliyorum, ancak (merak uğruna) her stil için nasıl yapılacağını bilmek istiyorum .

Collections.reverse yöntemi aslında orijinal listenin öğelerinin ters sırada kopyalanmış olduğu yeni bir liste döndürür, bu nedenle bu, orijinal listenin boyutuna göre O (n) performansına sahiptir.

Daha verimli bir çözüm olarak, bir Listenin tersine çevrilmiş görünümünü Yinelenebilir olarak sunan bir dekoratör yazabilirsiniz. Dekoratörünüz tarafından döndürülen yineleyici, öğeler üzerinde ters sırada gezinmek için dekore edilmiş listenin ListIterator'ını kullanır.

Örneğin:

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

Ve bunu şu şekilde kullanırsınız:

import static Reversed.reversed;

...

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

Liste için Google Guava Kitaplığını kullanabilirsiniz :

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

Not gelmez bütün koleksiyonunu ters veya böyle bir şey yok - bu sadece ters sırada, iterasyon ve rastgele erişim sağlar. Bu, önce koleksiyonu tersine çevirmekten daha etkilidir.Lists.reverse

Keyfi bir yinelenebilirliği tersine çevirmek için hepsini okumanız ve ardından geriye doğru "yeniden oynatmanız" gerekir.

(Henüz kullanmıyorsanız, Guava'ya iyice bir göz atmanızı tavsiye ederim . Harika bir şey.)

Liste (Set'in aksine) sıralı bir koleksiyondur ve üzerinde yinelendiğinde, siparişi sözleşmeye göre korur. Bir Yığın ters sırada yinelenmesini beklerdim ama maalesef öyle değil. Yani düşünebildiğim en basit çözüm şudur:

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

Bunun "her biri için" döngü çözümü olmadığının farkındayım. Google Koleksiyonları gibi yeni bir kitaplık sunmaktansa for döngüsünü kullanmayı tercih ederim.

Collections.reverse () de işi yapar ancak bir kopyayı ters sırada döndürmek yerine listeyi günceller.

Bu, orijinal listeyi karıştırır ve ayrıca döngünün dışında çağrılması gerekir. Ayrıca her döngüde bir ters çevirme yapmak istemezsiniz - bunlardan biri Iterables.reverse ideasuygulanmış olsaydı bu doğru olur muydu?

Collections.reverse(stringList);

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

AFAIK, standart kitaplıkta, her bir sözdizimi için destekleyen standart bir "ters_itleyici" türü yoktur ki bu zaten dile geç getirdikleri sözdizimsel bir şekerdir.

(Item element: myList.clone (). Reverse ()) gibi bir şey yapabilir ve ilgili fiyatı ödeyebilirsiniz.

Bu aynı zamanda, size pahalı işlemler yapmanın uygun yollarını sunmama fenomeni ile oldukça tutarlı görünüyor - çünkü bir liste, tanımı gereği, O (N) rastgele erişim karmaşıklığına sahip olabilir (arayüzü tek bağlantıyla uygulayabilirsiniz), tersine yineleme O (N ^ 2) olabilir. Tabii bir ArrayList'iniz varsa, bu bedeli ödemezsiniz.

Bu bir seçenek olabilir. Umarım son öğeden başlamak için döngüden sonuna kadar başlamaktan daha iyi bir yol vardır.

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

İtibariyle comment : Apache Commons kullanmaya muktedir olmalıdırReverseListIterator

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

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

Gibi @rogerdpack dedi , sen sarmak gerekiyor ReverseListIteratorbir şekilde Iterable.

Öğeleri sizin için tersine çevirecek bir numaralandırıcı verecek özel bir kod yazmadan olmaz.

Öğeleri ters sırayla döndürecek özel bir Yinelenebilir uygulaması oluşturarak bunu Java'da yapabilmelisiniz.

Daha sonra, sarmalayıcıyı başlatırsınız (veya yöntemi çağırırsınız, neye sahip olursunuz), bu da her döngü için öğedeki öğeyi tersine çeviren Yinelenebilir uygulamayı döndürür.

Kutudan çıkan her sözdizimi için kullanmak ve ters sırada gitmek istiyorsanız, koleksiyonunuzu tersine çevirmeniz gerekir.

Yukarıdaki tüm yanıtlar, yalnızca başka bir yöntemi paketleyerek veya dışarıdan bazı yabancı kodu çağırarak gereksinimi karşılar;

İşte Thinking in Java 4th edition , bölüm 11.13.1 AdapterMethodIdiom'dan kopyalanan çözüm ;

İşte kod:

// 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
*///:~

Etrafında bir çalışma:

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

Veya guava ile :

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

Listeyi ters çevirmek ve sonra döngüye almak için Collections sınıfını kullanabilirsiniz .

Bu soruya kesinlikle geç bir cevap. Bir olasılık, ListIterator'ı bir for döngüsünde kullanmaktır. İki nokta üst üste sözdizimi kadar temiz değil, ama işe yarıyor.

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 sözdizimi için kredi "Java'da bir liste üzerinde yineleme yolları" na gider