Suppose that there are classes like:
CivilAddSystem class :
class CivilAddSystem{
List<People> people = new ArrayList<>();
List<Town> towns = new ArrayList<>();
public People addPeople(People people) {
people.add(people);
return people;
}
public Town addTown(Town town) {
towns.add(town);
return town;
}
public House addHouse (House house, String townName) throws IllegalStateException {
Town town = getTown(townName);
if (null == town) throw new IllegalStateException("No matching town");
town.addHouse(house);
return house;
}
public List<String> getTown(String name) {
for (Town town : towns) {
if (town.getName().equals(name)) return town;
}
return null;
}
}
Town class:
public class Town {
List<House> houses = new ArrayList<>();
String name;
String abbreviation;
public Town (String name, String abbreviation) {
this.name = name;
this.abbreviation = abbreviation;
}
public String getName() {
return name;
}
public String getAbbreviation() {
return abbreviation;
}
public void addHouse(House house) {
houses.add(house);
}
public House getHouse(String unitNumber) {
for (House house : houses) {
if (house.getUnitNumber().equals(unitNumber)) return house;
}
return null;
}
}
House class:
public class House {
private final List<People> people = new ArrayList<>();
private final String unitNumber;
private final String houseName;
public House (String unitNumber, String houseName) {
this.unitNumber= unitNumber;
this.houseName= houseName;
}
public String getUnitNumber() {
return unitNumber;
}
public String getHouseName() {
return houseName;
}
private People checkMovedInPeople(People person) {
if (null == person) throw new NullPointerException();
for (People movedIn : people) {
if (movedIn.getName().equals(person.getName())) return movedIn;
if (movedIn.getPersonID().equals(person.getPersonID())) return movedIn;
}
return null;
}
public void moveInPeople(People person) throws IllegalArgumentException, IllegalStateException {
if (null == person) throw new IllegalArgumentException("Person shouldn't be null");
if (null != checkMovedInPeople(person)) throw new IllegalStateException("Person is already in the house");
people.add(person);
}
public List<String> getPeople() {
List<String> results = new ArrayList<>();
for (People person: people) {
results.add(person.getPersonID());
}
return results;
}
public People getPerson(String match) {
for (People person: people) {
if (person.getPersonID().equals(match)) return person;
if (person.getName().equals(match)) return person;
}
return null;
}
}
And for the people class, it just has two variables: String PersonID and String Name and their getter methods.
So, what I want to achieve is that, I am currently trying to test the addPeople method in CivilAddSystem class and I want to test it independently using mockito.
The test case I wrote using JUnit is like this:
#Test
public void testAddPeople() {
CivilAddSystem CAS = new CivilAddSystem();
Town town = CAS.addTown("BlueTown", "BT");
House house = CAS.addHouse("U180", "BlueHouse", "BlueTown");
People bob = CAS.addPeople("1", "Bob");
Assert.assertEquals(CAS.getTown("BlueTown").getHouse("U180").getPerson("1"), null);
house.moveInPeople(bob);
Assert.assertEquals(CAS.getTown("BlueTown").getHouse("U180").getPerson("1").getPersonID, 1);
}
But I am really struggling with applying mockito for this test case.
What I did so far is just mocking Town, House and People classes, (not the CivilAddSystem class since it is the one that is being tested), and stopped there...
Can anyone gives me a hint on how to apply mockito for that above test case?
p.s) A little bit of modification for the codes above is accepted (for example, applying dependency injection and something like this are accepted).
Thanks in advance!
Mocking gives you the ability to have a class look like another class or a class matching an interface. So if you wanted to test Town, you don't want to go through creating Houses, you just use Mockito to mock the house.
Ideally, Dwelling would be an interface, and there would be House, TownHome, Condo, RanchHouse, etc. as implementations. Then, when you are testing the CivilAddSystem, you aren't testing any of the TownHome implementation code. You have isolated it so that you are just testing the one class.
So you could create something like this:
// unit tests should only test one piece of functionality at a time.
// This should only test the addition of a Person. You should expect
// to have lots of unit tests so that when one breaks, you can tell
// exactly what broke
#Test
public void testAddTown() {
Town mockedTown = Mockito.mock(Town.class);
CivilAddSystem CAS = new CivilAddSystem();
Town town = CAS.addTown(mockedTown);
// verify that the town that was put in is the same as you get out...
// note that you should not be testing the functionality of Town here
// if you do, this breaks the isolation
Assert.assertTrue(CAS.getTowns().contains(mockedTown));
}
For advanced functionality, you can stub functionality. For example, if you needed to test if it was a large city, and CAS
// checks this by determining if the population is > 100000
#Test
public void testAddTown() {
Town mockedTown = Mockito.mock(Town.class);
when(mockedTown.getPopulation()).thenReturn(100001)
CivilAddSystem CAS = new CivilAddSystem();
// verify that the current state is the expected state
Assert.assertEquals(CAS.getNumberOfLargeTowns(), 0);
// make a change
Town town = CAS.addTown(mockedTown);
// test that the updates state is as expected
Assert.assertEquals(CAS.getNumberOfLargeTowns(), 1);
}
I have to write a method with the stream api.In the method I should get the maximum of an integer value in an Object called "Winner", The Integer value I mean is the average speed value, I have to get the highest/fastest one.The Class looks like this
package U13_Lambdas_Streams.Streams;
import java.time.Duration;
import java.util.Arrays;
import java.util.List;
public class Winner {
private int year;
private String nationality;
private String name;
private String team;
private int lengthKm;
private Duration winningTime;
private int stageWins;
private int daysInYellow;
public static final List<Winner> tdfWinners = Arrays.asList(
new Winner(2006, "Spain", "Óscar Pereiro", "Caisse d'Epargne–
Illes Balears", 3657, Duration.parse("PT89H40M27S"), 8),
new Winner(2007, "Spain", "Alberto Contador", "Discovery
Channel", 3570, Duration.parse("PT91H00M26S"), 4),
new Winner(2008, "Spain", "Carlos Sastre", "Team CSC", 3559,
Duration.parse("PT87H52M52S"), 5),
new Winner(2009, "Spain", "Alberto Contador", "Astana", 3459,
Duration.parse("PT85H48M35S"), 7),
new Winner(2010, "Luxembourg", "Andy Schleck", "Team Saxo Bank",
3642, Duration.parse("PT91H59M27S"), 12),
new Winner(2011, "Australia", "Cadel Evans", "BMC Racing Team",
3430, Duration.parse("PT86H12M22S"), 2),
new Winner(2012, "Great Britain", "Bradley Wiggins", "Team Sky",
3496, Duration.parse("PT87H34M47S"), 14),
new Winner(2013, "Great Britain", "Chris Froome", "Team Sky",
3404, Duration.parse("PT83H56M20S"), 14),
new Winner(2014, "Italy", "Vincenzo Nibali", "Astana", 3661,
Duration.parse("PT89H59M06S"), 19),
new Winner(2015, "Great Britain", "Chris Froome", "Team Sky",
3360, Duration.parse("PT84H46M14S"), 16),
new Winner(2016, "Great Britain", "Chris Froome", "Team Sky",
3529, Duration.parse("PT89H04M48S"), 14)
);
public Winner(int year, String nationality, String name, String team, int
lengthKm, Duration winningTime, int daysInYellow) {
this.year = year;
this.nationality = nationality;
this.name = name;
this.team = team;
this.lengthKm = lengthKm;
this.winningTime = winningTime;
this.daysInYellow = daysInYellow;
}
public double getAveSpeed() {
return (getLengthKm() / (getWinningTime().getSeconds() / 3600));
}
public int getYear() {
return year;
}
public void setYear(int year) {
this.year = year;
}
public String getNationality() {
return nationality;
}
public void setNationality(String nationality) {
this.nationality = nationality;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getTeam() {
return team;
}
public void setTeam(String team) {
this.team = team;
}
public int getLengthKm() {
return lengthKm;
}
public void setLengthKm(int lengthKm) {
this.lengthKm = lengthKm;
}
public Duration getWinningTime() {
return winningTime;
}
public void setWinningTime(Duration winningTime) {
this.winningTime = winningTime;
}
public int getStageWins() {
return stageWins;
}
public void setStageWins(int stageWins) {
this.stageWins = stageWins;
}
public int getDaysInYellow() {
return daysInYellow;
}
public void setDaysInYellow(int daysInYellow) {
this.daysInYellow = daysInYellow;
}
#Override
public String toString() {
return name;
}
}
I tried It with this, but I still get 3 names and I dont know why
private static Double getMaxAVGSpeed() {
return Winner.tdfWinners
.stream()
.mapToDouble(Winner::getAveSpeed)
.max()
.orElse(Double.MAX_VALUE);
}
private static String winnerAVGSpeed() {
return Winner.tdfWinners
.stream()
.filter(winner -> winner.getAveSpeed() == getMaxAVGSpeed())
.map(Winner::getName)
.collect(Collectors.joining());
}
I hope you guys can help.
Regards, Lukas
EDIT: After reading Mark Keen's comment, it seems like the main fault is that the getAveSpeed() function does not cast the length to a double, so the result is rounded. I missed that when looking through the code. If the Winner class was provided as-is by the exercise, I would ask around to make sure that that is the intended behavior. However, the most likely case is that the methods of the class were written by OP, in which case casting the calculation would be a necessary change. Thanks, Mark.
I actually get 6 names when I run your code.
Your problem is that 6 Winners have the average speed of 40.0, which is the fastest/highest one of the set. So the result you're getting is correct. The main problem you have is figuring out the requirements of the exercise, to see if you have to print out just the maximum speed, the names of the Winners that have the maximum speed, or just one name that has the maximum speed.
One small caveat about your code, in the winnerAVGSpeed() function, you write
.filter(winner -> winner.getAveSpeed() == getMaxAVGSpeed())
on the stream you're manipulating. You're calling getMaxAVGSpeed() for every single element in the stream, which means that you're going through the stream and calculating the max speed once for every element of the list. The thing is, the max average speed will not change at any point, so you can calculate it once before you start manipulating the stream, store it in a variable, and then use the variable, to make your code more efficient.
If you only have to print out a single name that has the maximum velocity, you could also do this in a single stream operation, by using reduce, a stream function that allows you to compare and reduce a stream to a single element with a custom function. There's official documentation on this, but you can also find many different tutorials on how to use reduce on streams. It's not necessary though, your way seems more clear and useful to me.
I have a list of maps. The map holds two values "key" and "value" I have to filter out specific values from that list. So I am iterating through the list and if the map has the key that I want, then I take that value and set it in another pojo.
{
teams=["
{key=NAME, value="ANKIT"},
{key=START_DATE, value=2016-09-01}
}
String START_DATE = "START_DATE";
STRING NAME = "NAME";
I have multiple conditions to check. I am doing this using foreach. Can this be done using Java 8 stream().
teamList.forEach(
team -> {
if (NAME.equals(team.get("key"))) {
team.setName(team.get("value"));
} else if (START_DATE.equals(team.get("key"))) {
team.setEndDate(LocalDate.parse(team.get("value")));
}
});
You can't use Java 8 new features to replace your old Java code. I think as everyone was trying to point out that fact what you are trying is not a recommended use of Java 8 streams.
Best practice in Java 8 is to avoid state-full operations. (That means, you are modifying an existing object. Here in this case, you are setting data to a object that resides in memory which had created earlier)
If you still wants to write this simple logic using Java 8 streams, below you can see the POJO class and the main method that sets the Data to that object.
public class POJO {
private Integer age;
private LocalDate birthday;
public LocalDate getBirthday() {
return birthday;
}
public void setBirthday(LocalDate birthday) {
this.birthday = birthday;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
#Override
public String toString() {
return "POJO{" +
"age=" + age +
", birthday=" + birthday +
'}';
}
}
public class MapIteration {
public static Map<String,Integer> ageMap = new HashMap<>();
private static final String NAME = "Doki";
private static final String START_DATE = "31/10/2016";
private static POJO myDataObject = new POJO();
private static BiConsumer<String,Integer> integerConsumer = (k, v) -> {
try {
if(NAME.equals(k.toString()))
myDataObject.setAge(Integer.valueOf(v.toString()));
else if (START_DATE.equals(LocalDate.parse(k.toString()).toString()))
myDataObject.setBirthday(LocalDate.parse(k.toString()));
} catch (NumberFormatException | DateTimeParseException e) {
System.out.println("exception occurred: Because sometimes names cannot be parsed as Date formats");
}
};
static{
ageMap.put("John", 23);
ageMap.put("Norman", 26);
ageMap.put("Micheal", 25);
ageMap.put("Doki", 22);
}
public static void main(String[] args){
ageMap.forEach(integerConsumer);
System.out.println(myDataObject);
}
}
I have simple class
public class ActiveAlarm {
public long timeStarted;
public long timeEnded;
private String name = "";
private String description = "";
private String event;
private boolean live = false;
}
and List<ActiveAlarm> con. How to sort in ascending order by timeStarted, then by timeEnded? Can anybody help? I know in C++ with generic algorithm and overload operator <, but I am new to Java.
Using Comparator
For Example:
class Score {
private String name;
private List<Integer> scores;
// +accessor methods
}
Collections.sort(scores, new Comparator<Score>() {
public int compare(Score o1, Score o2) {
// compare two instance of `Score` and return `int` as result.
return o2.getScores().get(0).compareTo(o1.getScores().get(0));
}
});
With Java 8 onwards, you can simply use lambda expression to represent Comparator instance.
Collections.sort(scores, (s1, s2) -> { /* compute and return int */ });
Either make ActiveAlarm implement Comparable<ActiveAlarm> or implement Comparator<ActiveAlarm> in a separate class. Then call:
Collections.sort(list);
or
Collections.sort(list, comparator);
In general, it's a good idea to implement Comparable<T> if there's a single "natural" sort order... otherwise (if you happen to want to sort in a particular order, but might equally easily want a different one) it's better to implement Comparator<T>. This particular situation could go either way, to be honest... but I'd probably stick with the more flexible Comparator<T> option.
EDIT: Sample implementation:
public class AlarmByTimesComparer implements Comparator<ActiveAlarm> {
#Override
public int compare(ActiveAlarm x, ActiveAlarm y) {
// TODO: Handle null x or y values
int startComparison = compare(x.timeStarted, y.timeStarted);
return startComparison != 0 ? startComparison
: compare(x.timeEnded, y.timeEnded);
}
// I don't know why this isn't in Long...
private static int compare(long a, long b) {
return a < b ? -1
: a > b ? 1
: 0;
}
}
JAVA 8 and Above Answer (Using Lambda Expressions)
In Java 8, Lambda expressions were introduced to make this even easier! Instead of creating a Comparator() object with all of it's scaffolding, you can simplify it as follows: (Using your object as an example)
Collections.sort(list, (ActiveAlarm a1, ActiveAlarm a2) -> a1.timeStarted-a2.timeStarted);
or even shorter:
Collections.sort(list, Comparator.comparingInt(ActiveAlarm ::getterMethod));
That one statement is equivalent to the following:
Collections.sort(list, new Comparator<ActiveAlarm>() {
#Override
public int compare(ActiveAlarm a1, ActiveAlarm a2) {
return a1.timeStarted - a2.timeStarted;
}
});
Think of Lambda expressions as only requiring you to put in the relevant parts of the code: the method signature and what gets returned.
Another part of your question was how to compare against multiple fields. To do that with Lambda expressions, you can use the .thenComparing() function to effectively combine two comparisons into one:
Collections.sort(list, (ActiveAlarm a1, ActiveAlarm a2) -> a1.timeStarted-a2.timeStarted
.thenComparing ((ActiveAlarm a1, ActiveAlarm a2) -> a1.timeEnded-a2.timeEnded)
);
The above code will sort the list first by timeStarted, and then by timeEnded (for those records that have the same timeStarted).
One last note: It is easy to compare 'long' or 'int' primitives, you can just subtract one from the other. If you are comparing objects ('Long' or 'String'), I suggest you use their built-in comparison. Example:
Collections.sort(list, (ActiveAlarm a1, ActiveAlarm a2) -> a1.name.compareTo(a2.name) );
EDIT: Thanks to Lukas Eder for pointing me to .thenComparing() function.
We can sort the list in one of two ways:
1. Using Comparator : When required to use the sort logic in multiple places
If you want to use the sorting logic in a single place, then you can write an anonymous inner class as follows, or else extract the comparator and use it in multiple places
Collections.sort(arrayList, new Comparator<ActiveAlarm>() {
public int compare(ActiveAlarm o1, ActiveAlarm o2) {
//Sorts by 'TimeStarted' property
return o1.getTimeStarted()<o2.getTimeStarted()?-1:o1.getTimeStarted()>o2.getTimeStarted()?1:doSecodaryOrderSort(o1,o2);
}
//If 'TimeStarted' property is equal sorts by 'TimeEnded' property
public int doSecodaryOrderSort(ActiveAlarm o1,ActiveAlarm o2) {
return o1.getTimeEnded()<o2.getTimeEnded()?-1:o1.getTimeEnded()>o2.getTimeEnded()?1:0;
}
});
We can have null check for the properties, if we could have used 'Long' instead of 'long'.
2. Using Comparable(natural ordering): If sort algorithm always stick to one property:
write a class that implements 'Comparable' and override 'compareTo' method as defined below
class ActiveAlarm implements Comparable<ActiveAlarm>{
public long timeStarted;
public long timeEnded;
private String name = "";
private String description = "";
private String event;
private boolean live = false;
public ActiveAlarm(long timeStarted,long timeEnded) {
this.timeStarted=timeStarted;
this.timeEnded=timeEnded;
}
public long getTimeStarted() {
return timeStarted;
}
public long getTimeEnded() {
return timeEnded;
}
public int compareTo(ActiveAlarm o) {
return timeStarted<o.getTimeStarted()?-1:timeStarted>o.getTimeStarted()?1:doSecodaryOrderSort(o);
}
public int doSecodaryOrderSort(ActiveAlarm o) {
return timeEnded<o.getTimeEnded()?-1:timeEnded>o.getTimeEnded()?1:0;
}
}
call sort method to sort based on natural ordering
Collections.sort(list);
In java8+ this can be written in single line as follows:
collectionObjec.sort(comparator_lamda) or comparator.comparing(CollectionType::getterOfProperty)
code:
ListOfActiveAlarmObj.sort((a,b->a.getTimeStarted().compareTo(b.getTimeStarted())))
or
ListOfActiveAlarmObj.sort(Comparator.comparing(ActiveAlarm::getTimeStarted))
public class ActiveAlarm implements Comparable<ActiveAlarm> {
public long timeStarted;
public long timeEnded;
private String name = "";
private String description = "";
private String event;
private boolean live = false;
public int compareTo(ActiveAlarm a) {
if ( this.timeStarted > a.timeStarted )
return 1;
else if ( this.timeStarted < a.timeStarted )
return -1;
else {
if ( this.timeEnded > a.timeEnded )
return 1;
else
return -1;
}
}
That should give you a rough idea. Once that's done, you can call Collections.sort() on the list.
Since Java8 this can be done even cleaner using a combination of Comparator and Lambda expressions
For Example:
class Student{
private String name;
private List<Score> scores;
// +accessor methods
}
class Score {
private int grade;
// +accessor methods
}
Collections.sort(student.getScores(), Comparator.comparing(Score::getGrade);
Java-8 solution using Stream API:
A. When timeStarted and timeEnded are public (as mentioned in the requirement) and therefore do not (need to) have public getter methods:
List<ActiveAlarm> sorted =
list.stream()
.sorted(Comparator.comparingLong((ActiveAlarm alarm) -> alarm.timeStarted)
.thenComparingLong((ActiveAlarm alarm) -> alarm.timeEnded))
.collect(Collectors.toList());
B. When timeStarted and timeEnded have public getter methods:
List<ActiveAlarm> sorted =
list.stream()
.sorted(Comparator.comparingLong(ActiveAlarm::getTimeStarted)
.thenComparingLong(ActiveAlarm::getTimeEnded))
.collect(Collectors.toList());
If you want to sort the original list itself:
A. When timeStarted and timeEnded are public (as mentioned in the requirement) and therefore do not (need to) have public getter methods:
list.sort(Comparator.comparingLong((ActiveAlarm alarm) -> alarm.timeStarted)
.thenComparingLong((ActiveAlarm alarm) -> alarm.timeEnded));
B. When timeStarted and timeEnded have public getter methods:
list.sort(Comparator.comparingLong(ActiveAlarm::getTimeStarted)
.thenComparingLong(ActiveAlarm::getTimeEnded));
Guava's ComparisonChain:
Collections.sort(list, new Comparator<ActiveAlarm>(){
#Override
public int compare(ActiveAlarm a1, ActiveAlarm a2) {
return ComparisonChain.start()
.compare(a1.timestarted, a2.timestarted)
//...
.compare(a1.timeEnded, a1.timeEnded).result();
}});
We can use the Comparator.comparing() method to sort a list based on an object's property.
class SortTest{
public static void main(String[] args) {
ArrayList<ActiveAlarm> activeAlarms = new ArrayList<>(){{
add(new ActiveAlarm("Alarm 1", 5, 10));
add(new ActiveAlarm("Alarm 2", 2, 12));
add(new ActiveAlarm("Alarm 3", 0, 8));
}};
/* I sort the arraylist here using the getter methods */
activeAlarms.sort(Comparator.comparing(ActiveAlarm::getTimeStarted)
.thenComparing(ActiveAlarm::getTimeEnded));
System.out.println(activeAlarms);
}
}
Note that before doing it, you'll have to define at least the getter methods of the properties you want to base your sort on.
public class ActiveAlarm {
public long timeStarted;
public long timeEnded;
private String name = "";
private String description = "";
private String event;
private boolean live = false;
public ActiveAlarm(String name, long timeStarted, long timeEnded) {
this.name = name;
this.timeStarted = timeStarted;
this.timeEnded = timeEnded;
}
public long getTimeStarted() {
return timeStarted;
}
public long getTimeEnded() {
return timeEnded;
}
#Override
public String toString() {
return name;
}
}
Output:
[Alarm 3, Alarm 2, Alarm 1]
Employee POJO Class
package in.ac.adit.oop.sort;
public class Employee {
private int id;
private String name;
private String department;
public int getId() {
return id;
}
public Employee() {
super();
}
public Employee(int id, String name, String department) {
super();
this.id = id;
this.name = name;
this.department = department;
}
#Override
public String toString() {
return "Employee [id=" + id + ", name=" + name + ", department=" + department + "]";
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getDepartment() {
return department;
}
public void setDepartment(String department) {
this.department = department;
}
}
Employee Class To Manage Employee
package in.ac.adit.oop.sort;
import java.util.ArrayList;
import java.util.List;
public class Example {
public static void main(String[] args) {
/*
* Create 10 Employee Object
*/
Employee emp1 = new Employee(1, "Nayan", "IT");
Employee emp2 = new Employee(2, "Siddarth", "CP");
Employee emp3 = new Employee(3, "Samarth", "AE");
Employee emp4 = new Employee(4, "Bhavesh", "CV");
Employee emp5 = new Employee(5, "Sam", "FT");
Employee emp6 = new Employee(6, "Keyur", "IT");
Employee emp7 = new Employee(7, "Bala", "ME");
Employee emp8 = new Employee(8, "Mitul", "ME");
Employee emp9 = new Employee(9, "Kamlesh", "EE");
Employee emp10 = new Employee(10, "Piyush", "EE");
/*
* List of Employee Object
*/
List<Employee> employeeList = new ArrayList<Employee>();
employeeList.add(emp1);
employeeList.add(emp2);
employeeList.add(emp3);
employeeList.add(emp4);
employeeList.add(emp5);
employeeList.add(emp6);
employeeList.add(emp7);
employeeList.add(emp8);
employeeList.add(emp9);
employeeList.add(emp10);
CustomObjectSort customObjectSort = new CustomObjectSort();
List<Employee> sortByDepartment = customObjectSort.sortByDepartment(employeeList);
/*
* Sorted By Department
*/
for (Employee employee : sortByDepartment) {
System.out.println(employee);
}
/*
* Sorted By Name
*/
List<Employee> sortByName = customObjectSort.sortByName(employeeList);
for (Employee employee : sortByName) {
System.out.println(employee);
}
/*
* Sorted By Id
*/
List<Employee> sortById = customObjectSort.sortById(employeeList);
for (Employee employee : sortById) {
System.out.println(employee);
}
}
}
Custom Sorting
package in.ac.adit.oop.sort;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class CustomObjectSort {
public List<Employee> sortByName(List<Employee> employeeList) {
Collections.sort(employeeList, new Comparator<Employee>() {
#Override
public int compare(Employee employee1, Employee employee2) {
return employee1.getName().compareTo(employee2.getName());
}
});
return employeeList;
}
public List<Employee> sortByDepartment(List<Employee> employeeList) {
Collections.sort(employeeList, new Comparator<Employee>() {
#Override
public int compare(Employee employee1, Employee employee2) {
return employee1.getDepartment().compareTo(employee2.getDepartment());
}
});
return employeeList;
}
public List<Employee> sortById(List<Employee> employeeList) {
Collections.sort(employeeList, new Comparator<Employee>() {
#Override
public int compare(Employee employee1, Employee employee2) {
return employee1.getId() - employee2.getId();
}
});
return employeeList;
}
}
You can use Collections.sort and pass your own Comparator<ActiveAlarm>
In java you need to use the static Collections.sort method. Here is an example for a list of CompanyRole objects, sorted first by begin and then by end. You can easily adapt for your own object.
private static void order(List<TextComponent> roles) {
Collections.sort(roles, new Comparator() {
#Override
public int compare(Object o1, Object o2) {
int x1 = ((CompanyRole) o1).getBegin();
int x2 = ((CompanyRole) o2).getBegin();
if (x1 != x2) {
return x1 - x2;
} else {
int y1 = ((CompanyRole) o1).getEnd();
int y2 = ((CompanyRole) o2).getEnd();
return y2 - y1;
}
}
});
}
You can call Collections.sort() and pass in a Comparator which you need to write to compare different properties of the object.
As mentioned you can sort by:
Making your object implement Comparable
Or pass a Comparator to Collections.sort
If you do both, the Comparable will be ignored and Comparator will be used. This helps that the value objects has their own logical Comparable which is most reasonable sort for your value object, while each individual use case has its own implementation.
public class ActiveAlarm {
public long timeStarted;
public long timeEnded;
private String name = "";
private String description = "";
private String event;
private boolean live = false;
}
List<ActiveAlarm> con = new ArrayList<ActiveAlarm>();
Collections.sort(con , (a1, a2) -> a1.timeStarted.compareTo(a2.timeStarted));
Collections.sort(con , (a1, a2) -> a1.timeEnded.compareTo(a2.timeEnded));
Here's what did the trick for me.
Was much shorter and easier than everything else I found:
Collections.sort(listName, Comparator.comparing(Object::getProperty).reversed());
The ".reversed()" part at the end was a requirement for my specific project but I'm sharing it too, as it took a while to find it
The best and the easiest way to sort any list of objects in Java (Java 8 and above).
Lets sort a basket of fruits based on the property "fruitName"
Fruit POJO:
class Fruit
{
int price;
String fruitName;
public Fruit(int price, String fruitName) {
super();
this.price = price;
this.fruitName = fruitName;
}
public int getPrice() {
return price;
}
public void setPrice(int price) {
this.price = price;
}
public String getFruitName() {
return fruitName;
}
public void setFruitName(String fruitName) {
this.fruitName = fruitName;
}
#Override
public String toString() {
return "Fruits [price=" + price + ", fruitName=" + fruitName + "]";
}
}
Now lets add fruits into a list and then sort it
List<Fruit> basketOfFruits = new ArrayList<>();
basketOfFruits.add(new Fruit(123, "oranges"));
basketOfFruits.add(new Fruit(45, "nectarine"));
basketOfFruits.add(new Fruit(369, "blueberries"));
basketOfFruits.add(new Fruit(248, "apple"));
basketOfFruits.add(new Fruit(968, "peaches"));
basketOfFruits.add(new Fruit(436, "grapes"));
basketOfFruits.add(new Fruit(596, "figs"));
//sorting by the property fruitName
Collections.sort(basketOfFruits, (f1, f2)->{return f1.getFruitName().compareTo(f2.getFruitName());});
You can now print the list (i.e basketOfFruits) and the fruits in the list would be sorted in ASCENDING order (lexicographically).
The output would look like this:
[Fruits [price=248, fruitName=apple], Fruits [price=369, fruitName=blueberries], Fruits [price=596, fruitName=figs], Fruits [price=436, fruitName=grapes], Fruits [price=45, fruitName=nectarine], Fruits [price=123, fruitName=oranges], Fruits [price=968, fruitName=peaches]]
Instead of Collections.sort(), Java streams can also be used (Java 8 and above). The following is the code using Java streams
List<Fruit> sortedFruits = basketOfFruits.stream().sorted( (f1, f2)->{return f1.getFruitName().compareTo(f2.getFruitName());}).collect(Collectors.toList());
here the list is sorted in the same manner as Collections.sort(), but the sorted items would be stored/collected in another list "sortedFruits". So, if we want to print the sorted items of the list, we need to print "sortedFruits" instead of "basketOfFruits" in this case