Який найпростіший спосіб повернути ArrayList?

Який найпростіший спосіб повернути цей 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;
}

Це більш ефективно, але також більш багатослівно.

Крім того, ми можемо переписати вище, щоб використовувати streamAPI 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)замість цього.

Третій варіант - створити подання у зворотному порядку . Це більш складне рішення і гідне подальшого читання / власне питання. Метод списків Гуави # зворотний - це життєздатна відправна точка.

Вибір "найпростішої" реалізації залишається читачем як вправа.

Рішення без використання додаткового ArrayList або комбінації методів add () та delete (). Обидва можуть мати негативний вплив, якщо вам доведеться скасувати величезний список.

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