如何sortingArrayList？
我有一个Java的双打名单，我想按降序sorting的ArrayList
inputArrayList就像 –
List<Double> testList=new ArrayList(); testList.add(0.5); testList.add(0.2); testList.add(0.9); testList.add(0.1); testList.add(0.1); testList.add(0.1); testList.add(0.54); testList.add(0.71); testList.add(0.71); testList.add(0.71); testList.add(0.92); testList.add(0.12); testList.add(0.65); testList.add(0.34); testList.add(0.62); 输出应该是这样的
0.92 0.9 0.71 0.71 0.71 0.65 0.62 0.54 0.5 0.34 0.2 0.12 0.1 0.1 0.1
Collections.sort(testList); Collections.reverse(testList);
这将做你想要的。 记得要导入Collections ！
以下是Collections的文档 。
使用java.util.Collections类的util方法，即
Collections.sort(list)
事实上，如果你想sorting自定义对象，你可以使用
Collections.sort(List<T> list, Comparator<? super T> c)
看集合api
降：
Collections.sort(mArrayList, new Comparator<CustomData>() { @Override public int compare(CustomData lhs, CustomData rhs) { // -1 - less than, 1 - greater than, 0 - equal, all inversed for descending return lhs.customInt > rhs.customInt ? -1 : (lhs.customInt < rhs.customInt) ? 1 : 0; } });
使用lambdas（Java8），并将其剥离到最简单的语法（在这种情况下，JVM将推断出很多 ），您将得到：
Collections.sort(testList, (a, b) -> b.compareTo(a));
更详细的版本：
// Implement a reverse-order Comparator by lambda function Comparator<Double> comp = (Double a, Double b) -> { return b.compareTo(a); }; Collections.sort(testList, comp);
使用lambda是可能的，因为Comparator接口只能实现一个方法，所以VM可以推断出哪个方法正在执行。 由于可以推断出参数的types，所以不需要说明（即(a, b)而不是(Double a, Double b) ，而且由于lambda体只有一条线，方法是期望返回一个值， return是推断和括号是没有必要的。
对于你的例子，这将会在Java 8中发挥魔力
testList.sort();
但是，如果您想按照您正在sorting的对象的某个字段进行sorting，则可以通过以下方式轻松顺利地执行此操作：
testList.sort(Comparator.comparing(ClassName::getFieldName));
要么
testList.sort(Comparator.comparing(ClassName::getFieldName).reversed());
要么
testList.stream().sorted(Comparator.comparing(ClassName::getFieldName).reversed());
来源： https ： //docs.oracle.com/javase/8/docs/api/java/util/Comparator.html
使用Java8时，List接口上有一个默认的sorting方法，如果您提供一个Comparator，将允许您sorting集合。 您可以轻松地在问题中对示例进行sorting，如下所示：
testList.sort((a, b) -> Double.compare(b, a));
注意：lambda中的参数在传递到Double.compare时被交换，以确保sorting是降序的
如果list包含Comparable元素，则可以使用Collections.sort(list)对list进行sorting。 否则，我会build议你像这样实现这个接口：
public class Circle implements Comparable<Circle> {}
当然也可以像这样提供你自己的compareTo方法的实现：
@Override public int compareTo(Circle another) { if (this.getD()<another.getD()){ return -1; }else{ return 1; } }
然后你可以再次使用Colection.sort(list)因为现在列表包含了Comparabletypes的对象并且可以被sorting。 顺序依赖于compareTo方法。 查看https://docs.oracle.com/javase/tutorial/collections/interfaces/order.html获取更多详细信息。;
Collections.sort允许您传递定义sorting逻辑的Comparator实例。 因此，不要按自然顺序对列表进行sorting，然后将其颠倒，只需传递Collections.reverseOrder()进行sort即可按相反的顺序对列表进行sorting：
// import java.util.Collections; Collections.sort(testList, Collections.reverseOrder());
正如@ Marco13所提到的，除了比较习惯（也可能更有效）之外，使用反向比较器确保sorting是稳定的（意味着当比较器相等时元素的顺序不会改变，而倒车会改变顺序）
//Here is sorted List alphabetically with syncronized package com.mnas.technology.automation.utility; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.Iterator; import java.util.List; import org.apache.log4j.Logger; /** * * @author manoj.kumar */ public class SynchronizedArrayList { static Logger log = Logger.getLogger(SynchronizedArrayList.class.getName()); @SuppressWarnings("unchecked") public static void main(String[] args) { List<Employee> synchronizedList = Collections.synchronizedList(new ArrayList<Employee>()); synchronizedList.add(new Employee("Aditya")); synchronizedList.add(new Employee("Siddharth")); synchronizedList.add(new Employee("Manoj")); Collections.sort(synchronizedList, new Comparator() { public int compare(Object synchronizedListOne, Object synchronizedListTwo) { //use instanceof to verify the references are indeed of the type in question return ((Employee)synchronizedListOne).name .compareTo(((Employee)synchronizedListTwo).name); } }); /*for( Employee sd : synchronizedList) { log.info("Sorted Synchronized Array List..."+sd.name); }*/ // when iterating over a synchronized list, we need to synchronize access to the synchronized list synchronized (synchronizedList) { Iterator<Employee> iterator = synchronizedList.iterator(); while (iterator.hasNext()) { log.info("Sorted Synchronized Array List Items: " + iterator.next().name); } } } } class Employee { String name; Employee (String name) { this.name = name; } }
如果您正在使用Java SE 8，那么这可能会有所帮助。
//create a comparator object using a Lambda expression Comparator<Double> compareDouble = (d1, d2) -> d1.compareTo(d2); //Sort the Collection in this case 'testList' in reverse order Collections.sort(testList, Collections.reverseOrder(compareDouble)); //print the sorted list using method reference only applicable in SE 8 testList.forEach(System.out::println);
你可以这样做：
List<String> yourList = new ArrayList<String>(); Collections.sort(yourList, Collections.reverseOrder());
集合有一个默认的比较器，可以帮助你。
另外，如果你想使用一些Java 8的新function，你可以这样做：
List<String> yourList = new ArrayList<String>(); yourList = yourList.stream().sorted(Collections.reverseOrder()).collect(Collectors.toList());
你可以这样使用
ArrayList<Group> groupList = new ArrayList<>(); Collections.sort(groupList, Collections.reverseOrder()); Collections.reverse(groupList);
使用Eclipse集合，您可以创build一个基本的双列表，对其进行sorting，然后将其反转为按降序排列。 这种做法将避免拳击双打。
MutableDoubleList doubleList = DoubleLists.mutable.with( 0.5, 0.2, 0.9, 0.1, 0.1, 0.1, 0.54, 0.71, 0.71, 0.71, 0.92, 0.12, 0.65, 0.34, 0.62) .sortThis().reverseThis(); doubleList.each(System.out::println);
如果你想要一个List<Double> ，那么下面的工作。
List<Double> objectList = Lists.mutable.with( 0.5, 0.2, 0.9, 0.1, 0.1, 0.1, 0.54, 0.71, 0.71, 0.71, 0.92, 0.12, 0.65, 0.34, 0.62) .sortThis(Collections.reverseOrder()); objectList.forEach(System.out::println);
如果要将types保留为ArrayList<Double> ，则可以使用ArrayListIterate实用程序类对列表进行初始化和sorting，如下所示：
ArrayList<Double> arrayList = ArrayListIterate.sortThis( new ArrayList<>(objectList), Collections.reverseOrder()); arrayList.forEach(System.out::println);
注意：我是Eclipse集合的提交者。
| * | sorting列表：
import java.util.Collections;
| =>按顺序sorting顺序：
Collections.sort(NamAryVar);
| => Sort Dsc Order：
Collections.sort(NamAryVar, Collections.reverseOrder());
| * | 颠倒List的顺序：
Collections.reverse(NamAryVar);
在JAVA 8现在它很容易。
List<String> alphaNumbers = Arrays.asList("one", "two", "three", "four"); List<String> alphaNumbersUpperCase = alphaNumbe`enter code here`rs.stream() .map(String::toUpperCase) .sorted() .collect(Collectors.toList()); System.out.println(alphaNumbersUpperCase); // [FOUR, ONE, THREE, TWO]
– 反向使用这个
.sorted（Comparator.reverseOrder（））
只需使用循环或默认的sort（）函数。
for(int n = 0; n<= arrList[i]; n++){ i
