返回Java中的反转泛型列表类型

我正在做一些关于泛型编程的练习；有没有一种方法可以获取实现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
}
}

import java.util.ArrayList；
导入java.util.LinkedList；
导入java.util.List；
导入java.util.array；
公共类反向DEMO{
公共静态列表反向（列表）{
List reversed=新的ArrayList（）；
对于（int i=list.size（）-1；i>=0；i--）{
添加（list.get（i））；
}
反向返回；
}
公共静态void main（字符串[]args）{
LinkedList LinkedIn=新建LinkedList（）；
ArrayList arrayDouble=新的ArrayList（）；
对于（int k=0；k<10；k++）{
double doubleNum=10*Math.random（）；
int intNum=（int）（10*Math.random（））；
linkedInt.add（intNum）；
arrayDouble.add（doubleNum）；
}
//LinkedList演示
System.out.println（Arrays.toString（linkedInt.toArray（））；
System.out.println（Arrays.toString（reverse（linkedInt.toArray（））；
System.out.println（LinkedList的反向（linkedInt）实例）；//false
//ArrayList演示
System.out.println（Arrays.toString（arrayDouble.toArray（））；
System.out.println（Arrays.toString（reverse（arrayDouble.toArray（）））；
System.out.println（ArrayList的反向（arrayDouble）实例）；//true
}
}

---

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

Collections.reverse（）可能无效，但这只是因为您应该传入要反转的列表

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

List myList=。。。；
收藏。反面（myList）；

---

您现在有了一个相反的列表。

所有

java.util

的

list

实现都是可克隆的，因此您可以使用它，但遗憾的是，如果不借助反射，就不能使用它。在反射一章中，您还可以使用复制构造函数，这也是所有Java集合都使用的

不幸的是，目前还没有完全通用的非破坏性倒车方法

---

另一方面，破坏性反转太琐碎而不有趣。

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

originalList.getClass().newInstance()

---

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

Guava库有一个很好的、非破坏性的解决方案。看

它们定义了一组包装输入列表的

ReverseList

类。从这里开始，只需翻译所有的电话（尽管“just”可能有点轻描淡写）。

试试下面的内容

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

公共静态列表反向（列表）{
列表反转=空；
试一试{
反向=list.getClass（）.newInstance（）；
收款。反向（列表）；
颠倒。添加全部（列表）；
}捕获（实例化异常|非法访问异常e）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
};
反向返回；
}

这似乎有效：

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

import java.util.*；
公共类ReverseListDemo
{
公共静态void main（字符串[]args）
{
List original=Arrays.asList（“A”、“B”、“C”）；
列表冲销=冲销（原件）；
System.out.println（“原件：+原件”）；
系统输出打印项次（“冲销：+冲销”）；
}
公共静态列表反向（列表）
{
T[]对象=（T[]）list.toArray（）；
List copy=Arrays.asList（对象）；
收藏。反面（复印件）；
返回副本；
}
}
谢谢大家的回复。我编写了一个方法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<?>);
    }

}

import java.util.ArrayList；
导入java.util.LinkedList；
导入java.util.List；
导入java.util.ListIterator；
导入java.util.array；
//看http://stackoverflow.com/questions/16799066/return-reversed-generic-list-type-in-java.
公共类反向DEMO{
公共静态列表反转1（列表）{
List reversed=新的ArrayList（）；
对于（int i=list.size（）-1；i>-1；i--）{
添加（list.get（i））；
}
反向返回；
}
公共静态列表反转2（列表）{
int size=list.size（）；
ArrayList obArray=新的ArrayList（）；
obArray.addAll（列表）；
ListIterator iter=list.ListIterator（）；
对于（int i=0；i