# ObjectsHashCodePrimitive
Objects.hashCode(Object o) should not be passed a primitive value

Severity
  WARNING

## The problem

`Objects.hashCode` takes an `Object` parameter, and will either return `0` when the parameter is `null` , or call the underlying `hashCode` function of the Object reference.

Passing a primitive value to `Objects.hashCode` function results in boxing the primitive, then calling the boxed object’s `hashCode` . You can get the same result by using, e.g.: `Long.hashCode(long)` to get the effective hash code of a primitive `long` . If you’re calling this method outside of your own `hashCode()` implementation, prefer to use the `BoxedClass.hashCode(primitive)` functions to avoid unwanted boxed.

If you’re implementing a `hashCode` function for your own class that consists of a single primitive value, you may want to consider some of these alternatives:

    @Override
    public int hashCode() {
      // This function will box intValue into an Integer, and wrap *that* in an
      // array, but will generate a hashCode which is likely to be different than
      // the hashCode of the boxed version of the intValue. This makes it easier
      // to add more fields to the class and hashCode method (just by adding more
      // fields to the hash call), but comes at a potential performance penalty.
      return Objects.hash(intValue);
    }

    @Override
    public int hashCode() {
      // This function will avoid boxing the int to an Integer, and is an explicit
      // acknowledgement that the hashCode() of *this* class is the same as the
      // hash code of the underlying intValue.
      return Integer.hashCode(intValue);
    }

## Suppression

Suppress false positives by adding the suppression annotation `@SuppressWarnings("ObjectsHashCodePrimitive")` to the enclosing element.