I&#39;ve got a collection of Duck objects and I&#39;d like to **sort them using multiple keys**.

    class Duck {
        DuckAge age; //implements Comparable
        DuckWeight weight; //implements Comparable
        String name;
    }
    List&lt;Duck&gt; ducks = Pond.getDucks();

eg. I want to sort them **primarily by their weights**, and **secondarily by their age**. If two ducks have the exact same weight and the exact same age, then let&#39;s differentiate them using their **names as a tertiary key**. I might do something like this:

    Collections.sort(ducks, new Comparator&lt;Duck&gt;(){
        @Override
        public int compare(Duck d1, Duck d2){
            int weightCmp = d1.weight.compareTo(d2.weight);
            if (weightCmp != 0) {
                return weightCmp;
            }
            int ageCmp = d1.age.compareTo(d2.age);
            if (ageCmp != 0) {
                return ageCmp;
            }
            return d1.name.compareTo(d2.name);
        }
    });

Well I do this quite frequently, but this solution doesn&#39;t smell right. It doesn&#39;t scale well, and it&#39;s easy to mess up. Surely there must be a better way of sorting Ducks using multiple keys! Does anybody know of a better solution?

**EDIT** removed unnecessary `else` branches

Sorting Java objects using multiple keys

I read about sorting ArrayLists using a Comparator but in all of the examples people used `compareTo` which according to some research is a method for Strings.

I wanted to sort an ArrayList of custom objects by one of their properties: a Date object
(`getStartDay()`). Normally I compare them by `item1.getStartDate().before(item2.getStartDate())` so I was wondering whether I could write something like:

    public class CustomComparator {
        public boolean compare(Object object1, Object object2) {
            return object1.getStartDate().before(object2.getStartDate());
        }
    }
    
    public class RandomName {
        ...
        Collections.sort(Database.arrayList, new CustomComparator);
        ...
    }



Sort ArrayList of custom Objects by property

I want to sort a list with Lambda:

    List&lt;Message&gt; messagesByDeviceType = new ArrayList&lt;Message&gt;();  	
    messagesByDeviceType.sort((Message o1, Message o2)-&gt;o1.getTime()-o2.getTime());

But I got this compilation error:

     Multiple markers at this line
    	- Type mismatch: cannot convert from long to int
    	- The method sort(Comparator&lt;? super Message&gt;) in the type List&lt;Message&gt; is not applicable for the arguments ((Message o1, Message o2) 
    	 -&gt; {})


Java 8 Lambda: Comparator

I had a program crash because of bad data stored in a database recently.  This confused me, because I thought I had a catch to prevent this.

The intent of the following code is to compare employee badge numbers and sort them.  If there&#39;s an error, return -1 and soldier on -- don&#39;t stop because one of several thousand badge numbers is wrong:

    public int compare(Employee t, Employee t1) {
        Integer returnValue = -1;
        try {
            Integer tb = Integer.parseInt(t.getBadgeNumber());
            Integer t1b = Integer.parseInt(t1.getBadgeNumber());
            returnValue = tb.compareTo(t1b);
        } catch (Exception e) {
            returnValue = -1;//useless statement, I know.
        }
        return returnValue;
    }

When the bad badge number hit (as t in this case), I got an &quot;java.lang.IllegalArgumentException: Comparison method violates its general contract!&quot; error instead of returning the -1 in the catch.

What don&#39;t I understand about the catch here?

