Java: sorting list of objects by substrings of a given String property (pattern ITEM/LOC/YYYY/N)

I have a list of objects and I want to sort them (ascending and descending order) by a formNumber property.

FormNumber is always a String of a pattern ITEM/LOC/YYYY/N, where:

• ITEM is constant
• LOC - three-letter location shortcut, ex. NYC, MIA, TOR
• YYYY - year
• N - number. Always a prime number, so something like 05 or 007 won't happen

I want to sort first by a YYYY, then if equal by N, then if equal by LOC.

The number of objects can go in hundreds rather than thousands. What will be the best / most efficient way of doing this?

First, create a wrapper class:

class ObjWrapper implements Comparable<ObjWrapper> {
private static final Pattern DELIM = Pattern.compile("/");
Obj obj;
String[] formNumberSplit;
public ObjWrapper(Obj obj) {
this.obj = obj;
this.formNumberSplit = DELIM.split(obj.getFormNumber());
}
@Override
public int compareTo(ObjWrapper another) {
int compareYear = formNumberSplit[2].compareTo(another.formNumberSplit[2]);
if (compareYear != 0) {
return compareYear;
}
int compareN = Integer.compare(
Integer.parseInt(formNumberSplit[3]),
Integer.parseInt(another.formNumberSplit[3]));
if (compareN != 0) {
return compareN;
}
return formNumberSplit[1].compareTo(another.formNumberSplit[1]);
}
public Obj getObj() {
return obj;
}
}

It will do the splitting and will help sorting our objects. Of course, instead of Obj is your class. Then do the sorting:

List<Obj> sortedObjs = objsList.stream()
.map(ObjWrapper::new)
.sorted()
.map(ObjWrapper::getObj)
.collect(Collectors.toList());

I would create three comparators and chain them together when sorting. It makes your code more readable and obvious. Also, you can flexibly switch the sorting of the individual attributes between descending and ascending as needed

Example:

List<String> list = new ArrayList<>(); 
list.add("ITEM/NYC/2020/3");
list.add("ITEM/TOR/2018/13");
list.add("ITEM/MIA/2020/41");
list.add("ITEM/NYC/2018/7");
list.add("ITEM/MIA/2018/11");
list.add("ITEM/NYC/2020/17");
list.add("ITEM/NYC/2019/13");
list.add("ITEM/MIA/2019/3");
list.add("ITEM/TOR/2019/3");
Comparator<String> byYear = (y1,y2)-> 
Integer.compare(Integer.parseInt(y1.split("/")[2]), Integer.parseInt(y2.split("/")[2]));
Comparator<String> byN = (n1,n2)-> 
Integer.compare(Integer.parseInt(n1.split("/")[3]), Integer.parseInt(n2.split("/")[3]));
Comparator<String> byLoc = (loc1,loc2)-> loc1.split("/")[1].compareTo(loc2.split("/")[1]);
// sort by all asc
list.sort(byYear.thenComparing(byN).thenComparing(byLoc));
list.forEach(System.out::println);
// sort by year desc, then by n asc and loc desc
list.sort(byYear.reversed().thenComparing(byN).thenComparing(byLoc).reversed());
// combine them as you wish or exclude one if not necessary etc...

You can also combine them into one comparator if the sort order is fixed and will not change in the future

EDIT

Assuming you have a class Foo with a formNumber property:

class Foo{    
String formNumber;
public String getFormNumber() {
return formNumber;
}        
}

and a list of foos:

List<Foo> fooList = ....

then change the above to something like :

Comparator<Foo> byYear = (y1,y2)-> 
Integer.compare(Integer.parseInt(y1.getFormNumber().split("/")[2]), 
Integer.parseInt(y2.getFormNumber().split("/")[2]));
Comparator<Foo> byN = (n1,n2)-> 
Integer.compare(Integer.parseInt(n1.getFormNumber().split("/")[3]), 
Integer.parseInt(n2.getFormNumber().split("/")[3]));
Comparator<Foo> byLoc = (loc1,loc2)-> loc1.getFormNumber().split("/")[1]
.compareTo(loc2.getFormNumber().split("/")[1]);

the usage of the comparators remains the same

fooList.sort(byYear.thenComparing(byN).thenComparing(byLoc));