Java 使用stream（）和sorted（）更快，还是使用Collections方法反转列表顺序更快

我试图找出哪一个更快：

Collections.reverse(bottlesList);




bottlesList= bottlesList.stream().sorted(Collections.reverseOrder()).collect(Collectors.toList());

---

Collections.reverse

是这里唯一一个基于索引反转元素的选项，关于时间复杂度，它是线性操作

排序（Collections.reverseOrder（））

将基于比较器进行排序，因此它将按值而不是索引进行排序

简单比较：

    List<Integer> list1 = Arrays.asList(4,3,5,7,1);
    List<Integer> list2 = Arrays.asList(4,3,5,7,1);

    Collections.reverse(list1);
    System.out.println(list1);
    // Output: [1, 7, 5, 3, 4]

    List<Integer> list3 = list2.stream().sorted(Collections.reverseOrder()).collect(Collectors.toList());;
    System.out.println(list3);
    // Output: [7, 5, 4, 3, 1]

List list1=Arrays.asList（4,3,5,7,1）；
list2=Arrays.asList（4,3,5,7,1）；
收款。反向（清单1）；
System.out.println（列表1）；
//输出：[1,7,5,3,4]
List list3=list2.stream（）.sorted（Collections.reverseOrder（））.collect（Collectors.toList（））；；
System.out.println（列表3）；
//输出：[7,5,4,3,1]

集合。反转是此处唯一一个基于索引反转元素的选项，就时间复杂度而言，它是线性操作

排序（Collections.reverseOrder（））
将基于比较器进行排序，因此它将按值而不是索引进行排序

简单比较：

    List<Integer> list1 = Arrays.asList(4,3,5,7,1);
    List<Integer> list2 = Arrays.asList(4,3,5,7,1);

    Collections.reverse(list1);
    System.out.println(list1);
    // Output: [1, 7, 5, 3, 4]

    List<Integer> list3 = list2.stream().sorted(Collections.reverseOrder()).collect(Collectors.toList());;
    System.out.println(list3);
    // Output: [7, 5, 4, 3, 1]

List list1=Arrays.asList（4,3,5,7,1）；
list2=Arrays.asList（4,3,5,7,1）；
收款。反向（清单1）；
System.out.println（列表1）；
//输出：[1,7,5,3,4]
List list3=list2.stream（）.sorted（Collections.reverseOrder（））.collect（Collectors.toList（））；；
System.out.println（列表3）；
//输出：[7,5,4,3,1]
列表有多大？是否有
并行
流？如果是，有多少芯？只有像JMH这样具有框架的微基准才能判断。
Collections.reverse
只是颠倒了元素的顺序（n/2交换）我有根据的猜测：如果使用多线程（因为列表可能很小）没有好处，然后，<>代码>集合。Reals可能产生最佳的性能。考虑到在一个标准的用例中有一个小的列表，<代码>流>代码>方法创建了一个新的列表，并且比集合（ReaveSe）做了更多的工作。更不用说打字量的差异了。它真的是您的性能热点吗？如果是这样，请考虑Zabuzard的第二个评论。如果它不是热点，那么你问错了问题。它们有不同的用例，但性能不是在它们之间选择的主要动机。两个操作做的事情不一样那么哪一个更快有什么意义？列表有多大？是否有
并行
流？如果是，有多少芯？只有像JMH这样具有框架的微基准才能判断。
Collections.reverse
只是颠倒了元素的顺序（n/2交换）我有根据的猜测：如果使用多线程（因为列表可能很小）没有好处，然后，<>代码>集合。Reals可能产生最佳的性能。考虑到在一个标准的用例中有一个小的列表，<代码>流>代码>方法创建了一个新的列表，并且比集合（ReaveSe）做了更多的工作。更不用说打字量的差异了。它真的是您的性能热点吗？如果是这样，请考虑Zabuzard的第二个评论。如果它不是热点，那么你问错了问题。它们有不同的用例，但性能不是在它们之间进行选择的主要动机。两个操作做的事情不一样那么哪一个更快又有什么意义呢？