这与Collections.sort()不同，在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* 返回 * 排序的数据，它没有像你期望的那样排序。

Java 8提供了不同的实用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);

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

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

使用Comparator.comparingLong（）方法（我们也有comparingDouble（），comparingInt（）方法）：

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

使用Comparator.comparing（）方法（根据提供的getter方法进行比较的泛型方法）：

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

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

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<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（在上面的例子中），即你是在一个新的List对象中存储stream()的结果并验证该对象吗？

使用streamAPI对Integer进行排序

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<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 version 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;
}

使用比较器：

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

编辑：JDK 16+

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

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对象价格进行排序。