我在Java中有一个双打列表,我想按降序对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);
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


#1 楼

Collections.sort(testList);
Collections.reverse(testList);


这会做您想要的。不过请记住要导入Collections

这里是Collections的文档。

评论


也许值得一提的是,您可以定义自己的Comparator :)

– Polygnome
13年4月27日在12:53

@Polygnome OP仅对Doubles进行排序。

–tckmn
2013年4月27日12:54



是的,但是您可以根据用例以各种方式对它们进行排序。有时您可能想按到0的距离对它们进行排序。我什至不知道反向的运行时特性,但是降序排序实际上可能比升序排序然后反向排序更快。此外,使用支持Comparator的List实现作为构造函数参数(因此保持不变)将确保列表始终被排序。

– Polygnome
13年4月27日在12:58

@Ayesha是的,Collections.sort在后台使用了compareTo。

–tckmn
2014年1月13日22:44

实际上应该使用Collections.sort(list,Collections.reverseOrder());。除了更惯用(可能更有效)之外,使用逆序比较器还可以确保排序稳定(这意味着元素的顺序在比较器中相等时不会改变,而反向会改变顺序) )。

– Marco13
2014年8月30日在23:18



#2 楼

降序:

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;
    }
});


评论


如果CustomData是AnotherModel具有ID的List 并且我想按ID排序,该怎么办?而且我只访问班级中的CustomData模型。

–.jacky博士
17/12/26在11:48

您只需用AnotherModel替换CustomData类,并获得如下代码:return lhs.id> rhs.id? -1:..等

–user2808054
18年1月12日在17:54

比较返回语句可以更好地写为Integer.compare(rhs.customInt,lhs.customInt);

– LordKiz
19年8月13日在9:30



#3 楼

对于您的示例,这将在Java 8中发挥神奇作用。

List<Double> testList = new ArrayList();
testList.sort(Comparator.naturalOrder());


但是,如果要按要排序的对象的某些字段进行排序,则可以

testList.sort(Comparator.comparing(ClassName::getFieldName));




 testList.sort(Comparator.comparing(ClassName::getFieldName).reversed());




 testList.stream().sorted(Comparator.comparing(ClassName::getFieldName).reversed()).collect(Collectors.toList());


来源:https://docs.oracle.com/javase/8/docs/api/java/util/Comparator.html

评论


“比较”方法位于何处?

– Lippo
16-10-4在10:20

您需要导入:导入静态java.util.Comparator.comparing;

–krmanish007
16-10-4在13:20

它在Java 1.7中可用吗?

– Lippo
16-10-5在11:07

不,这是流和功能接口的一部分,它是Java 8的全部

–krmanish007
16-10-5在14:01

您说得对@AjahnCharles。他们删除了零参数,因此我现在更新了答案。

–krmanish007
18年8月8日在19:40

#4 楼

使用java.util.Collections类的util方法,即

Collections.sort(list)


实际上,如果要对自定义对象进行排序,则可以使用

Collections.sort(List<T> list, Comparator<? super T> c) 


请参阅收藏集api

#5 楼

使用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可以推断出哪个方法正在实现。由于可以推断出参数的类型,因此无需声明它们(即,用(a, b)代替(Double a, Double b)。由于lambda主体只有一行,并且该方法应返回一个值,因此可以推断出return不需要大括号。

评论


太酷了,谢谢!这个比较紧凑:Collections.sort(testList,Comparator.reverseOrder());

– kavics
18年4月21日在9:36



更紧凑:testList.sort(Comparator.reverseOrder());

– jonasespelita
18年6月8日在9:18

#6 楼

使用Java8,List接口上有一个默认的排序方法,如果您提供了Comparator,它将允许您对集合进行排序。您可以轻松地对问题中的示例进行如下排序:

testList.sort((a, b) -> Double.compare(b, a));


注意:传递给Double.compare时,lambda中的args被交换以确保排序是降序

评论


对我来说这是最好的答案,因为它也适用于使用对象进行排序。例如locationDetails.sort((locationDetailAsc,locationDetailsDsc)-> Long.compare(locationDetailsDsc.getSnapshot()。getQuantity(),locationDetailAsc.getSnapshot()。 getQuantity()));

–Anas
18-2-21在11:52

此方法执行哪种类型的排序?

–里希克里希纳
9月22日晚上11:50

#7 楼

如果您的Collections.sort(list)包含list元素,则可以使用listComparable进行排序。否则,我建议您像下面那样实现该接口:

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),因为现在列表包含Comparable类型的对象并且可以进行排序。顺序取决于compareTo方法。检查此https://docs.oracle.com/javase/tutorial/collections/interfaces/order.html,以获取更多详细信息。

