Comment obtenir une vue de liste inversée sur une liste en Java?

Je veux avoir une vue de liste inversée sur une liste (d'une manière similaire à celle qui List#sublistfournit une vue de sous-liste sur une liste). Y a-t-il une fonction qui fournit cette fonctionnalité?

Je ne veux pas faire de copie de la liste ni modifier la liste.

Ce serait suffisant si je pouvais obtenir au moins un itérateur inversé sur une liste dans ce cas.

De plus, je sais comment l'implémenter moi-même. Je demande simplement si Java fournit déjà quelque chose comme ça.

Mise en œuvre de la démonstration:

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

Je viens de découvrir que certaines Listimplémentations ont descendingIterator()ce dont j'ai besoin. Bien qu'il n'y ait pas une telle mise en œuvre générale pour List. Ce qui est LinkedListassez étrange car l'implémentation que j'ai vue dans est assez générale pour fonctionner avec n'importe laquelle List.

La goyave fournit ceci: Lists.reverse (List)

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

Contrairement à Collections.reverse, c'est purement une vue ... cela ne modifie pas l'ordre des éléments dans la liste d'origine. En outre, avec une liste d'origine modifiable, les modifications apportées à la fois à la liste d'origine et à la vue sont répercutées dans l'autre.

Utilisez la méthode .clone () sur votre liste. Il renverra une copie superficielle, ce qui signifie qu'il contiendra des pointeurs vers les mêmes objets, vous n'aurez donc pas à copier la liste. Ensuite, utilisez simplement Collections.

Ergo,

Collections.reverse(list.clone());

Si vous utilisez un Listet que vous n'y avez pas accès, clone()vous pouvez utiliser subList():

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

Si j'ai bien compris, c'est une ligne de code. Cela a fonctionné pour moi.

 Collections.reverse(yourList);

Ce n'est pas exactement élégant, mais si vous utilisez List.listIterator (int index), vous pouvez obtenir un ListIterator bidirectionnel à la fin de la liste:

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

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

Collections.reverse (nums) ... Il inverse en fait l'ordre des éléments. Le code ci-dessous devrait être très apprécié -

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

Sortie: 15,94,83,42,61

java.util.Dequea descendingIterator()- si votre Listest un Deque, vous pouvez l'utiliser.

Je sais que c'est un vieux post mais aujourd'hui je cherchais quelque chose comme ça. Finalement, j'ai écrit le code moi-même:

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 recommandé pour les longues listes, ce n'est pas du tout optimisé. C'est une sorte de solution facile pour les scénarios contrôlés (les listes que je gère ne contiennent pas plus de 100 éléments).

J'espère que ça aide quelqu'un.

J'utilise ceci:

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

}

comme ça:

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

Vous pouvez également le faire:

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

Vous pouvez également inverser la position lorsque vous demandez un objet:

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

Pour une liste de petite taille, nous pouvons créer LinkedListet ensuite utiliser l'itérateur descendant comme:

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

Utilisez des reverse(...)méthodes de java.util.Collectionsclasse. Passez votre liste en paramètre et votre liste sera inversée.

Collections.reverse(list);