The full stacktrace:

    16-May-2018 14:28:53.496 SEVERE [http-nio-8084-exec-601] org.apache.catalina.core.StandardWrapperValve.invoke Servlet.service() for servlet [RequestServlet] in context with path [/AppearanceRequest] threw exception
     java.lang.IllegalArgumentException: Comparison method violates its general contract!
	at java.util.TimSort.mergeHi(TimSort.java:868)
	at java.util.TimSort.mergeAt(TimSort.java:485)
	at java.util.TimSort.mergeForceCollapse(TimSort.java:426)
	at java.util.TimSort.sort(TimSort.java:223)
	at java.util.TimSort.sort(TimSort.java:173)
	at java.util.Arrays.sort(Arrays.java:659)
	at java.util.Collections.sort(Collections.java:217)
	at org.bcso.com.appearancerequest.html.NotifierHTML.getHTML(NotifierHTML.java:363)
	at org.bcso.com.appearancerequest.AppearanceRequestServlet.processRequest(AppearanceRequestServlet.java:96)
	at org.bcso.com.appearancerequest.AppearanceRequestServlet.doGet(AppearanceRequestServlet.java:565)
	at javax.servlet.http.HttpServlet.service(HttpServlet.java:618)
	at javax.servlet.http.HttpServlet.service(HttpServlet.java:725)
	at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:301)
	at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:206)
	at org.apache.tomcat.websocket.server.WsFilter.doFilter(WsFilter.java:52)
	at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:239)
	at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:206)
	at org.netbeans.modules.web.monitor.server.MonitorFilter.doFilter(MonitorFilter.java:393)
	at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:239)
	at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:206)
	at org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperValve.java:219)
	at org.apache.catalina.core.StandardContextValve.invoke(StandardContextValve.java:106)
	at org.apache.catalina.authenticator.AuthenticatorBase.invoke(AuthenticatorBase.java:503)
	at org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.java:136)
	at org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:74)
	at org.apache.catalina.valves.AbstractAccessLogValve.invoke(AbstractAccessLogValve.java:610)
	at org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineValve.java:88)
	at org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:516)
	at org.apache.coyote.http11.AbstractHttp11Processor.process(AbstractHttp11Processor.java:1015)
	at org.apache.coyote.AbstractProtocol$AbstractConnectionHandler.process(AbstractProtocol.java:652)
	at org.apache.coyote.http11.Http11NioProtocol$Http11ConnectionHandler.process(Http11NioProtocol.java:222)
	at org.apache.tomcat.util.net.NioEndpoint$SocketProcessor.doRun(NioEndpoint.java:1575)
	at org.apache.tomcat.util.net.NioEndpoint$SocketProcessor.run(NioEndpoint.java:1533)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1145)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)
	at java.lang.Thread.run(Thread.java:745)

The calling code:

        List&lt;Employee&gt; employeeList = DatabaseUtil.getEmployees();
        Collections.sort(employeeList, new BadgeComparator());



When catch doesn&#39;t actually catch anything

I would like to sort and binary search a static array of strings via the String.CompareTo comparator.

The problem is that both sorting, and binary searching requires that a Comparator object be passed in -- So how do I pass in the built in string comparator?

Java get String CompareTo as a comparator object

So I&#39;m working with a few pre-existing comparators that compare certain values in two tuples and return true if the first is greater than the second, false if otherwise. Here&#39;s the code for one of them:

    def cmpValue(subInfo1, subInfo2):
        &quot;&quot;&quot;
        Returns True if value in (value, work) tuple subInfo1 is GREATER than
        value in (value, work) tuple in subInfo2
        &quot;&quot;&quot;
        # TODO...
        if subInfo1[0] &gt; subInfo2[0]:
            return True
        else:
            return False


Now, I have a dictionary that has numerous tuple entries of the type being compared above. I want to sort them all in reverse order, but I don&#39;t really understand how I would accomplish that. I was thinking something like:

    sortedDict = sorted(subjects, key=comparator, reverse = True)

But I don&#39;t know what to pass into the comparator because each comparator takes two arguments (subInfo1, subInfo2). *I cannot change the comparator functions.*



Using a comparator function to sort

Can someone explain me in simple terms, why does this code throw an exception, &quot;Comparison method violates its general contract!&quot;, and how do I fix it?

    private int compareParents(Foo s1, Foo s2) {
    	if (s1.getParent() == s2) return -1;
    	if (s2.getParent() == s1) return 1;
    	return 0;
    }

&quot;Comparison method violates its general contract!&quot;

I learned how to use the comparable but I&#39;m having difficulty with the Comparator. I am having a error in my code: 

    Exception in thread &quot;main&quot; java.lang.ClassCastException: New.People cannot be cast to java.lang.Comparable
     at java.util.Arrays.mergeSort(Unknown Source)
     at java.util.Arrays.sort(Unknown Source)
     at java.util.Collections.sort(Unknown Source)
     at New.TestPeople.main(TestPeople.java:18)

