Skip to content

Commit f9940fc

Browse files
author
JavaProgramTo.com
committed
Java Comparator Lambda Examples
1 parent 73fe60b commit f9940fc

File tree

7 files changed

+411
-23
lines changed

7 files changed

+411
-23
lines changed

‎src/main/java/com/javaprogramto/java8/comparator/ComparatorExample3.java‎

Lines changed: 4 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,7 @@
55
import java.util.Comparator;
66
import java.util.List;
77

8-
public class ComparatorExample2 {
8+
public class ComparatorExample3 {
99

1010
public static void main(String[] args) {
1111

@@ -21,7 +21,9 @@ public static void main(String[] args) {
2121
teachers.forEach(teacher -> System.out.println("Teacher name - " + teacher.getName() + ", subject - "
2222
+ teacher.getSubject() + ", exp - " + teacher.getExperience()));
2323

24-
Collections.sort(teachers, new SubjectExperienceComparator());
24+
Comparator<Teacher> subjectComparator = (t1, t2) -> t1.getSubject().compareTo(t2.getSubject());
25+
26+
Collections.sort(teachers, subjectComparator);
2527

2628
System.out.println("\nTeachers object before sorting");
2729
teachers.forEach(teacher -> System.out.println("Teacher name - " + teacher.getName() + ", subject - "
@@ -30,18 +32,3 @@ public static void main(String[] args) {
3032
}
3133

3234
}
33-
34-
// Custom comparator to sort Teacher objects by subject they teach and their experience level
35-
class SubjectExperienceComparator implements Comparator<Teacher> {
36-
37-
@Override
38-
public int compare(Teacher t1, Teacher t2) {
39-
40-
int name = t1.getSubject().compareTo(t2.getSubject());
41-
42-
int exp = Integer.valueOf(t1.getExperience()).compareTo(t2.getExperience());
43-
44-
return name == 0 ? exp : name;
45-
}
46-
47-
}

‎src/main/java/com/javaprogramto/java8/comparator/ComparatorExample4.java‎

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -21,7 +21,9 @@ public static void main(String[] args) {
2121
teachers.forEach(teacher -> System.out.println("Teacher name - " + teacher.getName() + ", subject - "
2222
+ teacher.getSubject() + ", exp - " + teacher.getExperience()));
2323

24-
Collections.sort(teachers, new SubjectExperienceComparator());
24+
Comparator<Teacher> subjectComparator = Comparator.comparing(Teacher::getSubject);
25+
26+
Collections.sort(teachers, subjectComparator);
2527

2628
System.out.println("\nTeachers object before sorting");
2729
teachers.forEach(teacher -> System.out.println("Teacher name - " + teacher.getName() + ", subject - "

‎src/main/java/com/javaprogramto/java8/comparator/ComparatorExample6.java‎

Lines changed: 26 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -23,21 +23,42 @@ public static void main(String[] args) {
2323
+ teacher.getSubject() + ", exp - " + teacher.getExperience()));
2424

2525
// using streams.sort
26+
27+
28+
// way 1 - comparator with method ref and comparing() and thenComparing() method.
2629
Comparator<Teacher> subjectExpComparator1 = Comparator.comparing(Teacher::getSubject)
2730
.thenComparing(Teacher::getExperience);
2831

2932
List<Teacher> sortedList1 = teachers.stream().sorted(subjectExpComparator1).collect(Collectors.toList());
3033

31-
Comparator<Teacher> subjectComparator2 = (t1, t2) -> {
32-
34+
// way 2 - lambda with comparator
35+
Comparator<Teacher> subjectExpComparator2 = (t1, t2) -> {
36+
3337
int subjectCompare = t1.getSubject().compareTo(t2.getSubject());
34-
int expCompare = Integer.valueof(t1.getExperience()).compareTo(t2.getExperience());
35-
return t1.getSubject().compareTo(t2.getSubject());
38+
int expCompare = Integer.valueOf(t1.getExperience()).compareTo(t2.getExperience());
39+
return subjectCompare == 0 ? expCompare : subjectCompare;
40+
};
41+
42+
List<Teacher> sortedList2 = teachers.stream().sorted(subjectExpComparator1).collect(Collectors.toList());
43+
44+
// way 3 - with anonymous comparator
45+
Comparator<Teacher> subjectExpComparator3 = new Comparator<Teacher>() {
46+
47+
@Override
48+
public int compare(Teacher o1, Teacher o2) {
49+
int subjectCompare = t1.getSubject().compareTo(t2.getSubject());
50+
int expCompare = Integer.valueOf(t1.getExperience()).compareTo(t2.getExperience());
51+
return subjectCompare == 0 ? expCompare : subjectCompare;
52+
}
3653
};
3754

38-
List<Teacher> sortedList2 = teachers.stream().sorted(subjectComparator2).collect(Collectors.toList());
55+
List<Teacher> sortedList3 = teachers.stream().sorted(subjectExpComparator3).collect(Collectors.toList());
3956

4057
// using collections.sort
58+
59+
Collections.sort(teachers, subjectExpComparator1);
60+
Collections.sort(teachers, subjectExpComparator2);
61+
Collections.sort(teachers, subjectExpComparator3);
4162

4263
System.out.println("\nTeachers object before sorting");
4364
teachers.forEach(teacher -> System.out.println("Teacher name - " + teacher.getName() + ", subject - "

‎src/main/java/com/javaprogramto/java8/comparator/lambda/WIthoutLambdasExample.java‎

Lines changed: 181 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,181 @@
1+
package com.javaprogramto.java8.comparator.lambda;
2+
3+
import java.util.Collections;
4+
import java.util.Comparator;
5+
import java.util.LinkedList;
6+
import java.util.List;
7+
8+
public class WIthoutLambdasExample {
9+
10+
public static void main(String[] args) {
11+
12+
List<Engineer> engineers1 = getEngineersList();
13+
14+
// printing engineer objects sorted by id
15+
System.out.println("Before sorting");
16+
engineers1.forEach(System.out::println);
17+
18+
// comparator before java 8 and without lambds
19+
Comparator<Engineer> idComparator = new Comparator<Engineer>() {
20+
21+
@Override
22+
public int compare(Engineer e1, Engineer e2) {
23+
24+
return Integer.valueOf(e1.getId()).compareTo(e2.getId());
25+
}
26+
};
27+
28+
// sorting with collections.sort()
29+
Collections.sort(engineers1, idComparator);
30+
31+
// printing engineer objects sorted by id
32+
System.out.println("\nAfter sorting");
33+
engineers1.forEach(System.out::println);
34+
35+
// sort engineers by name
36+
37+
List<Engineer> engineers2 = getEngineersList();
38+
39+
// printing engineer objects sorted by id
40+
System.out.println("Before sorting");
41+
engineers2.forEach(System.out::println);
42+
43+
// comparator before java 8 and without lambds
44+
Comparator<Engineer> nameComparator = new Comparator<Engineer>() {
45+
46+
@Override
47+
public int compare(Engineer e1, Engineer e2) {
48+
49+
return e1.getName().compareTo(e2.getName());
50+
}
51+
};
52+
53+
// sorting with collections.sort()
54+
Collections.sort(engineers2, nameComparator);
55+
56+
// printing engineer objects sorted by id
57+
System.out.println("\nAfter sorting");
58+
engineers2.forEach(System.out::println);
59+
60+
// sort engineers by salary
61+
62+
List<Engineer> engineers3 = getEngineersList();
63+
64+
// printing engineer objects sorted by id
65+
System.out.println("\nEngieer Sort by Salary");
66+
System.out.println("\nBefore sorting");
67+
engineers3.forEach(System.out::println);
68+
69+
// comparator before java 8 and without lambds
70+
Comparator<Engineer> salaryComparator = new Comparator<Engineer>() {
71+
72+
@Override
73+
public int compare(Engineer e1, Engineer e2) {
74+
75+
return Long.valueOf(e1.getSalary()).compareTo(e2.getSalary());
76+
}
77+
};
78+
79+
// sorting with collections.sort()
80+
Collections.sort(engineers3, salaryComparator);
81+
82+
// printing engineer objects sorted by id
83+
System.out.println("\nAfter sorting");
84+
engineers3.forEach(System.out::println);
85+
86+
// sort engineers by full time
87+
88+
List<Engineer> engineers4 = getEngineersList();
89+
90+
// printing engineer objects sorted by id
91+
System.out.println("\nEngieer Sort by fulltime");
92+
System.out.println("\nBefore sorting");
93+
engineers4.forEach(System.out::println);
94+
95+
// comparator before java 8 and without lambds
96+
Comparator<Engineer> fulltimeComparator = new Comparator<Engineer>() {
97+
98+
@Override
99+
public int compare(Engineer e1, Engineer e2) {
100+
101+
return Boolean.valueOf(e1.isFullTime()).compareTo(Boolean.valueOf(e2.isFullTime()));
102+
}
103+
};
104+
105+
// sorting with collections.sort()
106+
Collections.sort(engineers4, fulltimeComparator);
107+
108+
// printing engineer objects sorted by id
109+
System.out.println("\nAfter sorting");
110+
engineers4.forEach(System.out::println);
111+
112+
}
113+
114+
private static List<Engineer> getEngineersList() {
115+
// creating the List of engineers
116+
List<Engineer> engineers = new LinkedList<>();
117+
118+
// adding engineer objects
119+
engineers.add(new Engineer(100, "Jeo", 100000, false));
120+
engineers.add(new Engineer(103, "Sunny", 500000, true));
121+
engineers.add(new Engineer(104, "Zeon", 300000, false));
122+
engineers.add(new Engineer(105, "Neon", 400000, true));
123+
engineers.add(new Engineer(102, "Ammon", 200000, false));
124+
125+
return engineers;
126+
}
127+
128+
}
129+
130+
class Engineer {
131+
132+
private int id;
133+
private String name;
134+
private long salary;
135+
private boolean fullTime;
136+
137+
public Engineer(int id, String name, long salary, boolean fullTime) {
138+
super();
139+
this.id = id;
140+
this.name = name;
141+
this.salary = salary;
142+
this.fullTime = fullTime;
143+
}
144+
145+
public int getId() {
146+
return id;
147+
}
148+
149+
public void setId(int id) {
150+
this.id = id;
151+
}
152+
153+
public String getName() {
154+
return name;
155+
}
156+
157+
public void setName(String name) {
158+
this.name = name;
159+
}
160+
161+
public long getSalary() {
162+
return salary;
163+
}
164+
165+
public void setSalary(long salary) {
166+
this.salary = salary;
167+
}
168+
169+
public boolean isFullTime() {
170+
return fullTime;
171+
}
172+
173+
public void setFullTime(boolean fullTime) {
174+
this.fullTime = fullTime;
175+
}
176+
177+
@Override
178+
public String toString() {
179+
return "Engineer [id=" + id + ", name=" + name + ", salary=" + salary + ", fullTime=" + fullTime + "]";
180+
}
181+
}

‎src/main/java/com/javaprogramto/java8/comparator/lambda/WithLambdasExample.java‎

Lines changed: 101 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,101 @@
1+
package com.javaprogramto.java8.comparator.lambda;
2+
3+
import java.util.Collections;
4+
import java.util.Comparator;
5+
import java.util.LinkedList;
6+
import java.util.List;
7+
8+
public class WithLambdasExample {
9+
10+
public static void main(String[] args) {
11+
12+
List<Engineer> engineers1 = getEngineersList();
13+
14+
// printing engineer objects sorted by id
15+
System.out.println("Before sorting");
16+
engineers1.forEach(System.out::println);
17+
18+
// comparator with lambdas
19+
Comparator<Engineer> idComparator = (e1, e2) -> Integer.valueOf(e1.getId()).compareTo(e2.getId());
20+
21+
// sorting with collections.sort()
22+
engineers1.sort(idComparator);
23+
24+
// printing engineer objects sorted by id
25+
System.out.println("\nAfter sorting");
26+
engineers1.forEach(System.out::println);
27+
28+
// sort engineers by name
29+
30+
List<Engineer> engineers2 = getEngineersList();
31+
32+
// printing engineer objects sorted by id
33+
System.out.println("Before sorting");
34+
engineers2.forEach(System.out::println);
35+
36+
// comparator in java 8 with lambdas
37+
Comparator<Engineer> nameComparator = (e1, e2) -> e1.getName().compareTo(e2.getName());
38+
39+
// sorting with list.sort()
40+
engineers2.sort(nameComparator);
41+
42+
// printing engineer objects sorted by id
43+
System.out.println("\nAfter sorting");
44+
engineers2.forEach(System.out::println);
45+
46+
// sort engineers by salary
47+
48+
List<Engineer> engineers3 = getEngineersList();
49+
50+
// printing engineer objects sorted by id
51+
System.out.println("\nEngieer Sort by Salary");
52+
System.out.println("\nBefore sorting");
53+
engineers3.forEach(System.out::println);
54+
55+
// comparator before java 8 and without lambds
56+
Comparator<Engineer> salaryComparator = (e1, e2) -> Long.valueOf(e1.getSalary()).compareTo(e2.getSalary());
57+
58+
// sorting with collections.sort()
59+
engineers3.sort(salaryComparator);
60+
61+
// printing engineer objects sorted by id
62+
System.out.println("\nAfter sorting");
63+
engineers3.forEach(System.out::println);
64+
65+
// sort engineers by fulltime
66+
67+
List<Engineer> engineers4 = getEngineersList();
68+
69+
// printing engineer objects sorted by id
70+
System.out.println("\nEngieer Sort by fulltime");
71+
System.out.println("\nBefore sorting");
72+
engineers4.forEach(System.out::println);
73+
74+
// comparator in java 8 with lambdas
75+
Comparator<Engineer> fulltimeComparator = (e1, e2) -> Boolean.valueOf(e1.isFullTime())
76+
.compareTo(Boolean.valueOf(e2.isFullTime()));
77+
78+
// sorting with list.sort()
79+
engineers4.sort(fulltimeComparator);
80+
81+
// printing engineer objects sorted by id
82+
System.out.println("\nAfter sorting");
83+
engineers4.forEach(System.out::println);
84+
85+
}
86+
87+
private static List<Engineer> getEngineersList() {
88+
// creating the List of engineers
89+
List<Engineer> engineers = new LinkedList<>();
90+
91+
// adding engineer objects
92+
engineers.add(new Engineer(100, "Jeo", 100000, false));
93+
engineers.add(new Engineer(103, "Sunny", 500000, true));
94+
engineers.add(new Engineer(104, "Zeon", 300000, false));
95+
engineers.add(new Engineer(105, "Neon", 400000, true));
96+
engineers.add(new Engineer(102, "Ammon", 200000, false));
97+
98+
return engineers;
99+
}
100+
101+
}

0 commit comments

Comments
 (0)