Java में stream.sorted () के साथ एक सूची को सॉर्ट करना

Question

मुझे एक स्ट्रीम से एक सूची को छाँटने में दिलचस्पी है। यह वह कोड है जिसका मैं उपयोग कर रहा हूं:

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

Answer 1

यह ऐसा नहीं है Collections.sort()जहां पैरामीटर संदर्भ सॉर्ट हो जाता है। इस मामले में आपको बस एक क्रमबद्ध स्ट्रीम मिलती है जिसे आपको अंततः किसी अन्य चर को इकट्ठा करने और असाइन करने की आवश्यकता होती है:

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

आप केवल परिणाम आवंटित करने से चूक गए हैं

Answer 2

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

Comments

list.sort(Comparator.comparing(o -> o.getItem().getValue()));मेरे लिए नया था। महान!

— न्यूरॉन

Answer 3

जावा 8 धाराओं को बेहतर तरीके से छांटने में हमारी मदद करने के लिए अलग-अलग यूटिलिटी एपि तरीके प्रदान करता है।

यदि आपकी सूची पूर्णांक (या डबल, लंबी, स्ट्रिंग आदि) की सूची है, तो आप बस जावा द्वारा प्रदान किए गए डिफ़ॉल्ट तुलनित्र के साथ सूची को सॉर्ट कर सकते हैं।

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

मक्खी पर तुलनित्र बनाना:

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

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

Comparator.comparingLong () विधि का उपयोग करना (हमारे पास तुलना करना दोगुना है), (तुलना करना) () विधियाँ भी:

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

Comparator.comparing () विधि (सामान्य विधि जो गेटर विधि के आधार पर तुलना करती है) का उपयोग करना:

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

हम तब भी कर सकते हैं chaining का उपयोग करते हुए तब () विधि:

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

Comments

मुझे ऐसा लगता है कि यह उत्तर प्रश्न के लिए बहुत विस्तृत है, और फिर भी प्रश्न को संबोधित नहीं करता है। इस उत्तर का उपयोग स्व-उत्तरित प्रश्न / ए के बजाय करने पर विचार करें।

— नदी

मुझे यह भी लगता है कि यह सबसे अच्छा और सही उत्तर है। का उपयोग Comparator.comparing*करना बेहतर तरीका है और अधिक से अधिक JDK8 उन्मुख दृष्टिकोण

— काकबाली

Answer 4

यह ठीक काम करने लगता है:

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]

क्या आप सुनिश्चित हैं कि आप sortedList[ऊपर के उदाहरण में] के बजाय सूची को सत्यापित नहीं कर रहे हैं अर्थात आप stream()एक नई Listवस्तु के परिणाम को संग्रहीत कर रहे हैं और इस वस्तु को सत्यापित कर रहे हैं?

Answer 5

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


    }
}

**** यह नेस्टेड मैप ऑब्जेक्ट्स को मैप करने में मददगार है। यहां पर मैंने आइटम ऑब्जेक्ट प्राइस के आधार पर सॉर्ट किया है।

Answer 6

यह एक सरल उदाहरण है:

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

यह संभव हो सकता है कि कोड को संकलित करने के लिए आपके आईडीई को jdk 1.8 या ऊपरी संस्करण नहीं मिल रहा है।

जावा संस्करण 1.8 को Your_Project > गुण> प्रोजेक्ट पहलुओं> जावा संस्करण 1.8 के लिए सेट करें