blocks|key|111294|text|Collections.sort(testList);
Collections.reverse(testList);|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|111295|它会做你想做的事。记住要导入Collections！|unstyled|offset|length|style|CODE|111296|Here+is+the+documentation+for+Collections。|111297|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.oracle.com/javase/10/docs/api/java/util/Collections.html#sort(java.util.List))^0|0|E|B|0|U|B|0|15|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|V|8|@$G|W|H|X|I|J]]|9|@]|A|$]]|$1|K|3|L|5|F|7|Y|8|@$G|Z|H|10|I|J]]|9|@$G|11|H|12|1|13]]|A|$]]|$1|M|3|-4|5|F|7|14|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

<pre><code>Collections.sort(testList);
Collections.reverse(testList);
</code></pre>

That will do what you want. Remember to import <code>Collections</code> though!

<a href="https://docs.oracle.com/javase/10/docs/api/java/util/Collections.html#sort(java.util.List)" rel="noreferrer">Here is the documentation for <code>Collections</code></a>.

blocks|key|328857|text|降序：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|328858|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;
++++}
});|code-block|syntax|javascript|328859|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Descending:

<pre><code>Collections.sort(mArrayList, new Comparator&lt;CustomData&gt;() {
 @Override
 public int compare(CustomData lhs, CustomData rhs) {
 // -1 - less than, 1 - greater than, 0 - equal, all inversed for descending
 return lhs.customInt &gt; rhs.customInt ? -1 : (lhs.customInt &lt; rhs.customInt) ? 1 : 0;
 }
});
</code></pre>

blocks|key|111712|text|对于您的示例，这将在Java+8中发挥魔力|type|unstyled|depth|inlineStyleRanges|entityRanges|data|111713|List<Double>+testList+=+new+ArrayList();
testList.sort(Comparator.naturalOrder());|code-block|syntax|javascript|111714|但是，如果您想要按要排序的对象的某些字段进行排序，可以通过以下方法轻松实现：|111715|testList.sort(Comparator.comparing(ClassName::getFieldName));|111716|或|111717|+testList.sort(Comparator.comparing(ClassName::getFieldName).reversed());|111718|111719|+testList.stream().sorted(Comparator.comparing(ClassName::getFieldName).reversed()).collect(Collectors.toList());|111720|资料来源：https://docs.oracle.com/javase/8/docs/api/java/util/Comparator.html|offset|length|111721|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.oracle.com/javase/8/docs/api/java/util/Comparator.html^0|0|0|0|0|0|0|0|0|5|1V|0|0^^$0|@$1|2|3|4|5|6|7|13|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|14|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|15|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|16|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|17|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|18|8|@]|9|@]|A|$E|F]]|$1|O|3|L|5|6|7|19|8|@]|9|@]|A|$]]|$1|P|3|Q|5|D|7|1A|8|@]|9|@]|A|$E|F]]|$1|R|3|S|5|6|7|1B|8|@]|9|@$T|1C|U|1D|1|1E]]|A|$]]|$1|V|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]]|W|$X|$5|Y|Z|10|A|$11|12]]]]

For your example, this will do the magic in Java 8

<pre><code>List&lt;Double&gt; testList = new ArrayList();
testList.sort(Comparator.naturalOrder());
</code></pre>

But if you want to sort by some of the fields of the object you are sorting, you can do it easily by:

<pre><code>testList.sort(Comparator.comparing(ClassName::getFieldName));
</code></pre>

or 

<pre><code> testList.sort(Comparator.comparing(ClassName::getFieldName).reversed());
</code></pre>

or

<pre><code> testList.stream().sorted(Comparator.comparing(ClassName::getFieldName).reversed()).collect(Collectors.toList());
</code></pre>

Sources: <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Comparator.html" rel="noreferrer">https://docs.oracle.com/javase/8/docs/api/java/util/Comparator.html</a>

