Java에서 stream.sorted ()로 목록 정렬

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

그리고 인쇄 방법 :

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

---

이것은 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 메소드를 제공합니다.

목록이 Integers (또는 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);

sorted ()에 인수가 전달되지 않은 경우 Java 8에서 제공하는 기본 비교기 사용 :

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

동일한 목록을 역순으로 정렬하려면 :

integerList.stream (). sorted (Comparator.reverseOrder ()). forEach (System.out :: println); // 역순으로

목록이 사용자 정의 개체 목록 인 경우 :

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 () 메서드 사용 (우리는 comparisonDouble (), compareInt () 메서드도 있습니다) :

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]

Are you sure you are not verifying list instead of sortedList [in above example] i.e. you are storing the result of stream() in a new List object and verifying that object?

---

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


    }
}

**** this is helpful to sort the nested map objects like Map> here i sorted based on the Item object price .

참고URL : https://stackoverflow.com/questions/40517977/sorting-a-list-with-stream-sorted-in-java