Какой самый простой способ отменить этот ArrayList?
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());
Collections.reverse(aList);
Пример (Ссылка):
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);
Не самый простой способ, но если вы поклонник рекурсии, вас может заинтересовать следующий метод для изменения ArrayList:
public ArrayList<Object> reverse(ArrayList<Object> list) {
if(list.size() > 1) {
Object value = list.remove(0);
reverse(list);
list.add(value);
}
return list;
}
Или нерекурсивно:
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;
}
Хитрость здесь в том, чтобы определить "реверс". Можно изменить список на месте, создать копию в обратном порядке или создать представление в обратном порядке.
Самым простым способом, интуитивно понятным, является Collections.reverse:
Collections.reverse(myList);
Этот метод изменяет список на месте. Таким образом, Collections.reverse берет список и перезаписывает его элементы, не оставляя необратимой копии. Это подходит для некоторых случаев использования, но не для других; Более того, предполагается, что список можно изменить. Если это приемлемо, у нас все хорошо.
Если нет, можно создать копию в обратном порядке:
static <T> List<T> reverse(final List<T> list) {
final List<T> result = new ArrayList<>(list);
Collections.reverse(result);
return result;
}
Этот подход работает, но требует итерации по списку дважды. Конструктор копирования (new ArrayList<>(list)) выполняет итерации по списку, как и Collections.reverse. Мы можем переписать этот метод, чтобы повторить только один раз, если мы так склонны:
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;
}
Это более эффективно, но и более многословно.
В качестве альтернативы, мы можем переписать вышеупомянутое, чтобы использовать API stream Java 8, который некоторые люди находят более кратким и разборчивым, чем выше:
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
}
в северном направлении что Collectors.toList() дает очень мало гарантий относительно списка результатов. Если вы хотите, чтобы результат возвращался как ArrayList, используйте взамен Collectors.toCollection(ArrayList::new).
Третий вариант - создать вид в обратном порядке. Это более сложное решение и заслуживает дальнейшего чтения/своего вопроса. Guava Lists # обратный метод является жизнеспособной отправной точкой.
Выбор "простейшей" реализации оставлен читателю в качестве упражнения.
Решение без использования дополнительного ArrayList или комбинации методов add() и remove(). Оба могут оказать негативное влияние, если вам придется перевернуть огромный список.
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;
}
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));
}
Реверсивный ArrayList рекурсивным способом без создания нового списка для добавления элементов:
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;
}
}
На всякий случай мы используем Java 8, тогда мы можем использовать Stream. ArrayList - это список случайного доступа, и мы можем получить поток элементов в обратном порядке, а затем собрать его в новый 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;
}
Этот подход не подходит для LinkedList, поскольку это не случайный доступ. Мы также можем использовать instanceof для проверки.
Мы также можем сделать то же самое, используя 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;
}
Немного читаем:)
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;
}
Другое рекурсивное решение
public static String reverse(ArrayList<Float> list) {
if (list.size() == 1) {
return " " +list.get(0);
}
else {
return " "+ list.remove(list.size() - 1) + reverse(list);
}
}