blocks|key|328760|text|使用java.util.Collections类的util方法，即|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|328761|Collections.sort(list)|code-block|syntax|javascript|328762|实际上，如果您想对自定义对象进行排序，可以使用|328763|Collections.sort(List<T>+list,+Comparator<?+super+T>+c)+|328764|请参阅集合api|328765|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.oracle.com/javase/7/docs/api/java/util/Collections.html^0|2|L|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|11|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|12|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|13|8|@]|9|@]|C|$]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]]]

Use util method of <a href="http://docs.oracle.com/javase/7/docs/api/java/util/Collections.html" rel="noreferrer">java.util.Collections</a> class, i.e

<pre><code>Collections.sort(list)
</code></pre>

In fact, if you want to sort custom object you can use

<pre><code>Collections.sort(List&lt;T&gt; list, Comparator&lt;? super T&gt; c) 
</code></pre>

see collections api

blocks|key|328990|text|对于Java8，在列表接口上有一个默认的排序方法，如果您提供了一个比较器，它将允许您对集合进行排序。您可以轻松地对问题中的示例进行排序，如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|328991|testList.sort((a,+b)+->+Double.compare(b,+a));|code-block|syntax|javascript|328992|注意:当传递给Double.compare时，lambda中的arg会被交换，以确保排序是降序的|328993|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

With Java8 there is a default sort method on the List interface that will allow you to sort the collection if you provide a Comparator. You can easily sort the example in the question as follows:

<pre><code>testList.sort((a, b) -&gt; Double.compare(b, a));
</code></pre>

Note: the args in the lambda are swapped when passed in to Double.compare to ensure the sort is descending

blocks|key|328809|text|如果您的list包含Comparable元素，则可以使用Collections.sort(list)对list进行排序。否则，我建议您像这样实现该接口：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|328810|public+class+Circle+implements+Comparable<Circle>+{}|code-block|syntax|javascript|328811|当然，还可以提供您自己的compareTo方法实现，如下所示：|328812|@Override
++++public+int+compareTo(Circle+another)+{
++++++++if+(this.getD()<another.getD()){
++++++++++++return+-1;
++++++++}else{
++++++++++++return+1;
++++++++}
++++}|328813|然后，您可以再次使用Colection.sort(list)，因为现在list包含可比较类型的对象，并且可以排序。顺序取决于compareTo方法。有关更详细的信息，请查看此https://docs.oracle.com/javase/tutorial/collections/interfaces/order.html。|328814|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.oracle.com/javase/tutorial/collections/interfaces/order.html^0|4|4|A|A|S|M|1F|4|0|0|C|9|0|0|A|K|1Q|9|2F|21|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|17|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|18|8|@$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|1B|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1C|8|@$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]]|D|@$9|1H|A|1I|1|1J]]|E|$]]|$1|Q|3|-4|5|6|7|1K|8|@]|D|@]|E|$]]]|R|$S|$5|T|U|V|E|$W|X]]]]

You can use <code>Collections.sort(list)</code> to sort <code>list</code> if your <code>list</code> contains <code>Comparable</code> elements. Otherwise I would recommend you to implement that interface like here:

<pre><code>public class Circle implements Comparable&lt;Circle&gt; {}
</code></pre>

and of course provide your own realization of <code>compareTo</code> method like here:

<pre><code>@Override
 public int compareTo(Circle another) {
 if (this.getD()&lt;another.getD()){
 return -1;
 }else{
 return 1;
 }
 }
</code></pre>

And then you can again use <code>Colection.sort(list)</code> as now list contains objects of Comparable type and can be sorted. Order depends on <code>compareTo</code> method. Check this <a href="https://docs.oracle.com/javase/tutorial/collections/interfaces/order.html">https://docs.oracle.com/javase/tutorial/collections/interfaces/order.html</a> for more detailed information.

blocks|key|329655|text|以下是一个涵盖典型案例的简短小抄：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|329656|import+static+java.util.Comparator.comparing;

//+sort
list.sort(naturalOrder());

//+sort+(reversed)
list.sort(reverseOrder());

