Which fields would you recommend using when calculating the hashCode method?

When calculating hashCode(), it is recommended to use fields that:

1. Are part of the object and do not depend on external factors.
2. Are likely to be used in object comparison (in the equals() method).
3. Have unique or sufficiently diverse values to reduce collisions.
4. Are primitives or have a correctly implemented hashCode().

Excluded fields:

1. That can change during the object's lifetime (if the object is intended to be used as a key in hash collections).
2. That are cached values computed based on other fields.
3. That are not used in equals().
4. Fields that can cause cyclic dependencies or have very large data structures, which can be inefficient to process.

Example implementation using Objects.hash():

// Example class
public class MyClass {
    private int id;
    private String name;
    private List<String> items; // Assuming items do not change after creation
    private transient int transientField; // transient fields are usually not included

    // Constructor, getters, and setters omitted

    @Override
    public int hashCode() {
        // Using fields id, name, and items
        return Objects.hash(id, name, items);
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        MyClass myClass = (MyClass) o;
        // Comparing the same fields used in hashCode()
        return id == myClass.id &&
               Objects.equals(name, myClass.name) &&
               Objects.equals(items, myClass.items);
    }
}

Old way of implementing without Objects.hash():

// Example class
public class MyClass {
    private int id;
    private String name;
    private List<String> items;

    // ...

    @Override
    public int hashCode() {
        int result = 17; // Some simple initial number
        result = 31 * result + id;
        result = 31 * result + (name != null ? name.hashCode() : 0);
        result = 31 * result + (items != null ? items.hashCode() : 0);
        return result;
    }
}

It is recommended to use Objects.hash() as a more convenient and less error-prone method. The main rule is consistency between equals() and hashCode(): if two objects are equal according to equals(), their hashCode() should always return the same value.