Java 反转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());

ArrayList aList=new ArrayList（）；
//向ArrayList对象添加元素
添加（“1”）；
（a）添加（“2”）；
（a）添加（“3”）；
（a）添加（“4”）；
（a）添加（“5”）；
while（aList.listIterator（）.hasPrevious（））
Log.d（“reverse”，“aList.listIterator（）.previous（））；

示例（）：

---

这不是最简单的方法，但如果您喜欢递归，您可能会对以下方法感兴趣，以反转ArrayList：

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

公共ArrayList反向（ArrayList列表）{
如果（list.size（）>1）{
对象值=列表。删除（0）；
反向（列表）；
列表。添加（值）；
}
退货清单；
}

或非递归地：

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

公共ArrayList反向（ArrayList列表）{
对于（int i=0，j=list.size（）-1；i

可读性更强一点：）

公共静态ArrayList反向（ArrayList列表）{
int length=list.size（）；
ArrayList结果=新的ArrayList（长度）；
对于（int i=length-1；i>=0；i--）{
result.add（list.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反向（ArrayList列表）{
对于（int i=0；i

另一个递归解决方案

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

公共静态字符串反转（ArrayList列表）{
if（list.size（）==1）{
返回“”+列表。获取（0）；
}
否则{
返回“”+list.remove（list.size（）-1）+reverse（list）；
} 
}

如果我们使用的是Java8，那么我们可以利用流。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;
    }

publicstaticvoidmain（字符串[]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）；
}
私有静态数组列表getDummyList（）{
ArrayList dummyList=新的ArrayList（）；
//向ArrayList对象添加元素
添加（“A”）；
添加（“B”）；
添加（“C”）；
添加（“D”）；
返回dummyList；
}

---

上述方法不适用于LinkedList，因为它不是随机访问。我们还可以使用

instanceof

进行检查

这里的诀窍是定义“反向”。可以就地修改列表、按相反顺序创建副本或按相反顺序创建视图

直观地说，最简单的方法是收集。反过来说：

Collections.reverse(myList);

此方法修改就地列表。也就是说，

Collections.reverse

获取列表并覆盖其元素，不留下任何未反转的副本。这适用于某些用例，但不适用于其他用例；此外，它假定列表是可修改的。如果这是可以接受的，我们很好

---

如果没有，可以按相反顺序创建副本：

这更有效，但也更冗长

或者，我们可以重写上述内容，使用Java 8的

stream

API，有些人认为它比上述内容更简洁易懂：

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
}

静态列表反转（最终列表）{
final int last=list.size（）-1；
return IntStream.rangeClosed（0，last）//列表中所有有效索引的流
.map（i->（last-i））//顺序相反
.mapToObj（list:：get）//将每个索引映射到列表元素
.collect（Collectors.toList（））；//将它们打包到列表中
}

注意。这

Collectors.toList（）

对结果列表几乎没有保证。如果要确保结果作为ArrayList返回，请改用

Collectors.toCollection（ArrayList:：new）

---

第三个选项是按相反顺序创建视图。这是一个更复杂的解决方案，值得进一步阅读/它自己的问题。番石榴的方法是一个可行的起点

选择“最简单”的实现留给读者作为练习。

ArrayList myArray=new ArrayList（）；
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));
}

myArray.add（1）；
myArray.add（2）；
myArray.add（3）；
int reverseArrayCounter=myArray.size（）-1；
对于（int i=reversearlaycounter；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;
    }

}

公共类ListUtil{
公共静态void main（字符串[]args）{
ArrayList ArrayList=新的ArrayList（）；
arrayList.添加（“1”）；
arrayList.添加（“2”）；
arrayList.添加（“3”）；
arrayList.添加（“4”）；
arrayList.添加（“5”）；
System.out.println（“反向顺序：”+反向（arrayList））；
}
公共静态列表反向（列表arrayList）{
返回反向（arrayList，0，arrayList.size（）-1）；
}
公共静态列表反向（列表arrayList、int startIndex、int lastIndex）{
如果（startIndex，我们也可以使用Java8做同样的事情

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

公共静态列表反向列表（列表列表）{
List reverse=newarraylist（List.size（））；
list.stream（）
.collect（收集器.toCollection（LinkedList:：new））
.DegendingIterator（）
.foreach剩余（反向：：添加）；
反向返回；
}
简单的方法是在Java中有“集合”。您只需调用它并使用“re”
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;
}

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
}

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

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

}

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

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

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