//+sort+by+field
list.sort(comparing(Type::getField));

//+sort+by+field+(reversed)
list.sort(comparing(Type::getField).reversed());

//+sort+by+int+field
list.sort(comparingInt(Type::getIntField));

//+sort+by+double+field+(reversed)
list.sort(comparingDouble(Type::getDoubleField).reversed());

//+sort+by+nullable+field+(nulls+last)
list.sort(comparing(Type::getNullableField,+nullsLast(naturalOrder())));

//+two-level+sort
list.sort(comparing(Type::getField1).thenComparing(Type::getField2));|code-block|syntax|javascript|329657|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is a short cheatsheet that covers typical cases:
<pre><code>import static java.util.Comparator.comparing;

// sort
list.sort(naturalOrder());

// sort (reversed)
list.sort(reverseOrder());

// sort by field
list.sort(comparing(Type::getField));

// sort by field (reversed)
list.sort(comparing(Type::getField).reversed());

// sort by int field
list.sort(comparingInt(Type::getIntField));

// sort by double field (reversed)
list.sort(comparingDouble(Type::getDoubleField).reversed());

// sort by nullable field (nulls last)
list.sort(comparing(Type::getNullableField, nullsLast(naturalOrder())));

// two-level sort
list.sort(comparing(Type::getField1).thenComparing(Type::getField2));
</code></pre>

blocks|key|328846|text|Collections.sort允许您传递定义排序逻辑的Comparator的实例。因此，您可以简单地将Collections.reverseOrder()传递给sort，以便以相反的顺序对列表进行排序，而不是按自然顺序对列表进行排序：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|328847|//+import+java.util.Collections;
Collections.sort(testList,+Collections.reverseOrder());|code-block|syntax|javascript|328848|正如@Marco13所提到的，除了更加惯用(并且可能更高效)，使用逆序比较器还可以确保排序是稳定的(这意味着当元素根据比较器相等时，它们的顺序不会改变，而反转则会改变顺序)|328849|entityMap^0|0|G|S|A|1G|Q|29|4|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|N|$]]

<code>Collections.sort</code> allows you to pass an instance of a <code>Comparator</code> which defines the sorting logic. So instead of sorting the list in natural order and then reversing it, one can simply pass <code>Collections.reverseOrder()</code> to <code>sort</code> in order to sort the list in reverse order:

<pre><code>// import java.util.Collections;
Collections.sort(testList, Collections.reverseOrder());
</code></pre>

As mentioned by @Marco13, apart from being more idiomatic (and possibly more efficient), using the reverse order comparator makes sure that the sort is stable (meaning that the order of elements will not be changed when they are equal according to the comparator, whereas reversing will change the order)

blocks|key|328769|text|//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..."%2Bsd.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:+"+%2B+iterator.next().name);
++++++++++++}
++++++++}

++++}
}

class+Employee+{
++++String+name;

++++Employee(String+name)+{
++++++++this.name+=+name;

++++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|328770|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>//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&lt;Employee&gt; synchronizedList = Collections.synchronizedList(new ArrayList&lt;Employee&gt;());
 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&lt;Employee&gt; 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;

 }
}
</code></pre>

blocks|key|328820|text|如果您使用的是Java+SE+8，那么这可能会有所帮助。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|328821|//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);|code-block|syntax|javascript|328822|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

if you are using Java SE 8, then this might be of help.

<pre><code>//create a comparator object using a Lambda expression
Comparator&lt;Double&gt; compareDouble = (d1, d2) -&gt; 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);
</code></pre>

blocks|key|111529|text|你可以这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|111530|List<String>+yourList+=+new+ArrayList<String>();
Collections.sort(yourList,+Collections.reverseOrder());|code-block|syntax|javascript|111531|集合有一个默认的比较器，它可以帮助你做到这一点。|111532|另外，如果你想使用一些Java+8的新特性，你可以这样做：|111533|List<String>+yourList+=+new+ArrayList<String>();
yourList+=+yourList.stream().sorted(Collections.reverseOrder()).collect(Collectors.toList());|111534|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

