反转数组列表的最简单方法是什么?

反转这个数组列表最简单的方法是什么?

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());
383109 次浏览
小开
最佳答案 
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);
小开

这不是最简单的方法，但如果你喜欢递归，你可能会对下面的方法感兴趣:

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

可读性更强一点:)

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

不使用额外的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;
}
小开

另一个递归解

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

以防我们使用Java 8，那么我们可以使用Stream。数组列表是一个随机访问列表，我们可以获得一个倒序的元素流，然后将它收集到一个新的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来检查。

小开

这里的诀窍在于如何定义“反向”。可以就地修改列表，以相反的顺序创建副本，或以相反的顺序创建视图。

最简单的方法直观地说是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的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
}

nb。Collectors.toList()对结果列表的保证很少。如果你想确保返回的结果是一个数组列表，使用Collectors.toCollection(ArrayList::new)代替。

第三个选项是以相反的顺序创建一个视图。这是一个更复杂的解决方案，值得进一步阅读/它本身的问题。Guava的表#反方法是一个可行的起点。

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

小开 
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做同样的事情。

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中。你只需要调用它并使用“__abc1”;方法。

使用示例:

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

编码快乐!

参考


提交答案