Wat is de eenvoudigste manier om deze ArrayList om te draaien?
ArrayList<Integer> 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());
Antwoord 1, autoriteit 100%
Collections.reverse(aList);
Voorbeeld (Referentie):
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);
Antwoord 2, autoriteit 2%
Niet de eenvoudigste manier, maar als je een fan bent van recursie, ben je misschien geïnteresseerd in de volgende methode om een ArrayList om te keren:
public ArrayList<Object> reverse(ArrayList<Object> list) {
if(list.size() > 1) {
Object value = list.remove(0);
reverse(list);
list.add(value);
}
return list;
}
Of niet-recursief:
public ArrayList<Object> reverse(ArrayList<Object> list) {
for(int i = 0, j = list.size() - 1; i < j; i++) {
list.add(i, list.remove(j));
}
return list;
}
Antwoord 3, autoriteit 2%
De truc hier is om “omgekeerd” te definiëren. Men kan de lijst op zijn plaats wijzigen, een kopie in omgekeerde volgorde maken of een weergave in omgekeerde volgorde maken.
De eenvoudigste manier, intuïtief gesproken, is Collections.reverse:
Collections.reverse(myList);
Deze methode wijzigt de lijst op zijn plaats. Dat wil zeggen, Collections.reverseneemt de lijst en overschrijftde elementen ervan, zodat er geen niet-omgekeerde kopie achterblijft. Dit is geschikt voor sommige gebruikssituaties, maar niet voor andere; bovendien gaat het ervan uit dat de lijst kan worden gewijzigd. Als dit acceptabel is, zitten we goed.
Zo niet, dan zou men een kopie in omgekeerde volgorde kunnen maken:
static <T> List<T> reverse(final List<T> list) {
final List<T> result = new ArrayList<>(list);
Collections.reverse(result);
return result;
}
Deze aanpak werkt, maar vereist dat de lijst twee keer wordt herhaald. De kopieerconstructor (new ArrayList<>(list)) herhaalt de lijst, net als Collections.reverse. We kunnen deze methode herschrijven om slechts één keer te herhalen, als we daartoe geneigd zijn:
static <T> List<T> reverse(final List<T> 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<T> 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;
}
Dit is efficiënter, maar ook uitgebreider.
Als alternatief kunnen we het bovenstaande herschrijven om de streamAPI van Java 8 te gebruiken, die sommige mensenbeknopter en leesbaarder vinden dan het bovenstaande:
static <T> List<T> reverse(final List<T> 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. dat Collectors.toList()zeer weinig garanties geeft over de resultatenlijst. Als u er zeker van wilt zijn dat het resultaat terugkomt als een ArrayList, gebruikt u in plaats daarvan Collectors.toCollection(ArrayList::new).
De derde optie is om een weergave in omgekeerde volgorde te maken. Dit is een meer gecompliceerde oplossing en het waard om verder te lezen / zijn eigen vraag. Lists#reversemethode is een bruikbaar startpunt.
Het kiezen van een “eenvoudigste” implementatie wordt overgelaten als een oefening voor de lezer.
Antwoord 4
ArrayList<Integer> myArray = new ArrayList<Integer>();
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));
}
Antwoord 5
Oplossing zonder gebruik te maken van extra ArrayList of combinatie van add() en remove() methoden. Beide kunnen een negatieve impact hebben als je een enorme lijst moet terugdraaien.
public ArrayList<Object> reverse(ArrayList<Object> 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;
}
Antwoord 6
Een ArrayList recursief omkeren en zonder een nieuwe lijst te maken voor het toevoegen van elementen :
public class ListUtil {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList<String>();
arrayList.add("1");
arrayList.add("2");
arrayList.add("3");
arrayList.add("4");
arrayList.add("5");
System.out.println("Reverse Order: " + reverse(arrayList));
}
public static <T> List<T> reverse(List<T> arrayList) {
return reverse(arrayList,0,arrayList.size()-1);
}
public static <T> List<T> reverse(List<T> arrayList,int startIndex,int lastIndex) {
if(startIndex<lastIndex) {
T t=arrayList.get(lastIndex);
arrayList.set(lastIndex,arrayList.get(startIndex));
arrayList.set(startIndex,t);
startIndex++;
lastIndex--;
reverse(arrayList,startIndex,lastIndex);
}
return arrayList;
}
}
Antwoord 7
We kunnen hetzelfde ook doen met java 8.
public static<T> List<T> reverseList(List<T> list) {
List<T> reverse = new ArrayList<>(list.size());
list.stream()
.collect(Collectors.toCollection(LinkedList::new))
.descendingIterator()
.forEachRemaining(reverse::add);
return reverse;
}
Antwoord 8
Voor het geval we Java 8gebruiken, dan kunnen we Stream gebruiken. De ArrayList is een lijst met willekeurige toegang en we kunnen een stroom van elementen in omgekeerde volgorde krijgen en deze vervolgens verzamelen in een nieuwe ArrayList.
public static void main(String[] args) {
ArrayList<String> someDummyList = getDummyList();
System.out.println(someDummyList);
int size = someDummyList.size() - 1;
ArrayList<String> someDummyListRev = IntStream.rangeClosed(0,size).mapToObj(i->someDummyList.get(size-i)).collect(Collectors.toCollection(ArrayList::new));
System.out.println(someDummyListRev);
}
private static ArrayList<String> getDummyList() {
ArrayList dummyList = new ArrayList();
//Add elements to ArrayList object
dummyList.add("A");
dummyList.add("B");
dummyList.add("C");
dummyList.add("D");
return dummyList;
}
De bovenstaande aanpak is niet geschikt voor LinkedList, omdat dat geen willekeurige toegang is. We kunnen ook gebruik maken van instanceofom ook te controleren.
Antwoord 9
Kotlin-gebruikers
val reverse: List<Int> = list.reversed();
Veel plezier met coderen!
Antwoord 10
Iets leesbaarder 🙂
public static <T> ArrayList<T> reverse(ArrayList<T> list) {
int length = list.size();
ArrayList<T> result = new ArrayList<T>(length);
for (int i = length - 1; i >= 0; i--) {
result.add(list.get(i));
}
return result;
}
Antwoord 11
Nog een recursieve oplossing
public static String reverse(ArrayList<Float> list) {
if (list.size() == 1) {
return " " +list.get(0);
}
else {
return " "+ list.remove(list.size() - 1) + reverse(list);
}
}
Antwoord 12
Een eenvoudige manier is dat u “Collecties” in Java heeft. Je hoeft het alleen maar aan te roepen en de “reverse()” methode ervan te gebruiken.
Voorbeeld van gebruik:
ArrayList<Integer> yourArrayList = new ArrayList<>();
yourArrayList.add(1);
yourArrayList.add(2);
yourArrayList.add(3);
//yourArrayList is: 1,2,3
Collections.reverse(yourArrayList);
// Now, yourArrayList is: 3,2,1