#8 楼

Collections.sort允许您传递Comparator的实例,该实例定义了排序逻辑。因此,与其以自然顺序对列表进行排序然后再对其进行反转,不如将Collections.reverseOrder()传递给sort以便以相反的顺序对列表进行排序:

// import java.util.Collections;
Collections.sort(testList, Collections.reverseOrder());


@ Marco13撰写的文章,除了更惯用(并且可能更有效)之外,使用逆序比较器还可以确保排序稳定(这意味着元素的顺序在比较器中相等时将不会更改,而反转)会更改顺序)

#9 楼

以下是涵盖典型案例的简短备忘单:

// 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))


#10 楼

//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;

    }
}


评论


似乎是Thas是Collections.synchronizedList帮助我们

–vitalinvent
19年5月31日上午10:19

#11 楼

如果您使用的是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);


评论


还有Collections.reverseOrder(),不带任何参数,这使您对compareDouble的实现变得多余(它等效于Doubles的自然排序)。答案应该是Collections.sort(testList,Collections.reverseOrder());

–马特
15年5月13日在9:23

#12 楼

| * |排序列表:

import java.util.Collections;


| =>升序排序:

Collections.sort(NamAryVar);


| =>排序Dsc订购:

Collections.sort(NamAryVar, Collections.reverseOrder());



| * |颠倒List的顺序:

Collections.reverse(NamAryVar);


#13 楼

您可以这样操作:

List<String> yourList = new ArrayList<String>();
Collections.sort(yourList, Collections.reverseOrder());


集合具有默认的Comparator可以帮助您。

此外,如果您想使用Java 8的一些新功能,您可以这样:

List<String> yourList = new ArrayList<String>();
yourList = yourList.stream().sorted(Collections.reverseOrder()).collect(Collectors.toList());


#14 楼

例如,我有一个类Person:字符串名称,int age ==>构造函数new Person(name,age)

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+"".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]]

}


评论


如果要按名称缩写->如果要按名称排序

– linrongbin
18年5月9日在12:15

#15 楼

在JAVA 8中,现在非常容易。

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]


-要反向使用,请

.sorted(Comparator.reverseOrder())


#16 楼

您可以使用

ArrayList<Group> groupList = new ArrayList<>();
Collections.sort(groupList, Collections.reverseOrder());
Collections.reverse(groupList);


#17 楼

使用Eclipse Collections,您可以创建一个原始的双重列表,对其进行排序,然后将其反向以降序排列。这种方法可以避免打双打。

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);


如果要保持类型为ArrayList<Double>,您可以使用ArrayListIterate实用程序类对列表进行初始化和排序,如下所示:

ArrayList<Double> arrayList =
    ArrayListIterate.sortThis(
            new ArrayList<>(objectList), Collections.reverseOrder());
arrayList.forEach(System.out::println);


注意:我是Eclipse Collections的提交者。 />

#18 楼

以下行应做粗的

testList.sort(Collections.reverseOrder());


#19 楼

如果必须根据ArrayList中的ID对对象进行排序,请使用java8流。
  List<Person> personList = new ArrayList<>();

    List<Person> personListSorted =
                personList.stream()
                  .sorted(Comparator.comparing(Person::getPersonId))
                  .collect(Collectors.toList());
 


#20 楼

  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())
    }


评论


如果您能提供一些解释的话,那会很好;)

– johannchopin
8月19日8:07

谢谢,但我认为没有解释,因为干净的代码,可读:)

– CanerYılmaz
8月19日8:15

是的,所以首先要缩进您的干净代码;)

– johannchopin
8月19日8:20