如何按HashCode()排序HashSet？以及如何在hashCode()方法中按EmpID排序？

Hey there! Let's work through your questions clearly—first, there's an important distinction to make between how HashSet works and what hashCode() is designed for, so we'll start with that context.

1. How to sort a HashSet by the result of hashCode()? #

First off: HashSet itself is unordered by design. It uses hash codes to store elements in a hash table, but it doesn't maintain any sort of order (not even based on hash code values). So to sort elements by their hash codes, you'll need to convert the HashSet into an ordered collection and apply a custom sorting rule.

Here are two common approaches:

Approach 1: Convert to ArrayList and use Collections.sort() #

You can copy the HashSet's elements into an ArrayList, then use Collections.sort() with a Comparator that compares the hash codes of each element:

import java.util.Collections;
import java.util.HashSet;
import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        HashSet<String> hashSet = new HashSet<>();
        hashSet.add("Apple");
        hashSet.add("Banana");
        hashSet.add("Cherry");

        // Convert to ArrayList
        ArrayList<String> list = new ArrayList<>(hashSet);

        // Sort by hashCode()
        Collections.sort(list, (a, b) -> Integer.compare(a.hashCode(), b.hashCode()));

        // Print sorted list
        list.forEach(System.out::println);
    }
}

Approach 2: Use a TreeSet with a custom Comparator #

If you want a collection that stays sorted by hash code (instead of sorting once), you can use TreeSet instead of HashSet, and pass a Comparator that compares hash codes. Note: TreeSet considers elements "equal" if the comparator returns 0, so you should add a secondary check (like comparing the elements themselves) to avoid losing elements with identical hash codes:

import java.util.TreeSet;

public class Main {
    public static void main(String[] args) {
        TreeSet<String> sortedSet = new TreeSet<>((a, b) -> {
            int hashCompare = Integer.compare(a.hashCode(), b.hashCode());
            // If hash codes are equal, compare the elements to avoid treating them as duplicates
            return hashCompare != 0 ? hashCompare : a.compareTo(b);
        });

        sortedSet.add("Apple");
        sortedSet.add("Banana");
        sortedSet.add("Cherry");

        sortedSet.forEach(System.out::println);
    }
}

2. How to implement sorting logic based on EmpID in the hashCode() method? #

Wait a second—let's clarify a critical point: the hashCode() method is not for sorting. Its purpose is to generate a numerical value that helps hash-based collections (like HashSet) store and retrieve elements efficiently. Sorting is handled by the Comparable interface (for natural ordering) or a Comparator (for custom ordering).

That said, if you want your Emp class's hash code to be based on EmpID (which is a good practice for consistency with equals()), you can implement hashCode() using EmpID. And if you want to sort Emp objects by EmpID, you separately implement sorting logic.

Step 1: Implement hashCode() and equals() based on EmpID #

This ensures that Emp objects with the same EmpID are treated as equal in hash-based collections:

public class Emp {
    private int empID;
    private String name;

    // Constructor, getters, setters
    public Emp(int empID, String name) {
        this.empID = empID;
        this.name = name;
    }

    @Override
    public int hashCode() {
        // Base hashCode on EmpID
        return Integer.hashCode(empID);
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Emp emp = (Emp) o;
        return empID == emp.empID;
    }

    // toString for printing
    @Override
    public String toString() {
        return "Emp{empID=" + empID + ", name='" + name + "'}";
    }
}

Step 2: Sort Emp objects by EmpID #

Now, to sort a collection of Emp objects by EmpID, you have two options:

Option A: Make Emp implement Comparable<Emp> (natural ordering)

public class Emp implements Comparable<Emp> {
    // ... existing code ...

    @Override
    public int compareTo(Emp other) {
        // Sort by EmpID ascending
        return Integer.compare(this.empID, other.empID);
    }
}

Then you can sort an ArrayList directly, or use a TreeSet without a comparator:

ArrayList<Emp> empList = new ArrayList<>(hashSetOfEmps);
Collections.sort(empList); // Uses natural ordering from compareTo()

Option B: Use a custom Comparator for ad-hoc sorting

If you don't want to modify the Emp class, or need a different sort order sometimes:

ArrayList<Emp> empList = new ArrayList<>(hashSetOfEmps);
Collections.sort(empList, (e1, e2) -> Integer.compare(e1.getEmpID(), e2.getEmpID()));

// Or for a TreeSet that stays sorted by EmpID:
TreeSet<Emp> sortedEmpSet = new TreeSet<>((e1, e2) -> Integer.compare(e1.getEmpID(), e2.getEmpID()));

内容的提问来源于stack exchange，提问作者Tathagata Mukherjee