在 Java 中使用 stream. sort()对列表进行排序

小开

它似乎运转良好:

List<BigDecimal> list = Arrays.asList(new BigDecimal("24.455"), new BigDecimal("23.455"), new BigDecimal("28.455"), new BigDecimal("20.455"));
System.out.println("Unsorted list: " + list);
final List<BigDecimal> sortedList = list.stream().sorted((o1, o2) -> o1.compareTo(o2)).collect(Collectors.toList());
System.out.println("Sorted list: " + sortedList);

输入/输出示例

Unsorted list: [24.455, 23.455, 28.455, 20.455]
Sorted list: [20.455, 23.455, 24.455, 28.455]

您确定您没有验证 list 而不是 sortedList(在上面的例子中) ，也就是说，您正在将 stream()的结果存储在一个新的 List对象中并验证该对象？

小开

最佳答案

这不像 Collections.sort()那样对参数引用进行排序。在这种情况下，您只需要获得一个已排序的流，最终需要收集并分配给另一个变量:

List result = list.stream().sorted((o1, o2)->o1.getItem().getValue().
compareTo(o2.getItem().getValue())).
collect(Collectors.toList());

你刚好错过了分配结果

小开

改为使用 list.sort:

list.sort((o1, o2) -> o1.getItem().getValue().compareTo(o2.getItem().getValue()));

并使用 Comparator.comparing使其更加简洁:

list.sort(Comparator.comparing(o -> o.getItem().getValue()));

在这两者之一之后，list本身将被排序。

你的问题是 list.stream.sorted 报税表排序的数据，它没有像你期望的那样排序到位。

小开

Collection<Map<Item, Integer>> itemCollection = basket.values();
Iterator<Map<Item, Integer>> itemIterator =   itemCollection.stream().sorted(new TestComparator()).collect(Collectors.toList()).iterator();






package com.ie.util;


import com.ie.item.Item;


import java.util.Comparator;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;


public class TestComparator implements Comparator<Map<Item, Integer>> {


// comparator is used to sort the Items based on the price




@Override
public int compare(Map<Item, Integer> o1, Map<Item, Integer> o2) {




//  System.out.println("*** compare method will be called *****");




Item item1 = null;
Item item2 = null;




Set<Item> itemSet1 = o1.keySet();
Iterator<Item> itemIterator1 = itemSet1.iterator();
if(itemIterator1.hasNext()){
item1 =   itemIterator1.next();
}


Set<Item> itemSet2 = o2.keySet();
Iterator<Item> itemIterator2 = itemSet2.iterator();
if(itemIterator2.hasNext()){
item2 =   itemIterator2.next();
}




return -item1.getPrice().compareTo(item2.getPrice());




}
}

这有助于对嵌套的 Map 对象进行排序，比如 Map > ，这里我根据 Item 对象的价格进行排序。

小开

Java8提供了不同的实用 API 方法来帮助我们更好地对流进行排序。

如果您的列表是一个整数列表(或者 Double、 Long、 String 等) ，那么您可以使用 Java 提供的默认比较器对列表进行排序。

List<Integer> integerList = Arrays.asList(1, 4, 3, 4, 5);

在飞行中创建比较器:

integerList.stream().sorted((i1, i2) -> i1.compareTo(i2)).forEach(System.out::println);

当没有参数传递给 sort ()时，使用 java 8提供的默认比较器:

integerList.stream().sorted().forEach(System.out::println); //Natural order

如果您希望以相反的顺序对同一列表进行排序:

 integerList.stream().sorted(Comparator.reverseOrder()).forEach(System.out::println); // Reverse Order

如果列表是用户定义对象的列表，则:

List<Person> personList = Arrays.asList(new Person(1000, "First", 25, 30000),
new Person(2000, "Second", 30, 45000),
new Person(3000, "Third", 35, 25000));

在飞行中创建比较器:

personList.stream().sorted((p1, p2) -> ((Long)p1.getPersonId()).compareTo(p2.getPersonId()))
.forEach(person -> System.out.println(person.getName()));

使用 compator.compariingLong ()方法(我们也有 compariingDouble ()方法和 compariingInt ()方法) :

personList.stream().sorted(Comparator.comparingLong(Person::getPersonId)).forEach(person -> System.out.println(person.getName()));

使用 COMPATOR.ゑ()方法(基于提供的 getter 方法进行比较的 Generic 方法) :

personList.stream().sorted(Comparator.comparing(Person::getPersonId)).forEach(person -> System.out.println(person.getName()));

我们也可以使用比较()方法进行链接:

personList.stream().sorted(Comparator.comparing(Person::getPersonId).thenComparing(Person::getAge)).forEach(person -> System.out.println(person.getName())); //Sorting by person id and then by age.

人员类别

public class Person {
private long personId;
private String name;
private int age;
private double salary;


public long getPersonId() {
return personId;
}


public void setPersonId(long personId) {
this.personId = personId;
}


public Person(long personId, String name, int age, double salary) {
this.personId = personId;
this.name = name;
this.age = age;


this.salary = salary;
}


public String getName() {
return name;
}


public void setName(String name) {
this.name = name;
}


public int getAge() {
return age;
}


public void setAge(int age) {
this.age = age;
}


public double getSalary() {
return salary;
}


public void setSalary(double salary) {
this.salary = salary;
}
}

小开

这是一个简单的例子:

List<String> citiesName = Arrays.asList( "Delhi","Mumbai","Chennai","Banglore","Kolkata");
System.out.println("Cities : "+citiesName);
List<String> sortedByName = citiesName.stream()
.sorted((s1,s2)->s2.compareTo(s1))
.collect(Collectors.toList());
System.out.println("Sorted by Name : "+ sortedByName);

您的 IDE 可能没有得到 jdk 1.8或更高版本来编译代码。

为 Your _ Project > properties > Project Facets > Java version 1.8设置 Java 版本1.8

小开

这可能有助于人们在这里搜索如何按字母顺序排序列表。

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;


import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;


public class SortService {
public static void main(String[] args) {
List<TestData> test = new ArrayList<>();
test.add(prepareTestData("Asmin",1));
test.add(prepareTestData("saurav",4));
test.add(prepareTestData("asmin",2));
test.add(prepareTestData("Saurav",3));


test.forEach(data-> System.out.println(data));
/** Output
*  TestData(name=Asmin, id=1)
*  TestData(name=saurav, id=4)
*  TestData(name=asmin, id=2)
*  TestData(name=Saurav, id=3)
*/


test.sort(Comparator.comparing(TestData::getName,String::compareToIgnoreCase));
test.forEach(data-> System.out.println(data));
/**Sorted Output
* TestData(name=Asmin, id=1)
* TestData(name=asmin, id=2)
* TestData(name=saurav, id=4)
* TestData(name=Saurav, id=3)
*/
}
private static TestData prepareTestData(String name, int id){
TestData testData= new TestData();
testData.setId(id);
testData.setName(name);
return testData;
}
}


@Getter
@Setter
@ToString
class TestData{
private String name;
private int id;
}

小开

使用 stream API 对整数进行排序

arr.stream()
.sorted((item1,item2)-> Integer.compare(item1.price, item2.price))
.forEach(item-> item.show());
//asc
System.out.println("--------------------");
//desc
arr.stream()
.sorted((item1,item2)-> item1.price<item2.price?1:-1)
.forEach(item->item.show());

小开

使用比较器:

List<Type> result = list
.stream()
.sorted(Comparator.comparing(Type::getValue))
.collect(Collectors.toList());