You can do like this:

<pre><code>List&lt;String&gt; yourList = new ArrayList&lt;String&gt;();
Collections.sort(yourList, Collections.reverseOrder());
</code></pre>

Collection has a default Comparator that can help you with that.

Also, if you want to use some Java 8 new features, you can do like that:

<pre><code>List&lt;String&gt; yourList = new ArrayList&lt;String&gt;();
yourList = yourList.stream().sorted(Collections.reverseOrder()).collect(Collectors.toList());
</code></pre>

blocks|key|111425|text|你可以像这样使用|type|unstyled|depth|inlineStyleRanges|entityRanges|data|111426|ArrayList<Group>+groupList+=+new+ArrayList<>();
Collections.sort(groupList,+Collections.reverseOrder());
Collections.reverse(groupList);|code-block|syntax|javascript|111427|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can use like that 

<pre><code>ArrayList&lt;Group&gt; groupList = new ArrayList&lt;&gt;();
Collections.sort(groupList, Collections.reverseOrder());
Collections.reverse(groupList);
</code></pre>

blocks|key|111842|text|在Java8中，现在简单多了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|111843|List<String>+alphaNumbers+=+Arrays.asList("one",+"two",+"three",+"four");
List<String>+alphaNumbersUpperCase+=+alphaNumbers.stream()
++++.map(String::toUpperCase)
++++.sorted()
++++.collect(Collectors.toList());
System.out.println(alphaNumbersUpperCase);+//+[FOUR,+ONE,+THREE,+TWO]|code-block|syntax|javascript|111844|--对于反向使用此命令|111845|.sorted(Comparator.reverseOrder())|111846|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

In JAVA 8 its much easy now.

<pre><code>List&lt;String&gt; alphaNumbers = Arrays.asList("one", "two", "three", "four");
List&lt;String&gt; alphaNumbersUpperCase = alphaNumbers.stream()
 .map(String::toUpperCase)
 .sorted()
 .collect(Collectors.toList());
System.out.println(alphaNumbersUpperCase); // [FOUR, ONE, THREE, TWO]
</code></pre>

-- For reverse use this

<pre><code>.sorted(Comparator.reverseOrder())
</code></pre>

blocks|key|111896|text|例如，我有一个类Person:+String+name，int+age+==>Constructor+new+Person(name，age)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|111897|import+java.util.Collections;
import+java.util.ArrayList;
import+java.util.Arrays;


public+void+main(String[]+args){
++++Person+ibrahima=new+Person("Timera",40);
++++Person+toto=new+Person("Toto",35);
++++Person+alex=new+Person("Alex",50);
++++ArrayList<Person>+myList=new+ArrayList<Person>
++++Collections.sort(myList,+new+Comparator<Person>()+{
++++++++@Override
++++++++public+int+compare(Person+p1,+Person+p2)+{
++++++++++++//+return+p1.age%2B"".compareTo(p2.age%2B"");+//sort+by+age
++++++++++++return+p1.name.compareTo(p2.name);+//+if+you+want+to+short+by+name
++++++++}
++++});
++++System.out.println(myList.toString());
++++//[Person+[name=Alex,+age=50],+Person+[name=Timera,+age=40],+Person+[name=Toto,+age=35]]
++++Collections.reverse(myList);
++++System.out.println(myList.toString());
++++//[Person+[name=Toto,+age=35],+Person+[name=Timera,+age=40],+Person+[name=Alex,+age=50]]

}|code-block|syntax|javascript|111898|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

For example I have a class Person: String name, int age ==>Constructor new Person(name,age) 

<pre><code>import java.util.Collections;
import java.util.ArrayList;
import java.util.Arrays;


