कस्टम सॉर्ट क्रम को परिभाषित करने के लिए मैं तुलनित्र का उपयोग कैसे करूं?

Question

मैं कार सूची के लिए एक सॉर्टिंग डेमो विकसित करना चाहता हूं। मैं कार सूची प्रदर्शित करने के लिए डेटा तालिका का उपयोग कर रहा हूं। अब वास्तव में मैं कार के रंग द्वारा सूची को क्रमबद्ध करना चाहता हूं। यहाँ यह वर्णानुक्रम द्वारा क्रमबद्ध नहीं है। मैं अपने कस्टम छँटाई क्रम का उपयोग करना चाहता हूं जैसे रेड कार पहले आओ, फिर ब्लू, आदि।

कि मैं जावा इस्तेमाल करने की कोशिश के लिए Comparatorऔर Comparableलेकिन यह वर्णमाला क्रम में ही सुलझाने के लिए अनुमति देता है।

तो, क्या कोई भी मुझे तकनीक का उपयोग करने के तरीके को लागू करने के लिए मार्गदर्शन कर सकता है ताकि छंटाई तेजी से हो।

class Car implements Comparable<Car>
{
    private String name;
    private String color;

    public Car(String name, String color){
        this.name = name;
        this.color = color;
    }

    //Implement the natural order for this class
    public int compareTo(Car c) {
        return name.compareTo(c.name);
    }

    static class ColorComparator implements Comparator<Car> {
        public int compare(Car c1, Car c2) {
            String a1 = c1.color;
            String a2 = c2.color;
            return a1.compareTo(a2);
        }
    }

    public static void main(String[] args) {
        List<Car> carList = new ArrayList<>();
        List<String> sortOrder = new ArrayList<>();

        carList.add(new Car("Ford","Silver"));
        carList.add(new Car("Tes","Blue"));
        carList.add(new Car("Honda","Magenta"));

        sortOrder.add("Silver");
        sortOrder.add("Magenta");
        sortOrder.add("Blue");

        // Now here I am confuse how to implement my custom sort             
    }
}

Answer 1

मैं आपको स्ट्रिंग्स का उपयोग करने के बजाय अपनी कार के रंगों के लिए एक एनम बनाने की सलाह देता हूं और एनम का प्राकृतिक क्रम वह क्रम होगा जिसमें आप स्थिरांक की घोषणा करते हैं।

public enum PaintColors {
    SILVER, BLUE, MAGENTA, RED
}

तथा

 static class ColorComparator implements Comparator<CarSort>
 {
     public int compare(CarSort c1, CarSort c2)
     {
         return c1.getColor().compareTo(c2.getColor());
     }
 }

आप String को PaintColor में बदलते हैं और फिर मुख्य रूप से आपकी कार सूची बन जाती है:

carList.add(new CarSort("Ford Figo",PaintColor.SILVER));

...

Collections.sort(carList, new ColorComparator());

Comments

मैं इस उदाहरण को कैसे चलाऊंगा।पेंटकोलर्स ColorComparator.c Access में नहीं है। यदि आप बताएं कि मुख्य विधि कैसी दिखती है।

— दीपक

आउटपुट क्या है? क्या यह हमेशा रजत है?

— दीपक

@ दीपक: हाँ, enumमूल्यों का प्राकृतिक क्रम वह क्रम है जिसमें इसके मूल्यों को परिभाषित किया जाता है।

— जोकिम सॉर

@SeanPatrickFloyd मुझे नहीं लगता है कि एनमों के प्राकृतिक आदेश पर भरोसा करना एक सर्वोत्तम अभ्यास है।

— माइक

@ मायिक मैं असहमत हूं, लेकिन दोनों ही दृष्टिकोणों के लिए मान्य तर्क हैं

— सीन पैट्रिक फ्लोयड

Answer 2

इस बारे में कैसा है:

List<String> definedOrder = // define your custom order
    Arrays.asList("Red", "Green", "Magenta", "Silver");

Comparator<Car> comparator = new Comparator<Car>(){

    @Override
    public int compare(final Car o1, final Car o2){
        // let your comparator look up your car's color in the custom order
        return Integer.valueOf(
            definedOrder.indexOf(o1.getColor()))
            .compareTo(
                Integer.valueOf(
                    definedOrder.indexOf(o2.getColor())));
    }
};

