🧠 Mastering Sorting of Pairs and Custom Objects in Java: A Complete Guide

Whether you're using arrays, lists, priority queues, or maps — sorting pairs (or objects with multiple fields) is a common task in Java. This guide will walk you through the best ways to do it, using:

• ✅ Arrays
• ✅ Lists (ArrayList)
• ✅ PriorityQueue
• ✅ TreeMap / TreeSet
• ✅ Custom Objects
• ✅ Java 8+ functional comparators

---

🔹 1. Arrays of Primitive Arrays (int[][])

✅ Use Case:

Fastest to use in algorithm problems (e.g. LeetCode), with low overhead.

▶️ Sort by second element (ascending):

int[][] arr = { {1, 5}, {2, 3}, {3, 8}, {4, 1} };
Arrays.sort(arr, (a, b) -> Integer.compare(a[1], b[1]));

▶️ Sort by second element (descending):

Arrays.sort(arr, (a, b) -> Integer.compare(b[1], a[1]));

❌ You cannot use Comparator.comparingInt() here because int[] is not an object with named fields.

---

🔹 2. List of Arrays (List<int[]>)

Same as arrays but with Collections.sort.

▶️ Sort by second element ascending:

List<int[]> list = new ArrayList<>();
list.add(new int[]{1, 5});
list.add(new int[]{2, 3});
Collections.sort(list, (a, b) -> Integer.compare(a[1], b[1]));

---

🔹 3. List of Custom Objects

Define a Pair or any domain object with named fields.

▶️ Pair class:

class Pair {
    int first, second;
    Pair(int f, int s) { first = f; second = s; }
}

▶️ Ascending sort by second:

List<Pair> list = new ArrayList<>();
list.add(new Pair(1, 5));
list.add(new Pair(2, 3));

list.sort(Comparator.comparingInt(p -> p.second));

▶️ Descending sort:

list.sort(Comparator.comparingInt((Pair p) -> p.second).reversed());

✅ Clean and readable — use this for production-quality code.

---

🔹 4. PriorityQueue of Pairs

▶️ With arrays:

PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> Integer.compare(a[1], b[1]));

▶️ With objects:

PriorityQueue<Pair> pq = new PriorityQueue<>(Comparator.comparingInt(p -> p.second));

---

🔹 5. Map.Entry<K, V> (like HashMap or TreeMap)

✅ Use Case:

When you want to sort a map by value or keys, use Map.Entry.

▶️ Sort map by value ascending:

Map<String, Integer> map = new HashMap<>();
map.put("a", 3); map.put("b", 1);

List<Map.Entry<String, Integer>> entries = new ArrayList<>(map.entrySet());
entries.sort(Comparator.comparingInt(Map.Entry::getValue));

▶️ Descending:

entries.sort(Comparator.comparingInt(Map.Entry::getValue).reversed());

---

🔹 6. TreeMap and TreeSet Custom Sorting

✅ Use Case:

To maintain a continuously sorted collection.

▶️ TreeMap sorted by custom comparator on keys:

TreeMap<Integer, String> tree = new TreeMap<>(Comparator.reverseOrder());

▶️ TreeSet with custom objects:

TreeSet<Pair> set = new TreeSet<>(Comparator.comparingInt(p -> p.second));

⚠️ Note: TreeSet requires consistent equals() and compareTo() logic to avoid silent rejection of duplicates.

---

✅ Summary of Comparator Options

Collection Type	Use Lambda	comparingInt Works	Needs Custom Class	Reverse Order
int[][] / List<int[]>	✅ Yes	❌ No	❌ No	✅ Yes (manually)
List<Pair>	✅ Yes	✅ Yes	✅ Yes	✅ Yes
PriorityQueue<Pair>	✅ Yes	✅ Yes	✅ Yes	✅ Yes
Map.Entry<K, V>	✅ Yes	✅ Yes	❌ No	✅ Yes
TreeSet, TreeMap	✅ Yes	✅ Yes	✅ Recommended	✅ Yes

---

🚀 Pro Tips

1. Use Comparator.comparingInt() for clean, readable sorting when dealing with objects.
2. Use lambdas when working with primitive arrays or quick-and-dirty code.
3. Always use .reversed() when sorting in descending order.
4. For multiple sort keys (e.g., by value then key), use thenComparing():

   list.sort(Comparator.comparingInt((Pair p) -> p.second)
                       .thenComparingInt(p -> p.first));

---

🧾 Closing Thoughts

Sorting in Java is a versatile tool — once you understand how to use Comparator, comparingInt, and method references effectively, your code becomes cleaner, safer, and easier to maintain.

Choose the right strategy based on:

• Your data structure (array, list, map)
• Whether you need ascending/descending
• Whether your data has named fields

\