Quel est le moyen le plus simple d’inverser une liste de tableaux?

Quelle est la manière la plus simple d’inverser cette liste de tableaux?

ArrayList aList = new ArrayList(); //Add elements to ArrayList object aList.add("1"); aList.add("2"); aList.add("3"); aList.add("4"); aList.add("5"); while (aList.listIterator().hasPrevious()) Log.d("reverse", "" + aList.listIterator().previous()); 

 Collections.reverse(aList); 

Exemple ( référence ):

 ArrayList aList = new ArrayList(); //Add elements to ArrayList object aList.add("1"); aList.add("2"); aList.add("3"); aList.add("4"); aList.add("5"); Collections.reverse(aList); System.out.println("After Reverse Order, ArrayList Contains : " + aList); 

Pas le moyen le plus simple, mais si vous êtes un fan de récursivité, vous pourriez être intéressé par la méthode suivante pour inverser une ArrayList:

 public ArrayList reverse(ArrayList list) { if(list.size() > 1) { Object value = list.remove(0); reverse(list); list.add(value); } return list; } 

Ou non récursivement:

 public ArrayList reverse(ArrayList list) { for(int i = 0, j = list.size() - 1; i < j; i++) { list.add(i, list.remove(j)); } return list; } 

L’astuce ici est de définir “reverse”. On peut modifier la liste en place, créer une copie dans l’ordre inverse ou créer une vue dans l’ordre inverse.

La manière la plus simple, intuitivement parlant , est que Collections.reverse :

 Collections.reverse(myList); 

Cette méthode modifie la liste en place . Autrement dit, Collections.reverse prend la liste et écrase ses éléments, ne laissant aucune copie non retournée. Ceci est approprié pour certains cas d’utilisation, mais pas pour d’autres; de plus, cela suppose que la liste est modifiable. Si cela est acceptable, nous sums bons.


Sinon, on pourrait créer une copie dans l’ordre inverse :

 static  List reverse(final List list) { final List result = new ArrayList<>(list); Collections.reverse(result); return result; } 

Cette approche fonctionne, mais nécessite une itération sur la liste deux fois. Le constructeur de copie ( new ArrayList<>(list) ) effectue une itération sur la liste, tout comme Collections.reverse . Nous pouvons réécrire cette méthode pour itérer une seule fois, si nous sums tellement enclins à:

 static  List reverse(final List list) { final int size = list.size(); final int last = size - 1; // create a new list, with exactly enough initial capacity to hold the (reversed) list final List result = new ArrayList<>(size); // iterate through the list in reverse order and append to the result for (int i = last; i >= 0; --i) { final T element = list.get(i); result.add(element); } // result now holds a reversed copy of the original list return result; } 

Ceci est plus efficace, mais aussi plus verbeux.

Alternativement, nous pouvons réécrire ce qui précède pour utiliser l’API de stream Java 8, que certains trouvent plus concise et lisible que ci-dessus:

 static  List reverse(final List list) { final int last = list.size() - 1; return IntStream.rangeClosed(0, last) // a stream of all valid indexes into the list .map(i -> (last - i)) // reverse order .mapToObj(list::get) // map each index to a list element .collect(Collectors.toList()); // wrap them up in a list } 

nb. que Collectors.toList() apporte très peu de garanties sur la liste de résultats. Si vous voulez vous assurer que le résultat revient en tant que ArrayList, utilisez plutôt Collectors.toCollection(ArrayList::new) .


La troisième option consiste à créer une vue dans l’ordre inverse . Il s’agit d’une solution plus complexe et qui mérite d’être lue plus avant / sa propre question. La méthode inverse des listes de goyaves est un sharepoint départ viable.

Choisir une implémentation “la plus simple” rest un exercice pour le lecteur.

Solution sans utiliser ArrayList supplémentaire ou une combinaison des méthodes add () et remove (). Les deux peuvent avoir un impact négatif si vous devez inverser une liste énorme.

  public ArrayList reverse(ArrayList list) { for (int i = 0; i < list.size() / 2; i++) { Object temp = list.get(i); list.set(i, list.get(list.size() - i - 1)); list.set(list.size() - i - 1, temp); } return list; } 
 ArrayList myArray = new ArrayList(); myArray.add(1); myArray.add(2); myArray.add(3); int reverseArrayCounter = myArray.size() - 1; for (int i = reverseArrayCounter; i >= 0; i--) { System.out.println(myArray.get(i)); } 

Inverser une ArrayList de manière récursive et sans créer de nouvelle liste pour append des éléments:

  public class ListUtil { public static void main(Ssortingng[] args) { ArrayList arrayList = new ArrayList(); arrayList.add("1"); arrayList.add("2"); arrayList.add("3"); arrayList.add("4"); arrayList.add("5"); System.out.println("Reverse Order: " + reverse(arrayList)); } public static  List reverse(List arrayList) { return reverse(arrayList,0,arrayList.size()-1); } public static  List reverse(List arrayList,int startIndex,int lastIndex) { if(startIndex 

Un peu plus lisible 🙂

 public static  ArrayList reverse(ArrayList list) { int length = list.size(); ArrayList result = new ArrayList(length); for (int i = length - 1; i >= 0; i--) { result.add(list.get(i)); } return result; } 

Une autre solution récursive

  public static Ssortingng reverse(ArrayList list) { if (list.size() == 1) { return " " +list.get(0); } else { return " "+ list.remove(list.size() - 1) + reverse(list); } } 

Au cas où nous utiliserions Java 8 , nous pourrions utiliser Stream. ArrayList est une liste d’access aléatoire et nous pouvons obtenir un stream d’éléments dans l’ordre inverse, puis le collecter dans une nouvelle ArrayList .

 public static void main(Ssortingng[] args) { ArrayList someDummyList = getDummyList(); System.out.println(someDummyList); int size = someDummyList.size() - 1; ArrayList someDummyListRev = IntStream.rangeClosed(0,size).mapToObj(i->someDummyList.get(size-i)).collect(Collectors.toCollection(ArrayList::new)); System.out.println(someDummyListRev); } private static ArrayList getDummyList() { ArrayList dummyList = new ArrayList(); //Add elements to ArrayList object dummyList.add("A"); dummyList.add("B"); dummyList.add("C"); dummyList.add("D"); return dummyList; } 

L’approche ci-dessus ne convient pas pour LinkedList car ce n’est pas un access aléatoire. Nous pouvons également utiliser instanceof pour vérifier également.

Nous pouvons également faire la même chose en utilisant java 8.

 public static List reverseList(List list) { List reverse = new ArrayList<>(list.size()); list.stream() .collect(Collectors.toCollection(LinkedList::new)) .descendingIterator() .forEachRemaining(reverse::add); return reverse; }