Here is my code:

    import java.util.Comparator;

    public class People implements Comparator {
       private int id;
       private String info;
       private double price;
     
       public People(int newid, String newinfo, double newprice) {
           setid(newid);
           setinfo(newinfo);
           setprice(newprice);
       }
     
       public int getid() {
           return id;
       }
    
       public void setid(int id) {
           this.id = id;
       }
    
       public String getinfo() {
           return info;
       }
    
       public void setinfo(String info) {
           this.info = info;
       }
    
       public double getprice() {
           return price;
       }
    
       public void setprice(double price) {
           this.price = price;
       }
    
       public int compare(Object obj1, Object obj2) {
           Integer p1 = ((People) obj1).getid();
           Integer p2 = ((People) obj2).getid();
      
           if (p1 &gt; p2) {
               return 1;
           } else if (p1 &lt; p2){
               return -1;
           } else {
               return 0;
           }
        }
    }

&lt;!-- language: lang-java --&gt;

    import java.util.ArrayList;
    import java.util.Collections;

    public class TestPeople {
        public static void main(String[] args) {
            ArrayList peps = new ArrayList();
      
            peps.add(new People(123, &quot;M&quot;, 14.25));
            peps.add(new People(234, &quot;M&quot;, 6.21));
            peps.add(new People(362, &quot;F&quot;, 9.23));
            peps.add(new People(111, &quot;M&quot;, 65.99));
            peps.add(new People(535, &quot;F&quot;, 9.23));
      
            Collections.sort(peps);
      
            for (int i = 0; i &lt; peps.size(); i++){
                System.out.println(peps.get(i));
            }
        }
    }

I believe it has to do something with the casting in the compare method but I was playing around with it and still could not find the solution

How to use Comparator in Java to sort

&gt; **Possible Duplicates:**  
&gt; [difference between compare() and compareTo()](https://stackoverflow.com/questions/420223/difference-between-compare-and-compareto)  
&gt; [Java: What is the difference between implementing Comparable and Comparator?](https://stackoverflow.com/questions/1440134/java-what-is-the-difference-between-implementing-comparable-and-comparator)  

&lt;!-- End of automatically inserted text --&gt;

What are the keys differences between Comparable and Comparator.  

and which is preferred over the other in what scenarios?  

Thanks

**Updated - GOOD LINK WITH EXAMPLE!!**

http://www.digizol.com/2008/07/java-sorting-comparator-vs-comparable.html

Java : Comparable vs Comparator

I have seen classes which implement both **Comparable** and **Comparator**.  What does this mean?  Why would I use one over the other?

When should a class be Comparable and/or Comparator?

I have a list with some User objects and i&#39;m trying to sort the list, but only works using method reference, with lambda expression the compiler gives an error:

    List&lt;User&gt; userList = Arrays.asList(u1, u2, u3);
    userList.sort(Comparator.comparing(u -&gt; u.getName())); // works
    userList.sort(Comparator.comparing(User::getName).reversed()); // works
    userList.sort(Comparator.comparing(u -&gt; u.getName()).reversed()); // Compiler error

Error:

    com\java8\collectionapi\CollectionTest.java:35: error: cannot find symbol
                userList.sort(Comparator.comparing(u -&gt; u.getName()).reversed());
                                                         ^
    symbol:   method getName()
    location: variable u of type Object
    1 error

Comparator.reversed() does not compile using lambda

Im trying to sort through an arraylist of objects by a particular value within the object. What would be the best approach to do such a thing. Should I use Collections.sort() with some kind of comparator? 

Im trying to sort a list of objects by a float value they hold in one of the variables.


EDIT:
This is what I have so far:

    public class CustomComparator implements Comparator&lt;Marker&gt; {
	    @Override
	    public int compare(Mark o1, Mark o2) {
	        return o1.getDistance().compareTo(o2.getDistance());
	    }
	}

the error states: Cannot invoke compareTo(double) on the primitive type double.

Is it because a comparator cant return anything other than a certain type?


Android-java- How to sort a list of objects by a certain value within the object

I have a list of objects I need to sort on a field, say Score. Without giving much thought I wrote a new class that implements Comparator&lt;Object&gt;, that does the task and it works. 

Now looking back at this, I am wondering if I should have instead have the my class implement Comparable instead of creating a new class that implements Comparator. The score is the only field that the objects will be ordered on. 

1. What I have done acceptable as a practice? 

2. Is the right approach &quot;First have the class implement Comparable (for the natural ordering) and if an alternative field comparison is required, then create a new class that implements Comparator&quot; ?

3. If (2) above is true, then does it mean that one should implement Comparator only after they have the class implement Comparable? (Assuming I own the original class).


When to use Comparable and Comparator

How does the following code sort this array to be in numerical order?     

    var array=[25, 8, 7, 41]

    array.sort(function(a,b){
      return a - b
    })

I know that if the result of the computation is... 

**Less than 0**: &quot;a&quot; is sorted to be a lower index than &quot;b&quot;.&lt;br /&gt;
**Zero:** &quot;a&quot; and &quot;b&quot; are considered equal, and no sorting is performed.&lt;br /&gt;
**Greater than 0:** &quot;b&quot; is sorted to be a lower index than &quot;a&quot;.&lt;br /&gt;

Is the array sort callback function called many times during the course of the sort?

If so, I&#39;d like to know which two numbers are passed into the function each time. I assumed it first took &quot;25&quot;(a) and &quot;8&quot;(b), followed by &quot;7&quot;(a) and &quot;41&quot;(b), so:

25(a) - 8(b) = 17 (greater than zero, so sort &quot;b&quot; to be a lower index than &quot;a&quot;): 8, 25

7(a) - 41(b) = -34 (less than zero, so sort &quot;a&quot; to be a lower index than &quot;b&quot;: 7, 41

How are the two sets of numbers then sorted in relation to one another?

Please help a struggling newbie!



How does Javascript&#39;s sort() work?

I have an ArrayList and want sort it in descending order. I use for it `java.util.stream.Stream.sorted(Comparator)` method. Here is a description according Java API:

&gt; Returns a stream consisting of the elements of this stream, sorted according to the provided `Comparator`.

this methods return me a sort with ascending order. Which parameter should I change, just to have the descending order? 

Reverse a comparator in Java 8

I saw many questions about this, and tried to solve the problem, but after one hour of googling and a lots of trial &amp; error, I still can&#39;t fix it. I hope some of you catch the problem.

This is what I get:

&lt;!-- language: none --&gt;

    java.lang.IllegalArgumentException: Comparison method violates its general contract!
    	at java.util.ComparableTimSort.mergeHi(ComparableTimSort.java:835)
    	at java.util.ComparableTimSort.mergeAt(ComparableTimSort.java:453)
    	at java.util.ComparableTimSort.mergeForceCollapse(ComparableTimSort.java:392)
    	at java.util.ComparableTimSort.sort(ComparableTimSort.java:191)
    	at java.util.ComparableTimSort.sort(ComparableTimSort.java:146)
    	at java.util.Arrays.sort(Arrays.java:472)
    	at java.util.Collections.sort(Collections.java:155)
        ...

And this is my comparator:

    @Override
    public int compareTo(Object o) {
        if(this == o){
            return 0;
        }
        
        CollectionItem item = (CollectionItem) o;

        Card card1 = CardCache.getInstance().getCard(cardId);
        Card card2 = CardCache.getInstance().getCard(item.getCardId());

        if (card1.getSet() &lt; card2.getSet()) {
            return -1;
        } else {
            if (card1.getSet() == card2.getSet()) {
                if (card1.getRarity() &lt; card2.getRarity()) {
                    return 1;
                } else {
                    if (card1.getId() == card2.getId()) {
                        if (cardType &gt; item.getCardType()) {
                            return 1;
                        } else {
                            if (cardType == item.getCardType()) {
                                return 0;
                            }
                            return -1;
                        }
                    }
                    return -1;
                }
            }
            return 1;
        }
    }

Any idea?

Java error: Comparison method violates its general contract

I&#39;ve been looking at the difference between `Collections.sort` and `list.sort`, specifically regarding using the `Comparator` static methods and whether param types are required in the lambda expressions. Before we start, I know I could use method references, e.g. `Song::getTitle` to overcome my problems, but my query here is not so much something I want to fix but something I want an answer to, i.e. why is the Java compiler handling it in this way. 

These are my finding. Suppose we have an `ArrayList` of type `Song`, with some songs added, there are 3 standard get methods:

        ArrayList&lt;Song&gt; playlist1 = new ArrayList&lt;Song&gt;();

        //add some new Song objects
        playlist.addSong( new Song(&quot;Only Girl (In The World)&quot;, 235, &quot;Rhianna&quot;) );
        playlist.addSong( new Song(&quot;Thinking of Me&quot;, 206, &quot;Olly Murs&quot;) );
        playlist.addSong( new Song(&quot;Raise Your Glass&quot;, 202,&quot;P!nk&quot;) );

Here is a call to both types of sort method that works, no problem:

    Collections.sort(playlist1, 
        		Comparator.comparing(p1 -&gt; p1.getTitle()));

    playlist1.sort(
        		Comparator.comparing(p1 -&gt; p1.getTitle()));


As soon as I start to chain `thenComparing`, the following happens:

    Collections.sort(playlist1,
        		Comparator.comparing(p1 -&gt; p1.getTitle())
        		.thenComparing(p1 -&gt; p1.getDuration())
        		.thenComparing(p1 -&gt; p1.getArtist())
    			);
    	
    playlist1.sort(
    		Comparator.comparing(p1 -&gt; p1.getTitle())
        	.thenComparing(p1 -&gt; p1.getDuration())
        	.thenComparing(p1 -&gt; p1.getArtist())
    		);

i.e. syntax errors because it does not know the type of `p1` anymore. So to fix this I add the type `Song` to the first parameter (of comparing):


    Collections.sort(playlist1,
        		Comparator.comparing((Song p1) -&gt; p1.getTitle())
        		.thenComparing(p1 -&gt; p1.getDuration())
        		.thenComparing(p1 -&gt; p1.getArtist())
    			);
    	
    playlist1.sort(
    		Comparator.comparing((Song p1) -&gt; p1.getTitle())
        	.thenComparing(p1 -&gt; p1.getDuration())
        	.thenComparing(p1 -&gt; p1.getArtist())
    		);

Now here comes the CONFUSING part. For p`laylist1.sort`, i.e. the List, this solve all compilation errors, for both the following `thenComparing` calls. However, for `Collections.sort`, it solves it for the first one, but not the last one. I tested added several extra calls to `thenComparing` and it always shows an error for the last one, unless I put `(Song p1)` for the parameter.

Now I went on to test this further with creating a `TreeSet` and with using `Objects.compare`:

    int x = Objects.compare(t1, t2, 
    				Comparator.comparing((Song p1) -&gt; p1.getTitle())
    				.thenComparing(p1 -&gt; p1.getDuration())
    				.thenComparing(p1 -&gt; p1.getArtist())
    				);
    	
    	
		Set&lt;Song&gt; set = new TreeSet&lt;Song&gt;(
    			Comparator.comparing((Song p1) -&gt; p1.getTitle())
				.thenComparing(p1 -&gt; p1.getDuration())
				.thenComparing(p1 -&gt; p1.getArtist())
				);

The same thing happens as in, for the `TreeSet`, there are no compilation errors but for `Objects.compare` the last call to `thenComparing` shows an error.

Can anyone please explain why this is happening and also why there is no need to use `(Song p1)` at all when simply calling the comparing method (without further `thenComparing` calls).


One other query on the same topic is when I do this to the `TreeSet`:

    Set&lt;Song&gt; set = new TreeSet&lt;Song&gt;(
    			Comparator.comparing(p1 -&gt; p1.getTitle())
				.thenComparing(p1 -&gt; p1.getDuration())
				.thenComparing(p1 -&gt; p1.getArtist())
				);

i.e. remove the type `Song` from the first lambda parameter for the comparing method call, it shows syntax errors under the call to comparing and the first call to `thenComparing` but not to the final call to `thenComparing` - almost the opposite of what was happening above! Whereas, for all the other 3 examples i.e. with `Objects.compare`, `List.sort` and `Collections.sort` when I remove that first `Song` param type it shows syntax errors for all the calls.

Many thanks in advance.

Edited to include screenshot of errors I was receiving in Eclipse Kepler SR2, which I have now since found are Eclipse specific because when compiled using the JDK8 java compiler on the command-line it compiles OK. 

![Sort errors in Eclipse][1]


  [1]: http://i.stack.imgur.com/cPEfH.jpg

Very confused by Java 8 Comparator type inference

Is there a build-in possibility to create a null-safe mapping comparator in Java 8 without writing a own implementation of `Comparator`?

When running the following code, it causes a NPE because the `keyExtractor` argument of `Comparator.comparing()` may return a `null` value:

    public class ToSort
    {
    
        private String sortBy;
    
        public ToSort(String sortBy)
        {
            this.sortBy = sortBy;
        }
    
        public String getSortBy()
        {
            return sortBy;
        }
    
        public static void main(String[] args)
        {
            // mapping comparator
            Comparator&lt;ToSort&gt; comp = Comparator.comparing(ToSort::getSortBy);                          
            SortedSet&lt;ToSort&gt; set = new TreeSet&lt;&gt;(comp);
            ToSort o1 = new ToSort(&quot;1&quot;);
            ToSort o2 = new ToSort(null);
            
            set.add(o1);
            
            System.out.println(set.contains(o2)); //NPE because o2.getSortBy() == null
            
        }
    }

&gt; Exception in thread &quot;main&quot; java.lang.NullPointerException
	at java.util.Comparator.lambda$comparing$77a9974f$1(Comparator.java:469)
	at java.util.Comparator$$Lambda$2/1480010240.compare(Unknown Source)
	at java.util.Comparators$NullComparator.compare(Comparators.java:83)
	at java.util.TreeMap.getEntryUsingComparator(TreeMap.java:376)
	at java.util.TreeMap.getEntry(TreeMap.java:345)
	at java.util.TreeMap.containsKey(TreeMap.java:232)
	at java.util.TreeSet.contains(TreeSet.java:234)
	at test.ToSort.main(ToSort.java:48)

Using 

    Comparator&lt;ToSort&gt; comp = Comparator.nullsFirst(Comparator.comparing(ToSort::getSortBy));

does not work either as only `ToSort` objects that are `null` are treaded properly.

I know how to write my own `Comparator` implementation, I`m just searching a more &quot;elegant&quot; solution like

    Comparator.comparingNullsFirst(ToSort::getSortBy)

null-safe mapping Comparator using default implementations

I&#39;d like some kind of string comparison function that preserves natural sort order&lt;sup&gt;1&lt;/sup&gt;.  Is there anything like this built into Java?  I can&#39;t find anything in the &lt;a href=&quot;http://java.sun.com/javase/6/docs/api/java/lang/String.html&quot;&gt;String class&lt;/a&gt;, and the &lt;a href=&quot;http://java.sun.com/javase/6/docs/api/java/util/Comparator.html&quot;&gt;Comparator class&lt;/a&gt; only knows of two implementations.

I can roll my own (it&#39;s not a very hard problem), but I&#39;d rather not re-invent the wheel if I don&#39;t have to.

&lt;i&gt;In my specific case, I have software version strings that I want to sort.  So I want &quot;1.2.10.5&quot; to be considered greater than &quot;1.2.9.1&quot;.&lt;/i&gt;

------

&lt;sup&gt;1&lt;/sup&gt; By &quot;natural&quot; sort order, I mean it compares strings the way a human would compare them, as opposed to &quot;ascii-betical&quot; sort ordering that only makes sense to programmers.  In other words, &quot;image9.jpg&quot; is less than &quot;image10.jpg&quot;, and &quot;album1set2page9photo1.jpg&quot; is less than &quot;album1set2page10photo5.jpg&quot;, and &quot;1.2.9.1&quot; is less than &quot;1.2.10.5&quot;

Natural sort order string comparison in Java - is one built in?

We have some code which sorts a list of addresses based on the distance between their coordinates. this is done through collections.sort with a custom comparator.

However from time to time an address without coordinates is in the list causing a NullPointerException. My initial idea to fix this was to have the comparator return 0 as distance for addresses where at least one of the coordinates is null. I fear this might lead to corruption of the order the &#39;valid&#39; elements in the list.

so is returning a &#39;0&#39; values for null data in a comparator ok, or is there a cleaner way to resolve this?

comparator with null values

I need a comparator as part of a strategy pattern that can either use the natural ordering of the objects or some custom ordering. For the natural ordering case, I wrote a simple comparator:

    private static class NaturalComparator&lt;T extends Comparable&lt;? super T&gt;&gt; implements Comparator&lt;T&gt; {
        @Override
        public int compare(T o1, T o2) {
            return o1.compareTo(o2);
        }
    }

Seems simple enough, but I was wondering if anyone knew of one in the standard API. I looked at TreeMap, and it does it without such a class, so when that code was written, the apparent answer would be no, but perhaps it was added later.

Does a natural comparator exist in the standard api?

I have written the following code:

    public class NewClass2 implements Comparator&lt;Point&gt;
    {
        public int compare(Point p1, Point p2)
        {
            return (int)(p1.getY() - p2.getY());
        }
    }

If I let&#39;s say have two double numbers, `3.2 - 3.1`, the difference should be `0.1`. When I cast the number to an int, however, the difference ends up as `0`, which is not correct.

I therefore need `compare()` to return a double, not an int. The problem is, my `getX` field is a double. How can I solve this problem?

All Comparator Solutions on Gang of Coders

Total of 22 Comparator Solutions