Question

我正在尝试反转使用java中内置的Linked List类创建的链接列表。以下实现是否可行？而且，在实际的软件工程环境中，开发人员会使用模板类还是自己的？谢谢！

LinkedList<String> example1 = new LinkedList<>();
example1.add("Ben");
example1.add("Sam");
example1.add("Kyle");
Object objectArr[];
String stringArr[];
objectArr =  example1.toArray();
stringArr = Arrays.copyOf(objectArr, objectArr.length, String[].class);
ArrayList<String> newList = new ArrayList<String>(Arrays.asList(stringArr));
Collections.reverse(newList);
example1.clear();
example1.addAll(newList);

Answer 1

以下实施是否可行？

实际上并不是这样，因为为了反转LinkedList对象所需要做的就是直接调用Collections.reverse(List<?> list)静态方法，而无需创建两个arrays和一个ArrayList然后重建LinkedList。

在实际的软件工程环境中，开发人员会使用模板类还是他们自己的？

这取决于您想要实现的目标，一种巧妙的方式是使用Java提供给您并使用reverse()方法。但如果表现是问题

来自文档（我的重点）：

public static void reverse(List<?> list) 反转指定列表中元素的顺序。此方法以线性时间运行。

这意味着：List增长得越多，时间就越长。因此，例如，包含10个元素的列表将花费两次具有5个元素的列表所需的时间，依此类推。

这里的问题是：我们能否改善表现。我不确定我是否可以正确回答这个问题，但我创建了一个简单的测试来比较3种逆转方式（当然其他用户可能有其他改进的想法如何逆转），这里结果如下：

import java.util.Collections;
import java.util.LinkedList;

public class LinkedListReversePerformance {

    static LinkedList<String> list1 = new LinkedList<>();
    static LinkedList<String> list2 = new LinkedList<>();
    static LinkedList<String> list3 = new LinkedList<>();
    static long startTime, endTime;

    public static void main(String[] args){

        // populate the lists, each with 1 hundred thousand item!
        for(int i =0 ;i<100000; i++){
            list1.add(String.valueOf(i));
            list2.add(String.valueOf(i));
            list3.add(String.valueOf(i));
        }

        // create temporary list
        LinkedList<String> temp = new LinkedList<>();

        startTime = System.currentTimeMillis();
        // run for loop to add the items from list1 to temp in reverse order
        for(int i=9999; i>=0; i--){
            temp.add(list1.get(i));
        }
        // clear list1 then add temp
        list1.clear();
        list1.addAll(temp);
        endTime = System.currentTimeMillis();

        System.out.println("Using For Loop and clearing old list: " + (endTime-startTime) + " Millisecond");


        // re-initialize temp and populate it again in reverse order
        temp = new LinkedList<>();

        startTime = System.currentTimeMillis();
        for(int i=9999; i>=0; i--){
            temp.add(list2.get(i));
        }

        // re-initialize list2 and add temp using the constructor option
        list2 = new LinkedList<>(temp); 
        endTime = System.currentTimeMillis();
        System.out.println("Using For Loop and reconstruct the old list: " + (endTime-startTime) + " Millisecond");

        startTime = System.currentTimeMillis();
        // use the reverse static method provided by Java Collections Class
        Collections.reverse(list3);
        endTime = System.currentTimeMillis();
        System.out.println("Using Collection.reverse(): " + (endTime-startTime) + " Millisecond");

    }
}

<强>结果

Using For Loop and clearing old list: 875 Millisecond
Using For Loop and reconstruct the old list: 859 Millisecond
Using Collection.reverse(): 31 Millisecond

如您所见，Collection.reverse()仍然是其中最快的。 因此，我相信Java提供了最好的方法来反转或排序性能和内存。 但我仍然愿意接受纠正。

反转链接列表模板类

1 个答案: