1)You should write two Comparator for sorting on age and name separately, and then use the Collections.sort(List,Comparator). Something like this: class StudentVO { private String name; private int age; public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int … Read more
Java needs to know a type of all variables. In many lambdas it can infer a type, but in your first code snippet, it cannot guess the type of s. I think the standard way to solve that problem would be to declare it explicitly: Comparator<String> c = Comparator.comparing((String s) -> s.split(“\\s+”)[0]) .thenComparingInt(s -> Integer.parseInt(s.split(“\\s+”)[1])); … Read more
Kotlin’s stdlib offers a number of useful helper methods for this. First, you can define a comparator using the compareBy() method and pass it to the sortedWith() extension method to receive a sorted copy of the list: val list: List<Foo> = … val sortedList = list.sortedWith(compareBy({ it.a }, { it.b }, { it.c })) Second, … Read more
This is the right way to compare strings: int studentCompare = this.lastName.compareTo(s.getLastName()); This won’t even compile: if (this.getLastName() < s.getLastName()) Use if (this.getLastName().compareTo(s.getLastName()) < 0) instead. So to compare fist/last name order you need: int d = getFirstName().compareTo(s.getFirstName()); if (d == 0) d = getLastName().compareTo(s.getLastName()); return d;
To make classes comparable, you only need to implement __lt__ and decorate the class with functools.total_ordering. You should also provide an __eq__ method if possible. This provides the rest of the comparison operators so you don’t have to write any of them yourself.
This should work for all classes that extend Number, and are Comparable to themselves. By adding the & Comparable you allow to remove all the type checks and provides runtime type checks and error throwing for free when compared to Sarmun answer. class NumberComparator<T extends Number & Comparable> implements Comparator<T> { public int compare( T … Read more
It’s worth mentioning that the following expression: new Long(10).equals(new Integer(10)) is always false, which tends to trip everyone up at some point or another. So not only can you not compare arbitrary Numbers but you can’t even determine if they’re equal or not. Also, with the real primitive types (float, double), determining if two values … Read more
Guava is more elegant: return ComparisonChain.start() .compare(d1.weight, d2.weight) .compare(d1.age, d2.age) .compare(d1.name, d2.name) .result(); Apache commons-lang has a similar construct, CompareToBuilder.
Use Comparable if you want to define a default (natural) ordering behaviour of the object in question, a common practice is to use a technical or natural (database?) identifier of the object for this. Use Comparator if you want to define an external controllable ordering behaviour, this can override the default ordering behaviour.
You just have to define that Animal implements Comparable<Animal> i.e. public class Animal implements Comparable<Animal>. And then you have to implement the compareTo(Animal other) method that way you like it. @Override public int compareTo(Animal other) { return Integer.compare(this.year_discovered, other.year_discovered); } Using this implementation of compareTo, animals with a higher year_discovered will get ordered higher. I … Read more