java list翻转_java - 反转ArrayList的最简单方法是什么？

java - 反转ArrayList的最简单方法是什么？

反转此ArrayList的最简单方法是什么？

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

10个解决方案

698 votes

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

Shankar Agarwal answered 2019-02-02T07:53:26Z

18 votes

不是最简单的方法，但如果你是递归的粉丝，你可能会对以下方法感兴趣来反转ArrayList：

public ArrayList reverse(ArrayList list) {

if(list.size() > 1) {

Object value = list.remove(0);

reverse(list);

list.add(value);

}

return list;

}

或非递归：

public ArrayList reverse(ArrayList list) {

for(int i = 0, j = list.size() - 1; i < j; i++) {

list.add(i, list.remove(j));

}

return list;

}

todd answered 2019-02-02T07:53:54Z

9 votes

这里的诀窍是定义“反向”。 可以在适当的位置修改列表，以相反的顺序创建副本，或者以相反的顺序创建视图。

直观地说，最简单的方法是Collectors.toList()：

Collections.reverse(myList);

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

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

static List reverse(final List list) {

final List result = new ArrayList<>(list);

Collections.reverse(result);

return result;

}

这种方法有效，但需要对列表进行两次迭代。 复制构造函数(Collectors.toList())遍历列表，Collectors.toCollection(ArrayList::new)也是如此。如果我们如此倾向，我们可以重写此方法只迭代一次：

static List reverse(final List 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 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的Collectors.toList() API，有些人发现它比上面更简洁明了：

static List reverse(final List 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)。

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

选择“最简单”的实现仍然是读者的练习。

naomimyselfandi answered 2019-02-02T07:55:19Z

5 votes

解决方案，无需使用额外的ArrayList或add()和remove()方法的组合。 如果你必须撤销一个巨大的列表，两者都会产生负面影响。

public ArrayList reverse(ArrayList 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;

}

contrapost answered 2019-02-02T07:55:41Z

2 votes

ArrayList myArray = new ArrayList();

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

}

Tolunay Guney answered 2019-02-02T07:55:57Z

1 votes

以递归方式反转ArrayList而不创建用于添加元素的新列表：

public class ListUtil {

public static void main(String[] args) {

ArrayList arrayList = new ArrayList();

arrayList.add("1");

arrayList.add("2");

arrayList.add("3");

arrayList.add("4");

arrayList.add("5");

System.out.println("Reverse Order: " + reverse(arrayList));

}

public static List reverse(List arrayList) {

return reverse(arrayList,0,arrayList.size()-1);

}

public static List reverse(List arrayList,int startIndex,int lastIndex) {

if(startIndex

T t=arrayList.get(lastIndex);

arrayList.set(lastIndex,arrayList.get(startIndex));

arrayList.set(startIndex,t);

startIndex++;

lastIndex--;

reverse(arrayList,startIndex,lastIndex);

}

return arrayList;

}

}

Joby Wilson Mathews answered 2019-02-02T07:56:19Z

0 votes

更可读:)

public static ArrayList reverse(ArrayList list) {

int length = list.size();

ArrayList result = new ArrayList(length);

for (int i = length - 1; i >= 0; i--) {

result.add(list.get(i));

}

return result;

}

Yas answered 2019-02-02T07:56:41Z

0 votes

另一种递归解决方案

public static String reverse(ArrayList list) {

if (list.size() == 1) {

return " " +list.get(0);

}

else {

return " "+ list.remove(list.size() - 1) + reverse(list);

}

}

dt94 answered 2019-02-02T07:57:03Z

0 votes

为了防止我们使用Java 8，我们可以使用Stream。 ArrayList是随机访问列表，我们可以按相反顺序获取元素流，然后将其收集到新的instanceof中。

public static void main(String[] 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);

}

private static ArrayList 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进行检查。

i_am_zero answered 2019-02-02T07:57:32Z

0 votes

我们也可以使用java 8来做同样的事情。

public static List reverseList(List list) {

List reverse = new ArrayList<>(list.size());

list.stream()

.collect(Collectors.toCollection(LinkedList::new))

.descendingIterator()

.forEachRemaining(reverse::add);

return reverse;

}

vijayraj34 answered 2019-02-02T07:57:55Z