public void main(String[] args){
 Person ibrahima=new Person("Timera",40);
 Person toto=new Person("Toto",35);
 Person alex=new Person("Alex",50);
 ArrayList&lt;Person&gt; myList=new ArrayList&lt;Person&gt;
 Collections.sort(myList, new Comparator&lt;Person&gt;() {
 @Override
 public int compare(Person p1, Person p2) {
 // return p1.age+"".compareTo(p2.age+""); //sort by age
 return p1.name.compareTo(p2.name); // if you want to short by name
 }
 });
 System.out.println(myList.toString());
 //[Person [name=Alex, age=50], Person [name=Timera, age=40], Person [name=Toto, age=35]]
 Collections.reverse(myList);
 System.out.println(myList.toString());
 //[Person [name=Toto, age=35], Person [name=Timera, age=40], Person [name=Alex, age=50]]

}
</code></pre>

blocks|key|329694|text|如果你必须根据ArrayList中的id对对象进行排序，那么可以使用java8流。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|329695|+List<Person>+personList+=+new+ArrayList<>();

++++List<Person>+personListSorted+=
++++++++++++++++personList.stream()
++++++++++++++++++.sorted(Comparator.comparing(Person::getPersonId))
++++++++++++++++++.collect(Collectors.toList());|code-block|syntax|javascript|329696|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If you have to sort object based on its id in the ArrayList , then use java8 stream.
<pre class="lang-java prettyprint-override"><code> List&lt;Person&gt; personList = new ArrayList&lt;&gt;();

 List&lt;Person&gt; personListSorted =
 personList.stream()
 .sorted(Comparator.comparing(Person::getPersonId))
 .collect(Collectors.toList());
</code></pre>

blocks|key|329396|text|使用Eclipse+Collections，您可以创建一个原始的双列表，对其进行排序，然后将其反转以按降序排列。这种方法可以避免对替身进行装箱。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|329397|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);|code-block|syntax|javascript|329398|如果你想要一个List<Double>，那么下面的方法就行了。|style|CODE|329399|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);|329400|如果希望保持类型为ArrayList<Double>，则可以使用ArrayListIterate实用程序类初始化列表并对其进行排序，如下所示：|329401|ArrayList<Double>+arrayList+=
++++ArrayListIterate.sortThis(
++++++++++++new+ArrayList<>(objectList),+Collections.reverseOrder());
arrayList.forEach(System.out::println);|329402|注意:我是Eclipse+Collections的提交者。|329403|entityMap|0|LINK|mutability|MUTABLE|url|https://www.eclipse.org/collections/|1^0|2|J|0|0|0|7|C|0|0|9|H|W|G|0|0|5|J|1|0^^$0|@$1|2|3|4|5|6|7|13|8|@]|9|@$A|14|B|15|1|16]]|C|$]]|$1|D|3|E|5|F|7|17|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|18|8|@$A|19|B|1A|K|L]]|9|@]|C|$]]|$1|M|3|N|5|F|7|1B|8|@]|9|@]|C|$G|H]]|$1|O|3|P|5|6|7|1C|8|@$A|1D|B|1E|K|L]|$A|1F|B|1G|K|L]]|9|@]|C|$]]|$1|Q|3|R|5|F|7|1H|8|@]|9|@]|C|$G|H]]|$1|S|3|T|5|6|7|1I|8|@]|9|@$A|1J|B|1K|1|1L]]|C|$]]|$1|U|3|-4|5|6|7|1M|8|@]|9|@]|C|$]]]|V|$W|$5|X|Y|Z|C|$10|11]]|12|$5|X|Y|Z|C|$10|11]]]]

With <a href="https://www.eclipse.org/collections/" rel="nofollow noreferrer">Eclipse Collections</a> you could create a primitive double list, sort it and then reverse it to put it in descending order. This approach would avoid boxing the doubles. 

<pre><code>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);
</code></pre>

If you want a <code>List&lt;Double&gt;</code>, then the following would work.

<pre><code>List&lt;Double&gt; 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);
</code></pre>

