如何对ArrayList进行排序？

Question

我在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

Answer 1

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

那会做你想要的。请记住导入Collections尽管！

Here is the documentation for Collections

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

Answer 3

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

Collections.sort(list)

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

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

见集合api

Answer 4

对于您的示例，这将在Java 8中发挥作用

<

但是如果你想按照你正在排序的对象的某些字段进行排序，你可以通过以下方式轻松完成：

>

或

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

或

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

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

Answer 5

使用lambdas（Java8），并将其剥离为最基本的语法（在这种情况下JVM将推断 lots ），你得到：

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可以推断出正在实现的方法。由于可以推断出params的类型，因此不需要说明它们（即(a, b)而不是(Double a, Double b)。并且因为lambda体只有一条线，并且方法是期望返回一个值，推断出return并且不需要大括号。

Answer 6

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

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

注意：传入lambda中的args在传入Double.compare时会被交换，以确保排序是降序的

Answer 7

如果Collections.sort(list)包含list元素，您可以使用list对Comparable进行排序。否则我建议你像这样实现这个界面：

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

Answer 8

Collections.sort允许您传递定义排序逻辑的Comparator实例。因此，不是按自然顺序对列表进行排序然后将其反转，而是可以简单地将Collections.reverseOrder()传递给sort，以便按相反的顺序对列表进行排序：

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

正如@ Marco13所提到的，除了更惯用（并且可能更有效）之外，使用逆序比较器确保排序稳定（意味着元素的顺序在它们相等时不会被改变）比较器，而反转将改变顺序）

Answer 9

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

    }
}

Answer 10

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

Answer 11

| * |排序列表：

import java.util.Collections;

| =＆GT;按顺序排序：

Collections.sort(NamAryVar);

| =＆GT;排序Dsc顺序：

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

| * |颠倒List的顺序：

Collections.reverse(NamAryVar);

Answer 12

你可以这样做：

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

Collection有一个默认的Comparator可以帮助你。

此外，如果您想使用某些Java 8新功能，您可以这样做：

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

Answer 13

你可以这样使用

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

Answer 14

例如我有一个Person：String name，int age ==＆gt; Constructor 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]]

}

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

Answer 16

使用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的提交者。

Answer 17

以下行应该执行粗

testList.sort(Collections.reverseOrder());

Answer 18

如果必须根据ArrayList中的ID对对象进行排序，请使用java8流。

 List<Person> personList = new ArrayList<>();

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

Answer 19

以下是简短的速查表，涵盖了典型案例：

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

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

Answer 21

排序列表的另一种方法是使用集合框架；

在这种情况下使用 SortedSet（列表中的 bean 应该实现 Comparable，所以 Double 是可以的）：

List<Double> testList;
...
SortedSet<Double> sortedSet= new TreeSet<Double>();
for(Double number: testList) {
   sortedSet.add(number);
}
orderedList=new ArrayList(sortedSet);

一般来说，要按列表中bean的属性排序，将列表中的所有元素放在一个SortedMap中，使用该属性作为键，然后从SortedMap中获取values()（该属性应该实现可比）：

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