如何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