在Java中使用stream.sorted（）对列表进行排序

我对从流中排序列表感兴趣。这是我正在使用的代码：

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

我错过什么了吗？列表未排序

它应该根据具有最低值的项目对列表进行排序

for (int i = 0; i < list.size(); i++)
{
   System.out.println("list " + (i+1));
   print(list, i);
}

for（int i=0；i

以及打印方法：

public static void print(List<List> list, int i)
{
    System.out.println(list.get(i).getItem().getValue());
}

公共静态无效打印（列表，int i）
{
System.out.println（list.get（i.getItem（）.getValue（））；
}

它似乎工作正常：

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

---

您确定您不是在验证列表而不是

sortedList

[在上面的示例中]，即您正在将

stream（）

的结果存储在一个新的

list

对象中并验证该对象吗？

这与

Collections.sort（）

中的参数引用被排序不同。在这种情况下，您只需获得一个排序流，最终需要收集并分配给另一个变量：

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

您刚刚错过了分配结果

请改用：

并通过以下方式使其更加简洁：

在这两者之后，

列表

本身将被排序

你的问题是 返回已排序的数据，但它没有按预期进行排序。

Collection itemCollection=basket.values（）；
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());


    }
}

迭代器Iterator=itemCollection.stream（）.sorted（新的TestComparator（））.collect（Collectors.toList（））.Iterator（）；
包com.ie.util；
导入com.ie.item.item；
导入java.util.Comparator；
导入java.util.Iterator；
导入java.util.Map；
导入java.util.Set；
公共类TestComparator实现了Comparator{
//比较器用于根据价格对项目进行排序
@凌驾
公共整数比较（映射o1，映射o2）{
//System.out.println（“***比较方法将被调用******”）；
item1=null；
item2=null；
Set itemSet1=o1.keySet（）；
迭代器iterator1=itemSet1.Iterator（）；
if（itemIterator1.hasNext（））{
item1=itemIterator1.next（）；
}
Set itemSet2=o2.keySet（）；
迭代器iterator2=itemSet2.Iterator（）；
if（itemIterator2.hasNext（））{
item2=itemIterator2.next（）；
}
return-item1.getPrice（）.compareTo（item2.getPrice（））；
}
}

---

****这有助于对嵌套的map对象进行排序，如map>，这里我根据项目对象价格进行了排序。

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

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

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

当没有参数传递给sorted（）时，使用java 8提供的默认比较器：

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

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

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

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.

如果要按相反顺序对同一列表排序：

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

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

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

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.

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

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

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

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

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.

使用Comparator.comparingLong（）方法（我们还有comparingDouble（）和comparingInt（）方法）：

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

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

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

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.

使用Comparator.comparing（）方法（基于提供的getter方法进行比较的通用方法）：

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

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

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

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.

我们也可以使用比较（）方法进行链接：

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

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

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

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

List citiesName=Arrays.asList（“德里”、“孟买”、“钦奈”、“班格罗尔”、“加尔各答”）；
System.out.println（“城市：+citiesName”）；
List sortedByName=citiesName.stream（）
.已排序（（s1，s2）->s2.与（s1）比较）
.collect（Collectors.toList（））；
System.out.println（“按名称排序：+sortedByName”）；

您的IDE可能没有获得JDK1.8或更高版本来编译代码

为您的_项目设置Java版本1.8>属性>项目方面>Java版本1.8

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

导入lombok.Getter；
进口龙目织机；
进口龙目草；
导入java.util.ArrayList；
导入java.util.Comparator；
导入java.util.List；
公共类分拣服务{
公共静态void main（字符串[]args）{
列表测试=新建ArrayList（）；
添加（准备测试数据（“Asmin”，1））；
测试。添加（准备测试数据（“saurav”，4））；
添加（准备测试数据（“asmin”，2））；
测试。添加（准备测试数据（“Saurav”，3））；
test.forEach（数据->系统输出.println（数据））；
/**输出
*TestData（name=Asmin，id=1）
*TestData（name=saurav，id=4）
*TestData（name=asmin，id=2）
*TestData（name=Saurav，id=3）
*/
sort（Comparator.comparing（TestData:：getName，String:：compareToIgnoreCase））；
test.forEach（数据->系统输出.println（数据））；
/**排序输出
*TestData（name=Asmin，id=1）
*TestData（name=asmin，id=2）
*TestData（name=saurav，id=4）
*TestData（name=Saurav，id=3）
*/
}
私有静态测试数据prepareTestData（字符串名称，int-id）{
TestData TestData=新的TestData（）；
testData.setId（id）；
testData.setName（name）；
返回测试数据；
}
}
@吸气剂
@塞特
@托斯特林
类测试数据{
私有字符串名称；
私有int-id；
}

使用streamAPI对整数排序

arr.stream（）
.sorted（（item1，item2）->Integer.compare（item1.price，item2.price））
.forEach（项目->项目.show（））；
//asc
System.out.println（“------------------”）；
//描述
arr.stream（）
.sorted（（item1，item2）->item1.priceitem.show（））；

list.sort（Comparator.comparing（o->o.getItem（）.getValue（））对我来说是新的。伟大的我觉得这个答案对于这个问题来说太详细了，但根本没有解决这个问题。在自答的Q/A中使用这个答案。我也觉得这是最好和正确的答案。使用
Comparator.comparating*
是更好、更面向JDK8的方法