सिद्धांत रूप में, मैं मानता हूं कि a का उपयोग करना एक enumबेहतर तरीका है, लेकिन यह संस्करण अधिक लचीला है क्योंकि यह आपको विभिन्न प्रकार के आदेशों को परिभाषित करने देता है।

अपडेट करें

अमरूद की यह कार्यक्षमता इसके Orderingवर्ग में बेक की गई है :

List<String> colorOrder = ImmutableList.of("red","green","blue","yellow");
final Ordering<String> colorOrdering = Ordering.explicit(colorOrder);
Comparator<Car> comp = new Comparator<Car>() {
    @Override
    public int compare(Car o1, Car o2) {
        return colorOrdering.compare(o1.getColor(),o2.getColor());
    }
}; 

यह संस्करण थोड़ा कम क्रिया है।

---

फिर से अपडेट करें

जावा 8 तुलनित्र को कम क्रिया भी बनाता है:

Comparator<Car> carComparator = Comparator.comparing(
        c -> definedOrder.indexOf(c.getColor()));

Comments

क्या आप कृपया इस प्रश्न पर भी गौर कर सकते हैं। धन्यवाद। stackoverflow.com/questions/61934313/…

— user2048204

Answer 3

लाइन में तुलनित्र ...

List<Object> objList = findObj(name);
Collections.sort(objList, new Comparator<Object>() {
    @Override
    public int compare(Object a1, Object a2) {
        return a1.getType().compareToIgnoreCase(a2.getType());
    }
});

Answer 4

मुझे लगता है कि यह इस प्रकार किया जा सकता है:

class ColorComparator implements Comparator<CarSort>
{
    private List<String> sortOrder;
    public ColorComparator (List<String> sortOrder){
        this.sortOrder = sortOrder;
    }

    public int compare(CarSort c1, CarSort c2)
    {
        String a1 = c1.getColor();
        String a2 = c2.getColor();
        return sortOrder.indexOf(a1) - sortOrder.indexOf(a2);
     }
 }

इसके उपयोग को छाँटने के लिए:

Collections.sort(carList, new ColorComparator(sortOrder));

Answer 5

मुझे सीन और इललेक्स के जवाब के समान कुछ करना था।
लेकिन मेरे पास स्पष्ट रूप से सॉर्ट क्रम को निर्दिष्ट करने के लिए बहुत सारे विकल्प थे और केवल कुछ प्रविष्टियों को सूची के सामने लाने की आवश्यकता थी ... निर्दिष्ट (गैर-प्राकृतिक) क्रम में।
उम्मीद है कि यह किसी और के लिए उपयोगी है।

public class CarComparator implements Comparator<Car> {

    //sort these items in this order to the front of the list 
    private static List<String> ORDER = Arrays.asList("dd", "aa", "cc", "bb");

    public int compare(final Car o1, final Car o2) {
        int result = 0;
        int o1Index = ORDER.indexOf(o1.getName());
        int o2Index = ORDER.indexOf(o2.getName());
        //if neither are found in the order list, then do natural sort
        //if only one is found in the order list, float it above the other
        //if both are found in the order list, then do the index compare
        if (o1Index < 0 && o2Index < 0) result = o1.getName().compareTo(o2.getName());
        else if (o1Index < 0) result = 1;
        else if (o2Index < 0) result = -1;
        else result = o1Index - o2Index;
        return result;
    }

//Testing output: dd,aa,aa,cc,bb,bb,bb,a,aaa,ac,ac,ba,bd,ca,cb,cb,cd,da,db,dc,zz
}

Answer 6

मैं ऐसा कुछ करूंगा:

List<String> order = List.of("Red", "Green", "Magenta", "Silver");

Comparator.comparing(Car::getColor(), Comparator.comparingInt(c -> order.indexOf(c)))

सभी क्रेडिट @ सीन पैट्रिक फ्लॉयड :) जाते हैं

Answer 7

Java 8 में आप कुछ इस तरह से कर सकते हैं:

