如何排序一个列表/数组列表?

小开

最佳答案

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

这是你想要的。记住导入Collections !

下面是Collections的文档。

小开

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

Collections.sort(list)

事实上，如果你想排序自定义对象你可以使用

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

参见集合API

小开

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


}
}

小开

如果你的list包含Comparable元素，你可以使用Collections.sort(list)对list进行排序。否则我建议你像这样实现接口:

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)，因为现在list包含Comparable类型的对象，可以排序。顺序取决于compareTo方法。查看https://docs.oracle.com/javase/tutorial/collections/interfaces/order.html以获得更详细的信息。

小开

如果您正在使用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.sort允许你传递一个定义排序逻辑的Comparator实例。因此，我们可以简单地将Collections.reverseOrder()传递给sort，而不是按自然顺序对列表进行排序，然后反转它:

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

正如@Marco13所提到的，除了更习惯(可能更有效)，使用倒序比较器可以确保排序是稳定的(这意味着当元素的顺序根据比较器相等时，它们的顺序不会改变，而倒序将改变顺序)

小开

你可以这样用

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

小开

降:

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

小开

在Java8中，List接口上有一个默认的排序方法，如果您提供了Comparator，该方法将允许您对集合进行排序。你可以很容易地将问题中的例子排序如下:

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

注意:lambda中的参数在传递给Double.compare时交换，以确保排序是降序的

小开

你可以这样做:

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

集合有一个默认的比较器可以帮助你。

另外，如果你想使用一些Java 8的新特性，你可以这样做:

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

小开

对于您的示例，这将在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

小开

使用Eclipse集合，你可以创建一个基本的双列表，对其排序，然后将其反向排列成降序。这种方法可以避免打双打。

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集合的提交者。

小开

|*|

import java.util.Collections;

|=>排序Asc顺序:

Collections.sort(NamAryVar);

|=>

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

|*|颠倒列表顺序:

Collections.reverse(NamAryVar);

小开

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

小开

例如，我有一个类Person: String name, 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]]


}

小开

下面的线条应该比较粗

testList.sort(Collections.reverseOrder());

小开

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

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

小开

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

小开

如果你必须根据对象在数组列表中的id来排序，那么使用java8流。

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


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

小开

排序List的另一种方法是使用Collections框架;

在这种情况下使用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()(该属性应该实现Comparable):

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