输入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
的文档。#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
–.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
元素,则可以使用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)
,因为现在列表包含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
评论
也许值得一提的是,您可以定义自己的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