Array List를 되돌리는 가장 간단한 방법은 무엇입니까?

Array List를 되돌리는 가장 간단한 방법은 무엇입니까?

이 Array List를 되돌리는 가장 간단한 방법은 무엇입니까?

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

가장 간단한 방법은 아니지만 재귀 팬이라면 Array List를 되돌리는 다음 방법을 사용할 수 있습니다.

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

이것은 더 효율적이면서도 더 장황하다.

또는 Java 8을 사용하도록 위의 내용을 다시 쓸 수 있습니다.streamAPI는 위에서 설명한 것보다 더 간결하고 읽기 쉽다고 생각하는 사람도 있습니다.

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. 그거Collectors.toList()결과 리스트에 대한 보장은 거의 없습니다.결과를 ArrayList로 되돌리려면Collectors.toCollection(ArrayList::new)대신.

---

세 번째 옵션은 뷰를 역순으로 작성하는 것입니다.이것은 보다 복잡한 해결책이며, 더 자세히 읽을 가치가 있습니다.Guava의 Lists#reverse 메서드는 실행 가능한 시작점입니다.

「가장 심플한」의 실장을 선택하는 것은, 독자의 연습으로서 남습니다.

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 또는 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를 되돌리는 방법:

   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을 사용하여 동일한 작업을 수행할 수도 있습니다.

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

간단한 방법은 Java에서 "Collections"를 사용하는 것입니다.호출하여 "reverse()" 메서드를 사용하면 됩니다.

사용 예:

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

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

위의 접근방식은 랜덤액세스가 아니기 때문에 Linked List에는 적합하지 않습니다. '아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 이런 것도 쓸 수 있어요.instanceof을 사용하다

Kotlin 사용자

val reverse: List<Int> = list.reversed();

해피 코딩!

언급

조금 더 읽기 쉽게 :)

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

언급URL : https://stackoverflow.com/questions/10766492/what-is-the-simplest-way-to-reverse-an-arraylist