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 (de la même manière que List#sublist fournit une vue de sous-liste sur une liste). Est-il une fonction qui fournit cette fonctionnalité?
Je ne veux pas faire de copie de la liste ni modifier la liste.
, Il suffirait, si je pouvais obtenir au moins un itérateur inverse, sur une liste dans ce cas.
Aussi, je sais comment mettre en œuvre cela moi-même. Je demande juste si Java fournit déjà quelque chose comme ce.
Implémentation de 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 implémentations List ont descendingIterator() ce dont j'ai besoin. Bien qu'il n'y ait pas d'implémentation générale pour List. Ce qui est un peu étrange car l'implémentation que j'ai vue dans LinkedList est assez générale pour fonctionner avec n'importe quel List.
12 answers
Goyave donne ceci: Listes.reverse (Liste)
List<String> letters = ImmutableList.of("a", "b", "c");
List<String> reverseView = Lists.reverse(letters);
System.out.println(reverseView); // [c, b, a]
Contrairement à Collections.reverse, il s'agit purement d'une vue ... il ne modifie pas l'ordre des éléments dans la liste d'origine. De plus, avec une liste d'origine modifiable, les modifications apportées à la fois à la liste d'origine et à la vue sont reflétées dans l'autre.
Utilisez le .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 des Collections.
Donc,
Collections.reverse(list.clone());
Si vous utilisez un List et n'ont 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.inverse(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.Deque a descendingIterator() - si votre List est un Deque, vous pouvez l'utiliser.
Je sais que c'est un vieux post mais aujourd'hui, je cherchais quelque chose comme cela. À la fin, 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 listes longues, 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 n'ont 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 ceci:
ReversedView.of(backingList) // is a fully-fledged generic (but read-only) list
Vous pouvez également faire ceci:
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 LinkedList puis 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); // Four, Three, Two, One
System.out.println(stringList); // One, Two, Three, Four
Utilisez les méthodes reverse(...) de la classe java.util.Collections. Passez votre liste en paramètre et votre liste sera inversée.
Collections.reverse(list);