Java Comparator.comparing
March 13, 2019
comparing
is the static method of Comparator
functional interface. Comparator.comparing
method has been introduced in Java 8. Comparator.comparing
accepts a Function
that extracts a Comparable
sort key from the given type and returns a Comparator
that compares by that sort key. Comparator.comparing
has two forms.
1.
static <T,U extends Comparable<? super U>> Comparator<T> comparing(Function<? super T,? extends U> keyExtractor)
Function
and it will extract a Comparable
sort key from a type T, and will return a Comparator
that compares by that sort key. Find the sample code.
Comparator<Student> nameComparator = Comparator.comparing(Student::getName);
static <T,U> Comparator<T> comparing(Function<? super T,? extends U> keyExtractor, Comparator<? super U> keyComparator)
Function
and a Comparator
. The method will extract a sort key from a type T, and returns a Comparator
that compares by that sort key using the specified Comparator
. Find the sample code.
Comparator<Student> nameComparator = Comparator.comparing(Student::getName, (s1, s2) -> s2.compareTo(s1));
int
, long
and double
datatype sort keys, Comparator
has comparingInt
, comparingLong
and comparingDouble
methods respectively.
Contents
Comparator.comparing
Here we will provide the examples ofComparator.comparing
method. Find a class that will implement Comparable
interface and define compareTo
method.
School.java
package com.concretepage; public class School implements Comparable<School> { private int code; private String sname; public School(int code, String sname) { this.code = code; this.sname = sname; } public int getCode() { return code; } public String getSname() { return sname; } @Override public int compareTo(School s) { return s.sname.compareTo(sname); } }
School
type.
Student.java
package com.concretepage; import java.util.Arrays; import java.util.List; public class Student { private String name; private int age; private long homeDistance; private double weight; private School school; public Student(String name, int age, long homeDistance, double weight, School school) { this.name = name; this.age = age; this.homeDistance = homeDistance; this.weight = weight; this.school = school; } public String getName() { return name; } public int getAge() { return age; } public long getHomeDistance() { return homeDistance; } public double getWeight() { return weight; } public School getSchool() { return school; } public static List<Student> getStudentList() { Student s1 = new Student("Ram", 18, 3455, 60.75, new School(101, "PQ College")); Student s2 = new Student("Shyam", 22, 3252, 65.80, new School(103, "RS College")); Student s3 = new Student("Mohan", 19, 1459, 65.20, new School(102, "AB College")); Student s4 = new Student("Mahesh", 20, 4450, 70.25, new School(104, "CD College")); List<Student> list = Arrays.asList(s1, s2, s3, s4); return list; } }
Comparator.comparing
method.
ComparingDemo.java
package com.concretepage; import java.util.Collections; import java.util.Comparator; import java.util.List; public class ComparingDemo { public static void main(String[] args) { List<Student> list = Student.getStudentList(); Comparator<Student> schoolComparator1 = Comparator.comparing(Student::getSchool); Collections.sort(list, schoolComparator1); list.forEach(s->System.out.print(s.getName() + "-" + s.getSchool().getSname() + " | ")); System.out.println("\n-------------------"); Comparator<Student> schoolComparator2 = Comparator.comparing(Student::getSchool, (sch1, sch2) -> sch1.getCode() - sch2.getCode()); Collections.sort(list, schoolComparator2); list.forEach(s->System.out.print(s.getName() + "-" + s.getSchool().getCode() + " | ")); System.out.println("\n-------------------"); Comparator<Student> nameComparator1 = Comparator.comparing(Student::getName); Collections.sort(list, nameComparator1); list.forEach(s->System.out.print(s.getName() + " ")); System.out.println("\n-------------------"); Comparator<Student> nameComparator2 = Comparator.comparing(Student::getName, (s1, s2) -> s2.compareTo(s1)); Collections.sort(list, nameComparator2); list.forEach(s->System.out.print(s.getName() + " ")); } }
Shyam-RS College | Ram-PQ College | Mahesh-CD College | Mohan-AB College | ------------------- Ram-101 | Mohan-102 | Shyam-103 | Mahesh-104 | ------------------- Mahesh Mohan Ram Shyam ------------------- Shyam Ram Mohan Mahesh
Collections.sort
. We can also use Stream.sorted
, List.sort
and Arrays.sort
to sort collections using comparator.
Comparator.comparingInt
Find the declaration ofcomparingInt
method.
static <T> Comparator<T> comparingInt(ToIntFunction<? super T> keyExtractor)
int
sort key from a type T, and returns a Comparator
that compares by that sort key. Find the example.
ComparingIntDemo.java
package com.concretepage; import java.util.Collections; import java.util.Comparator; import java.util.List; public class ComparingIntDemo { public static void main(String[] args) { List<Student> list = Student.getStudentList(); Collections.sort(list, Comparator.comparingInt(Student::getAge)); list.forEach(s->System.out.print(s.getAge() + " ")); } }
18 19 20 22
Comparator.comparingLong
Find the declaration ofcomparingLong
method.
static <T> Comparator<T> comparingLong(ToLongFunction<? super T> keyExtractor)
long
sort key from a type T, and returns a Comparator
that compares by that sort key. Find the example.
ComparingLongDemo.java
package com.concretepage; import java.util.Collections; import java.util.Comparator; import java.util.List; public class ComparingLongDemo { public static void main(String[] args) { List<Student> list = Student.getStudentList(); Collections.sort(list, Comparator.comparingLong(Student::getHomeDistance)); list.forEach(s->System.out.print(s.getHomeDistance() + " ")); } }
1459 3252 3455 4450
Comparator.comparingDouble
Find the declaration ofcomparingDouble
method.
static <T> Comparator<T> comparingDouble(ToDoubleFunction<? super T> keyExtractor)
double
sort key from a type T, and returns a Comparator
that compares by that sort key. Find the example.
ComparingDoubleDemo.java
package com.concretepage; import java.util.Collections; import java.util.Comparator; import java.util.List; public class ComparingDoubleDemo { public static void main(String[] args) { List<Student> list = Student.getStudentList(); Collections.sort(list, Comparator.comparingDouble(Student::getWeight)); list.forEach(s->System.out.print(s.getWeight() + " ")); } }
60.75 65.2 65.8 70.25