If you want to keep the type as <code>ArrayList&lt;Double&gt;</code>, you can initialize and sort the list using the <code>ArrayListIterate</code> utility class as follows:

<pre><code>ArrayList&lt;Double&gt; arrayList =
 ArrayListIterate.sortThis(
 new ArrayList&lt;&gt;(objectList), Collections.reverseOrder());
arrayList.forEach(System.out::println);
</code></pre>

Note: I am a committer for <a href="https://www.eclipse.org/collections/" rel="nofollow noreferrer">Eclipse Collections</a>.

blocks|key|111925|text|下面这行代码应该是粗略的|type|unstyled|depth|inlineStyleRanges|entityRanges|data|111926|testList.sort(Collections.reverseOrder());|code-block|syntax|javascript|111927|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

The following line should do the thick

<pre><code>testList.sort(Collections.reverseOrder());
</code></pre>

blocks|key|112060|text|对列表进行排序的另一种方法是使用集合框架；|type|unstyled|depth|inlineStyleRanges|entityRanges|data|112061|在本例中使用SortedSet+(列表中的bean应该实现可比较的，所以Double是可以的)：|112062|List<Double>+testList;
...
SortedSet<Double>+sortedSet=+new+TreeSet<Double>();
for(Double+number:+testList)+{
+++sortedSet.add(number);
}
orderedList=new+ArrayList(sortedSet);|code-block|syntax|javascript|112063|通常，要按列表中bean的属性排序，请将列表中的所有元素放在一个SortedMap中，使用该属性作为键，然后从SortedMap获取值()(该属性应实现可比较)：|112064|List<Bean>+testList;
...
SortedMap<AttributeType,Bean>+sortedMap=+new+TreeMap<AttributeType,+Bean>();
for(Bean+bean+:+testList)+{
+++sortedMap.put(bean.getAttribute(),bean);
}
orderedList=new+ArrayList(sortedMap.values());|112065|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

An alternative way to order a List is using the Collections framework;
in this case using the SortedSet (the bean in the list should implement Comparable, so Double is ok):
<pre><code>List&lt;Double&gt; testList;
...
SortedSet&lt;Double&gt; sortedSet= new TreeSet&lt;Double&gt;();
for(Double number: testList) {
 sortedSet.add(number);
}
orderedList=new ArrayList(sortedSet);
</code></pre>
In general, to order by an attribute of a bean in the list,put all the elements of the list in a SortedMap, using as a key the attribute, then get the values() from the SortedMap (the attribute should implement Comparable):
<pre><code>List&lt;Bean&gt; testList;
...
SortedMap&lt;AttributeType,Bean&gt; sortedMap= new TreeMap&lt;AttributeType, Bean&gt;();
for(Bean bean : testList) {
 sortedMap.put(bean.getAttribute(),bean);
}
orderedList=new ArrayList(sortedMap.values());
</code></pre>

blocks|key|329674|text|++yearList+=+arrayListOf()
++++for+(year+in+1950+until+2021)+{
++++++++yearList.add(year)
++++}

+++yearList.reverse()
++++val+list:+ArrayList<String>+=+arrayListOf()

++++for+(year+in+yearList)+{
++++++++list.add(year.toString())
++++}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|329675|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code> yearList = arrayListOf()
 for (year in 1950 until 2021) {
 yearList.add(year)
 }

 yearList.reverse()
 val list: ArrayList&lt;String&gt; = arrayListOf()

 for (year in yearList) {
 list.add(year.toString())
 }
</code></pre>

I have a List of doubles in java and I want to sort ArrayList in descending order.

Input ArrayList is as below:

<pre><code>List&lt;Double&gt; 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);
</code></pre>

The out put should be like this

<pre><code>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
</code></pre>

How to sort an ArrayList?

Java

我在java中有一个doubles列表，我想按降序对ArrayList进行排序。输入ArrayList如下：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

问如何对ArrayList进行排序？
EN

回答 19

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何对ArrayList进行排序？EN

回答 19

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何对ArrayList进行排序？
EN