2011-03-09 28 views
60

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

इसके लिए मैं जावा तुलनाकर्ता और तुलनीय उपयोग करने का प्रयास करता हूं लेकिन यह केवल वर्णमाला क्रम में क्रमबद्ध करने की अनुमति देता है।

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

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

public class CarSort implements Comparable<CarSort>{ 

    String name; 
    String color; 

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

    public String getName() { 
     return name; 
    } 
    public void setName(String name) { 
     this.name = name; 
    } 
    public String getColor() { 
     return color; 
    } 
    public void setColor(String 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) 
     { 
      String a1 = c1.getColor(); 
      String a2 = c2.getColor(); 
      return a1.compareTo(a2); 
     } 
    } 

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

     carList.add(new CarSort("Ford Figo","Silver")); 
     carList.add(new CarSort("Santro","Blue")); 
     carList.add(new CarSort("Honda Jazz","Magenta")); 
     carList.add(new CarSort("Indigo V2","Red")); 

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

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

उत्तर

86

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

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

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

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

... 

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

मैं कैसे इस example.PaintColors ColorComparator.could में पहुँचा नहीं है चल पाएंगे आप उदाहरण देकर स्पष्ट करना मुख्य विधि कैसा दिखेगा कैसे। – Deepak

+0

आउटपुट क्या है? क्या यह हमेशा पहले सिल्वर है? – Deepak

+0

@ दीपक: हाँ, 'enum' मानों का प्राकृतिक क्रम वह क्रम है जिसमें इसके मान परिभाषित किए गए हैं। –

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

पी एस। मैंने इस कोड को ऐसे ब्राउज़र में लिखा है जो इसे डीबग नहीं करता है। लेकिन अवधारणा स्पष्ट होनी चाहिए।

+0

हाय ilya, धन्यवाद आप ... बहुत आसान और महान तरीका है। – akhtar

35

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

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

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

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

इस संस्करण में थोड़ा कम वर्बोज़ है:

अद्यतन

Guava इस कार्यशीलता अपने Ordering वर्ग में शामिल किया हुआ है।


अद्यतन फिर

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

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

लाइन में तुलनाकारी ...

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

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

public enum Color { 
    BLUE, YELLOW, RED 
} 

कार वर्ग:: आप पहले एक Enum जरूरत

:

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

जावा 8 में आप कुछ इस तरह कर सकते हैं

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

यह एक कस्टम प्रकार नहीं है। – zygimantus

+0

इसके अलावा, यह करने का एक "कार्यात्मक" तरीका नहीं है ... यह पक्ष प्रभावित करता है !! – Programmer

1

Colors

को गेटर और रंग के सेटर विधि के Colors बदलें वापसी प्रकार और तर्क प्रकार के

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

बदलें डेटा String से color के प्रकार के रूप में परिभाषित एक Enum प्रकार तुलनित्र प्रकार परिभाषित इस प्रकार है

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

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

i.e, 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()); 
     } 
    } 
} 
संबंधित मुद्दे