Come ottenere una vista elenco invertita su un elenco in Java?

Voglio avere una vista elenco invertita su un elenco (in modo simile a quello che List#sublistfornisce una vista elenco secondario su un elenco). C'è qualche funzione che fornisce questa funzionalità?

Non voglio fare alcun tipo di copia dell'elenco né modificare l'elenco.

Basterebbe se, in questo caso, potessi ottenere almeno un iteratore inverso in un elenco.

Inoltre, so come implementarlo da solo. Sto solo chiedendo se Java fornisce già qualcosa del genere.

Implementazione demo:

static <T> Iterable<T> iterableReverseList(final List<T> l) {
    return new Iterable<T>() {
        public Iterator<T> iterator() {
            return new Iterator<T>() {
                ListIterator<T> listIter = l.listIterator(l.size());                    
                public boolean hasNext() { return listIter.hasPrevious(); }
                public T next() { return listIter.previous(); }
                public void remove() { listIter.remove(); }                 
            };
        }
    };
}

Ho appena scoperto che alcune Listimplementazioni hanno descendingIterator()ciò di cui ho bisogno. Sebbene non ci sia una tale implementazione generale per List. Il che è strano perché l'implementazione che ho visto LinkedListè abbastanza generale da funzionare con qualsiasi List.

Guava fornisce questo: Lists.reverse (Elenco)

List<String> letters = ImmutableList.of("a", "b", "c");
List<String> reverseView = Lists.reverse(letters); 
System.out.println(reverseView); // [c, b, a]

A differenza Collections.reverse, questa è puramente una vista ... non altera l'ordinamento degli elementi nell'elenco originale. Inoltre, con un elenco originale modificabile, le modifiche all'elenco originale e alla vista si riflettono nell'altro.

Usa il metodo .clone () sul tuo Elenco. Restituirà una copia superficiale, il che significa che conterrà puntatori agli stessi oggetti, quindi non dovrai copiare l'elenco. Quindi usa solo le raccolte.

Quindi,

Collections.reverse(list.clone());

Se stai usando un Liste non hai accesso a clone()puoi usare subList():

List<?> shallowCopy = list.subList(0, list.size());
Collections.reverse(shallowCopy);

Se ho capito bene, allora è una riga di codice. Ha funzionato per me.

 Collections.reverse(yourList);

Non è esattamente elegante, ma se si utilizza List.listIterator (indice int) è possibile ottenere un ListIterator bidirezionale alla fine dell'elenco:

//Assume List<String> foo;
ListIterator li = foo.listIterator(foo.size());

while (li.hasPrevious()) {
   String curr = li.previous()
}

Collections.reverse (nums) ... In realtà inverte l'ordine degli elementi. Il codice seguente dovrebbe essere molto apprezzato -

List<Integer> nums = new ArrayList<Integer>();
nums.add(61);
nums.add(42);
nums.add(83);
nums.add(94);
nums.add(15);
//Tosort the collections uncomment the below line
//Collections.sort(nums); 

Collections.reverse(nums);

System.out.println(nums);

Uscita: 15,94,83,42,61

java.util.Dequeha descendingIterator()- se il tuo Listè un Deque, puoi usarlo.

So che questo è un vecchio post, ma oggi stavo cercando qualcosa di simile. Alla fine ho scritto il codice da solo:

private List reverseList(List myList) {
    List invertedList = new ArrayList();
    for (int i = myList.size() - 1; i >= 0; i--) {
        invertedList.add(myList.get(i));
    }
    return invertedList;
}

Non consigliato per elenchi lunghi, questo non è affatto ottimizzato. È una soluzione semplice per scenari controllati (gli elenchi che gestisco non hanno più di 100 elementi).

Spero che aiuti qualcuno.

Io lo uso questo:

public class ReversedView<E> extends AbstractList<E>{

    public static <E> List<E> of(List<E> list) {
        return new ReversedView<>(list);
    }

    private final List<E> backingList;

    private ReversedView(List<E> backingList){
        this.backingList = backingList;
    }

    @Override
    public E get(int i) {
        return backingList.get(backingList.size()-i-1);
    }

    @Override
    public int size() {
        return backingList.size();
    }

}

come questo:

ReversedView.of(backingList) // is a fully-fledged generic (but read-only) list

Puoi anche fare questo:

static ArrayList<String> reverseReturn(ArrayList<String> alist)
{
   if(alist==null || alist.isEmpty())
   { 
       return null;
   }

   ArrayList<String> rlist = new ArrayList<>(alist);

   Collections.reverse(rlist);
   return rlist;
}

Puoi anche invertire la posizione quando richiedi un oggetto:

Object obj = list.get(list.size() - 1 - position);

Per un elenco di piccole dimensioni possiamo creare LinkedListe quindi utilizzare l'iteratore discendente come:

List<String> stringList = new ArrayList<>(Arrays.asList("One", "Two", "Three"));
stringList.stream().collect(Collectors.toCollection(LinkedList::new))
         .descendingIterator().
         forEachRemaining(System.out::println); // Three, Two, One
System.out.println(stringList); // One, Two, Three

Usa reverse(...)metodi di java.util.Collectionsclasse. Passa la tua lista come parametro e la tua lista verrà invertita.

Collections.reverse(list);