आपको सबसे पहले एक Enum चाहिए:

public enum Color {
    BLUE, YELLOW, RED
}

कार वर्ग:

public class Car {

    Color color;

    ....

    public Color getColor() {
        return color;
    }

    public void setColor(Color color) {
        this.color = color;
    }
}

और फिर, अपनी कार सूची का उपयोग करके, आप बस कर सकते हैं:

Collections.sort(carList, Comparator:comparing(CarSort::getColor));

Comments

यह एक कस्टम सॉर्ट नहीं है।

— जिग्मंटस

इसके अलावा, यह इसे करने का एक "कार्यात्मक" तरीका नहीं है ... इसका साइड इफेक्ट होता है !!

— त्रिकोणीय

Answer 8

एक Enum प्रकार को परिभाषित करें

public enum Colors {
     BLUE, SILVER, MAGENTA, RED
}

के डेटा प्रकार बदलें colorसे Stringकरने के लिए Colors बदलें वापसी प्रकार और गेटर और सेटर रंग की विधि की तर्क प्रकार केColors

तुलनित्र प्रकार को परिभाषित करें

static class ColorComparator implements Comparator<CarSort>
{
    public int compare(CarSort c1, CarSort c2)
    {
        return c1.getColor().compareTo(c2.getColor());
    }
}

सूची में तत्वों को जोड़ने के बाद, सूची और तुलनित्र वस्तुओं को तर्कों के रूप में संग्रह के प्रकार को कॉल करें

यानी, Collections.sort(carList, new ColorComparator()); फिर प्रिंट करके इस्तेमाल करें ListIterator।

पूर्ण वर्ग कार्यान्वयन इस प्रकार है:

package test;

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

public class CarSort implements Comparable<CarSort>{

    String name;
    Colors color;

    public CarSort(String name, Colors color){
        this.name = name;
        this.color = color;
    } 

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Colors getColor() {
        return color;
    }
    public void setColor(Colors color) {
        this.color = color;
    }

    //Implement the natural order for this class
    public int compareTo(CarSort c)
    {
        return getName().compareTo(c.getName());
    }

    static class ColorComparator implements Comparator<CarSort>
    {
        public int compare(CarSort c1, CarSort c2)
        {
            return c1.getColor().compareTo(c2.getColor());
        }
    }

    public enum Colors {
         BLUE, SILVER, MAGENTA, RED
    }

     public static void main(String[] args)
     {
         List<CarSort> carList = new ArrayList<CarSort>();
         List<String> sortOrder = new ArrayList<String>();

         carList.add(new CarSort("Ford Figo",Colors.SILVER));
         carList.add(new CarSort("Santro",Colors.BLUE));
         carList.add(new CarSort("Honda Jazz",Colors.MAGENTA));
         carList.add(new CarSort("Indigo V2",Colors.RED));
         Collections.sort(carList, new ColorComparator());

         ListIterator<CarSort> itr=carList.listIterator();
         while (itr.hasNext()) {
            CarSort carSort = (CarSort) itr.next();
            System.out.println("Car colors: "+carSort.getColor());
        }
     }
}

Answer 9

बस सरल छोरों का उपयोग करना:

public static void compareSortOrder (List<String> sortOrder, List<String> listToCompare){
        int currentSortingLevel = 0;
        for (int i=0; i<listToCompare.size(); i++){
            System.out.println("Item from list: " + listToCompare.get(i));
            System.out.println("Sorting level: " + sortOrder.get(currentSortingLevel));
            if (listToCompare.get(i).equals(sortOrder.get(currentSortingLevel))){

            } else {
                try{
                    while (!listToCompare.get(i).equals(sortOrder.get(currentSortingLevel)))
                        currentSortingLevel++;
                    System.out.println("Changing sorting level to next value: " + sortOrder.get(currentSortingLevel));
                } catch (ArrayIndexOutOfBoundsException e){

                }

            }
        }
    }

और सूची में क्रमबद्ध करें

public static List<String> ALARMS_LIST = Arrays.asList(
            "CRITICAL",
            "MAJOR",
            "MINOR",
            "WARNING",
            "GOOD",
            "N/A");