Question

我正在做一些关于泛型编程的练习;有没有办法获取一个实现List的类并返回该相同类的反转版本？看起来这应该是可行的，因为至少采用面值的术语，“泛型编程”写得很大。

也许通过执行就地反转？我也考虑过Collections.reverse（），但它是一个void方法。

这是我的尝试和演示：

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Arrays;

public class ReverseDemo {

public static <T> List<T> reverse(List<T> list) {
    List<T> reversed = new ArrayList<T>();

    for (int i = list.size() - 1; i >= 0; i--) {
        reversed.add(list.get(i));
      }

    return reversed;
}

public static void main(String[] args) {
    LinkedList<Integer> linkedInt = new LinkedList<Integer>();
    ArrayList<Double> arrayDouble = new ArrayList<Double>();

    for (int k = 0; k < 10; k++) {
        double doubleNum = 10*Math.random();
        int intNum = (int) (10*Math.random());
        linkedInt.add(intNum);
        arrayDouble.add(doubleNum);
    }

    // LinkedList<Integer> demo
    System.out.println(Arrays.toString(linkedInt.toArray()));
    System.out.println(Arrays.toString(reverse(linkedInt).toArray()));
    System.out.println(reverse(linkedInt) instanceof LinkedList<?>);  // false

    // ArrayList<Double> demo
System.out.println(Arrays.toString(arrayDouble.toArray()));        
System.out.println(Arrays.toString(reverse(arrayDouble).toArray()));          
System.out.println(reverse(arrayDouble) instanceof ArrayList<?>);  // true
}
}

顺便说一句，这是我在这里的第一篇文章，是否有人知道直接从Eclipse发布代码同时保留其间距和缩进的最佳方法？我已经使用了这里指定的四空格法，但它有点不一致。

Answer 1

Guava库有一个很好的，非破坏性的解决方案。请参阅Lists.reverse(List)。

它们定义了一组包含输入ReverseList的{{1}}类。从那里开始，只需要翻译所有的电话（虽然“只是”可能会略微低估一些事情）。

Answer 2

如果您想保留原始列表，可以尝试使用：

originalList.getClass().newInstance()

这不是100％正确的解决方案，因为如果原始类没有默认构造函数，它可能会抛出。但是，大多数集合都具有创建空实例的默认构造函数。

Answer 3

尝试以下

public static <T> List<T> reverse(List<T> list) {

    List<T> reversed=null;
    try {
        reversed = list.getClass().newInstance();
        Collections.reverse(list);
        reversed.addAll(list);

    } catch (InstantiationException | IllegalAccessException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    };

     return reversed;
}

Answer 4

Collections.reverse()可能无效，但这只是因为您应该在列表中传递要反转。

List<T> myList = ...;
Collections.reverse(myList);

你现在有一个反向清单。

Answer 5

java.util的所有List实现都是可复制的，因此您可以使用它，但遗憾的是不能不使用反射。在反思章节中，您也可以使用复制构造函数，该构造函数也适用于所有Java集合。

遗憾的是，没有完全一般的非破坏性逆转方法。

另一方面，破坏性逆转太微不足道了。

Answer 6

这似乎有效：

import java.util.*;

public class ReverseListDemo
{
  public static void main(String[] args)
  {
    List<String> original = Arrays.asList("A", "B", "C");
    List<String> reversal = reverse(original);

    System.out.println("Original: " + original);
    System.out.println("Reversal: " + reversal);
  }

  public static <T> List<T> reverse(List<T> list)
  {
    T[] objects = (T[]) list.toArray();
    List<T> copy = Arrays.asList(objects);
    Collections.reverse(copy);
    return copy;
  }
}

Answer 7

感谢大家的回复。我写了一个方法reverse2，它至少用于实现类ArrayList和LinkedList。不确定它的效率如何。

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.Arrays;

// See http://stackoverflow.com/questions/16799066/return-reversed-generic-list-type-in-java.
public class ReverseDemo {

    public static <T> List<T> reverse1(List<T> list) {
        List<T> reversed = new ArrayList<T>();

        for (int i = list.size() - 1; i > -1; i--) {
            reversed.add(list.get(i));
          }

        return reversed;
    }

    public static <T> List<T> reverse2(List<T> list) {
        int size = list.size();

        ArrayList<T> obArray = new ArrayList<T>();
        obArray.addAll(list);

        ListIterator<T> iter = list.listIterator();  
        for (int i = 0; i < size; i++) {
            iter.next();
            iter.set(obArray.get(size - 1 - i));
        }       

        return list;
    }

    public static void main(String[] args) {
        LinkedList<Integer> linkedInt = new LinkedList<Integer>();
        ArrayList<Double> arrayDouble = new ArrayList<Double>();

        for (int k = 0; k < 10; k++) {
            double doubleNum = 10*Math.random();
            int intNum = (int) (10*Math.random());
            linkedInt.add(intNum);
            arrayDouble.add(doubleNum);
        }

        TextIO.putln("Testing reverse1.");

        // LinkedList<Integer> demo
        System.out.println(Arrays.toString(linkedInt.toArray()));
        System.out.println(Arrays.toString(reverse1(linkedInt).toArray()));
        TextIO.putln("LinkedList structure preserved?");
        System.out.println(reverse1(linkedInt) instanceof LinkedList<?>);

        // ArrayList<Double> demo
        System.out.println(Arrays.toString(arrayDouble.toArray()));
        System.out.println(Arrays.toString(reverse1(arrayDouble).toArray()));
        TextIO.putln("ArrayList structure preserved?");
        System.out.println(reverse1(arrayDouble) instanceof ArrayList<?>);

        TextIO.putln("\nTesting reverse2.");

        // LinkedList<Integer> demo
        System.out.println(Arrays.toString(linkedInt.toArray()));
        System.out.println(Arrays.toString(reverse2(linkedInt).toArray()));
        TextIO.putln("LinkedList structure preserved?");
        System.out.println(reverse2(linkedInt) instanceof LinkedList<?>);

        // ArrayList<Double> demo
        System.out.println(Arrays.toString(arrayDouble.toArray()));
        System.out.println(Arrays.toString(reverse2(arrayDouble).toArray()));
        TextIO.putln("ArrayList structure preserved?");
        System.out.println(reverse2(arrayDouble) instanceof ArrayList<?>);
    }

}

控制台输出：

测试reverse1。 [8,0,1,9,3,4,3,7,6,3] [3,6,7,3,4,3,9,1,0,8] LinkedList结构保留了吗？假 [8.301783107294664,5.434068303620735,9.095396759542615,0.41823972682620836,9.56659902304762,3.2560723280079085,4.037362000077436,9.731919590391389,0.5243645318825874,5.9432185528462975] [5.9432185528462975,0.5243645318825874,9.731919590391389,4.037362000077436,3.2560723280079085,9.56659902304762,0.41823972682620836,9.095396759542615,5.434068303620735,8.301783107294664] ArrayList结构保留了吗？真

测试reverse2。 [8,0,1,9,3,4,3,7,6,3] [3,6,7,3,4,3,9,1,0,8] LinkedList结构保留了吗？真正 [8.301783107294664,5.434068303620735,9.095396759542615,0.41823972682620836,9.56659902304762,3.2560723280079085,4.037362000077436,9.731919590391389,0.5243645318825874,5.9432185528462975] [5.9432185528462975,0.5243645318825874,9.731919590391389,4.037362000077436,3.2560723280079085,9.56659902304762,0.41823972682620836,9.095396759542615,5.434068303620735,8.301783107294664] ArrayList结构保留了吗？真

在Java中返回反向通用列表类型

7 个答案: