Introduce ObjectUtils#nullSafeHash(Object... element)

This commit deprecates the various nullSafeHashCode methods taking array
types as they are superseded by Arrays.hashCode now. This means that
the now only remaining nullSafeHashCode method does not trigger a
warning only if the target type is not an array. At the same time, there
are multiple use of this method on several elements, handling the
accumulation of hash codes.

For that reason, this commit also introduces a nullSafeHash that takes
an array of elements. The only difference between Objects.hash is that
this method handles arrays.

The codebase has been reviewed to use any of those two methods when it
is possible.

Closes gh-29051

spring-core/src/main/java/org/springframework/core/annotation/RepeatableContainers.java

@@ -20,6 +20,7 @@ import java.lang.annotation.Annotation;
 import java.lang.annotation.Repeatable;
 import java.lang.reflect.Method;
 import java.util.Map;
+import java.util.Objects;
 
 import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
@@ -91,7 +92,7 @@ public abstract class RepeatableContainers {
 
 	@Override
 	public int hashCode() {
-		return ObjectUtils.nullSafeHashCode(this.parent);
+		return Objects.hashCode(this.parent);
 	}
 
 

spring-core/src/main/java/org/springframework/core/convert/Property.java

@@ -22,6 +22,7 @@ import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.util.LinkedHashMap;
 import java.util.Map;
+import java.util.Objects;
 
 import org.springframework.core.MethodParameter;
 import org.springframework.lang.Nullable;
@@ -269,7 +270,7 @@ public final class Property {
 
 	@Override
 	public int hashCode() {
-		return (ObjectUtils.nullSafeHashCode(this.objectType) * 31 + ObjectUtils.nullSafeHashCode(this.name));
+		return Objects.hash(this.objectType, this.name);
 	}
 
 }

spring-core/src/main/java/org/springframework/core/env/PropertySource.java

@@ -16,6 +16,8 @@
 
 package org.springframework.core.env;
 
+import java.util.Objects;
+
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 
@@ -147,7 +149,7 @@ public abstract class PropertySource<T> {
 	 */
 	@Override
 	public int hashCode() {
-		return ObjectUtils.nullSafeHashCode(getName());
+		return Objects.hashCode(getName());
 	}
 
 	/**

spring-core/src/main/java/org/springframework/util/ObjectUtils.java

@@ -22,6 +22,7 @@ import java.time.ZoneId;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Optional;
 import java.util.StringJoiner;
 import java.util.TimeZone;
@@ -390,21 +391,32 @@ public abstract class ObjectUtils {
 	}
 
 	/**
-	 * Return as hash code for the given object; typically the value of
+	 * Return a hash code for the given elements, delegating to
+	 * {@link #nullSafeHashCode(Object)} for each element. Contrary
+	 * to {@link Objects#hash(Object...)}, this method handle an
+	 * element that is an array.
+	 * @param elements the elements to be hashed
+	 * @return a hash value of the elements
+	 * @since 6.1
+	 */
+	public static int nullSafeHash(@Nullable Object... elements) {
+		if (elements == null) {
+			return 0;
+		}
+		int result = 1;
+		for (Object element : elements) {
+			result = 31 * result + nullSafeHashCode(element);
+		}
+		return result;
+	}
+
+	/**
+	 * Return a hash code for the given object; typically the value of
 	 * {@code Object#hashCode()}}. If the object is an array,
-	 * this method will delegate to any of the {@code nullSafeHashCode}
-	 * methods for arrays in this class. If the object is {@code null},
-	 * this method returns 0.
+	 * this method will delegate to any of the {@code Arrays#hasCode}
+	 * methods. If the object is {@code null}, this method returns 0.
 	 * @see Object#hashCode()
-	 * @see #nullSafeHashCode(Object[])
-	 * @see #nullSafeHashCode(boolean[])
-	 * @see #nullSafeHashCode(byte[])
-	 * @see #nullSafeHashCode(char[])
-	 * @see #nullSafeHashCode(double[])
-	 * @see #nullSafeHashCode(float[])
-	 * @see #nullSafeHashCode(int[])
-	 * @see #nullSafeHashCode(long[])
-	 * @see #nullSafeHashCode(short[])
+	 * @see Arrays
 	 */
 	public static int nullSafeHashCode(@Nullable Object obj) {
 		if (obj == null) {
@@ -412,31 +424,31 @@ public abstract class ObjectUtils {
 		}
 		if (obj.getClass().isArray()) {
 			if (obj instanceof Object[] objects) {
-				return nullSafeHashCode(objects);
+				return Arrays.hashCode(objects);
 			}
 			if (obj instanceof boolean[] booleans) {
-				return nullSafeHashCode(booleans);
+				return Arrays.hashCode(booleans);
 			}
 			if (obj instanceof byte[] bytes) {
-				return nullSafeHashCode(bytes);
+				return Arrays.hashCode(bytes);
 			}
 			if (obj instanceof char[] chars) {
-				return nullSafeHashCode(chars);
+				return Arrays.hashCode(chars);
 			}
 			if (obj instanceof double[] doubles) {
-				return nullSafeHashCode(doubles);
+				return Arrays.hashCode(doubles);
 			}
 			if (obj instanceof float[] floats) {
-				return nullSafeHashCode(floats);
+				return Arrays.hashCode(floats);
 			}
 			if (obj instanceof int[] ints) {
-				return nullSafeHashCode(ints);
+				return Arrays.hashCode(ints);
 			}
 			if (obj instanceof long[] longs) {
-				return nullSafeHashCode(longs);
+				return Arrays.hashCode(longs);
 			}
 			if (obj instanceof short[] shorts) {
-				return nullSafeHashCode(shorts);
+				return Arrays.hashCode(shorts);
 			}
 		}
 		return obj.hashCode();
@@ -445,136 +457,91 @@ public abstract class ObjectUtils {
 	/**
 	 * Return a hash code based on the contents of the specified array.
 	 * If {@code array} is {@code null}, this method returns 0.
+	 * @deprecated as of 6.1 in favor of {@link Arrays#hashCode(Object[])}
 	 */
+	@Deprecated(since = "6.1")
 	public static int nullSafeHashCode(@Nullable Object[] array) {
-		if (array == null) {
-			return 0;
-		}
-		int hash = INITIAL_HASH;
-		for (Object element : array) {
-			hash = MULTIPLIER * hash + nullSafeHashCode(element);
-		}
-		return hash;
+		return Arrays.hashCode(array);
 	}
 
 	/**
 	 * Return a hash code based on the contents of the specified array.
 	 * If {@code array} is {@code null}, this method returns 0.
+	 * @deprecated as of 6.1 in favor of {@link Arrays#hashCode(boolean[])}
 	 */
+	@Deprecated(since = "6.1")
 	public static int nullSafeHashCode(@Nullable boolean[] array) {
-		if (array == null) {
-			return 0;
-		}
-		int hash = INITIAL_HASH;
-		for (boolean element : array) {
-			hash = MULTIPLIER * hash + Boolean.hashCode(element);
-		}
-		return hash;
+		return Arrays.hashCode(array);
 	}
 
 	/**
 	 * Return a hash code based on the contents of the specified array.
 	 * If {@code array} is {@code null}, this method returns 0.
+	 * @deprecated as of 6.1 in favor of {@link Arrays#hashCode(byte[])}
 	 */
+	@Deprecated(since = "6.1")
 	public static int nullSafeHashCode(@Nullable byte[] array) {
-		if (array == null) {
-			return 0;
-		}
-		int hash = INITIAL_HASH;
-		for (byte element : array) {
-			hash = MULTIPLIER * hash + element;
-		}
-		return hash;
+		return Arrays.hashCode(array);
 	}
 
 	/**
 	 * Return a hash code based on the contents of the specified array.
 	 * If {@code array} is {@code null}, this method returns 0.
+	 * @deprecated as of 6.1 in favor of {@link Arrays#hashCode(char[])}
 	 */
+	@Deprecated(since = "6.1")
 	public static int nullSafeHashCode(@Nullable char[] array) {
-		if (array == null) {
-			return 0;
-		}
-		int hash = INITIAL_HASH;
-		for (char element : array) {
-			hash = MULTIPLIER * hash + element;
-		}
-		return hash;
+		return Arrays.hashCode(array);
 	}
 
 	/**
 	 * Return a hash code based on the contents of the specified array.
 	 * If {@code array} is {@code null}, this method returns 0.
+	 * @deprecated as of 6.1 in favor of {@link Arrays#hashCode(double[])}
 	 */
+	@Deprecated(since = "6.1")
 	public static int nullSafeHashCode(@Nullable double[] array) {
-		if (array == null) {
-			return 0;
-		}
-		int hash = INITIAL_HASH;
-		for (double element : array) {
-			hash = MULTIPLIER * hash + Double.hashCode(element);
-		}
-		return hash;
+		return Arrays.hashCode(array);
 	}
 
 	/**
 	 * Return a hash code based on the contents of the specified array.
 	 * If {@code array} is {@code null}, this method returns 0.
+	 * @deprecated as of 6.1 in favor of {@link Arrays#hashCode(float[])}
 	 */
+	@Deprecated(since = "6.1")
 	public static int nullSafeHashCode(@Nullable float[] array) {
-		if (array == null) {
-			return 0;
-		}
-		int hash = INITIAL_HASH;
-		for (float element : array) {
-			hash = MULTIPLIER * hash + Float.hashCode(element);
-		}
-		return hash;
+		return Arrays.hashCode(array);
 	}
 
 	/**
 	 * Return a hash code based on the contents of the specified array.
 	 * If {@code array} is {@code null}, this method returns 0.
+	 * @deprecated as of 6.1 in favor of {@link Arrays#hashCode(int[])}
 	 */
+	@Deprecated(since = "6.1")
 	public static int nullSafeHashCode(@Nullable int[] array) {
-		if (array == null) {
-			return 0;
-		}
-		int hash = INITIAL_HASH;
-		for (int element : array) {
-			hash = MULTIPLIER * hash + element;
-		}
-		return hash;
+		return Arrays.hashCode(array);
 	}
 
 	/**
 	 * Return a hash code based on the contents of the specified array.
 	 * If {@code array} is {@code null}, this method returns 0.
+	 * @deprecated as of 6.1 in favor of {@link Arrays#hashCode(long[])}
 	 */
+	@Deprecated(since = "6.1")
 	public static int nullSafeHashCode(@Nullable long[] array) {
-		if (array == null) {
-			return 0;
-		}
-		int hash = INITIAL_HASH;
-		for (long element : array) {
-			hash = MULTIPLIER * hash + Long.hashCode(element);
-		}
-		return hash;
+		return Arrays.hashCode(array);
 	}
 
 	/**
 	 * Return a hash code based on the contents of the specified array.
 	 * If {@code array} is {@code null}, this method returns 0.
+	 * @deprecated as of 6.1 in favor of {@link Arrays#hashCode(short[])}
 	 */
+	@Deprecated(since = "6.1")
 	public static int nullSafeHashCode(@Nullable short[] array) {
-		if (array == null) {
-			return 0;
-		}
-		int hash = INITIAL_HASH;
-		for (short element : array) {
-			hash = MULTIPLIER * hash + element;
-		}
-		return hash;
+		return Arrays.hashCode(array);
 	}
 
 

spring-core/src/test/java/org/springframework/util/ObjectUtilsTests.java

@@ -30,6 +30,7 @@ import java.nio.file.Path;
 import java.sql.SQLException;
 import java.time.LocalDate;
 import java.time.ZoneId;
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.Currency;
 import java.util.Date;
@@ -38,6 +39,7 @@ import java.util.HashSet;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
 import java.util.TimeZone;
@@ -379,119 +381,197 @@ class ObjectUtilsTests {
 	}
 
 	@Test
-	void nullSafeHashCodeWithBooleanArray() {
-		int expected = 31 * 7 + Boolean.TRUE.hashCode();
-		expected = 31 * expected + Boolean.FALSE.hashCode();
+	void nullSafeHashWithNull() {
+		assertThat(ObjectUtils.nullSafeHash((Object[]) null)).isEqualTo(0);
+	}
 
+	@Test
+	void nullSafeHashWithIntermediateNullElements() {
+		assertThat(ObjectUtils.nullSafeHash(3, null, 5)).isEqualTo(Objects.hash(3, null, 5));
+	}
+
+	@Test
+	@Deprecated
+	void nullSafeHashCodeWithNullBooleanArray() {
+		boolean[] array = null;
+		assertThat(ObjectUtils.nullSafeHashCode(array)).isEqualTo(0);
+	}
+
+	@Test
+	@Deprecated
+	void nullSafeHashCodeWithBooleanArray() {
 		boolean[] array = {true, false};
 		int actual = ObjectUtils.nullSafeHashCode(array);
-
-		assertThat(actual).isEqualTo(expected);
+		assertThat(actual).isEqualTo(Arrays.hashCode(array));
 	}
 
 	@Test
-	void nullSafeHashCodeWithBooleanArrayEqualToNull() {
-		assertThat(ObjectUtils.nullSafeHashCode((boolean[]) null)).isEqualTo(0);
+	@Deprecated
+	void nullSafeHashCodeWithObjectBeingBooleanArray() {
+		Object array = new boolean[] {true, false};
+		int expected = ObjectUtils.nullSafeHashCode((boolean[]) array);
+		assertEqualHashCodes(expected, array);
 	}
 
 	@Test
+	@Deprecated
+	void nullSafeHashCodeWithNullByteArray() {
+		byte[] array = null;
+		assertThat(ObjectUtils.nullSafeHashCode(array)).isEqualTo(0);
+	}
+
+	@Test
+	@Deprecated
 	void nullSafeHashCodeWithByteArray() {
-		int expected = 31 * 7 + 8;
-		expected = 31 * expected + 10;
-
 		byte[] array = {8, 10};
 		int actual = ObjectUtils.nullSafeHashCode(array);
-
-		assertThat(actual).isEqualTo(expected);
+		assertThat(actual).isEqualTo(Arrays.hashCode(array));
 	}
 
 	@Test
-	void nullSafeHashCodeWithByteArrayEqualToNull() {
-		assertThat(ObjectUtils.nullSafeHashCode((byte[]) null)).isEqualTo(0);
+	@Deprecated
+	void nullSafeHashCodeWithObjectBeingByteArray() {
+		Object array = new byte[] {6, 39};
+		int expected = ObjectUtils.nullSafeHashCode((byte[]) array);
+		assertEqualHashCodes(expected, array);
 	}
 
 	@Test
+	@Deprecated
+	void nullSafeHashCodeWithNullCharArray() {
+		char[] array = null;
+		assertThat(ObjectUtils.nullSafeHashCode(array)).isEqualTo(0);
+	}
+
+	@Test
+	@Deprecated
 	void nullSafeHashCodeWithCharArray() {
-		int expected = 31 * 7 + 'a';
-		expected = 31 * expected + 'E';
-
 		char[] array = {'a', 'E'};
 		int actual = ObjectUtils.nullSafeHashCode(array);
-
-		assertThat(actual).isEqualTo(expected);
+		assertThat(actual).isEqualTo(Arrays.hashCode(array));
 	}
 
 	@Test
-	void nullSafeHashCodeWithCharArrayEqualToNull() {
-		assertThat(ObjectUtils.nullSafeHashCode((char[]) null)).isEqualTo(0);
+	@Deprecated
+	void nullSafeHashCodeWithObjectBeingCharArray() {
+		Object array = new char[] {'l', 'M'};
+		int expected = ObjectUtils.nullSafeHashCode((char[]) array);
+		assertEqualHashCodes(expected, array);
 	}
 
 	@Test
+	@Deprecated
+	void nullSafeHashCodeWithNullDoubleArray() {
+		double[] array = null;
+		assertThat(ObjectUtils.nullSafeHashCode(array)).isEqualTo(0);
+	}
+
+	@Test
+	@Deprecated
 	void nullSafeHashCodeWithDoubleArray() {
-		long bits = Double.doubleToLongBits(8449.65);
-		int expected = 31 * 7 + (int) (bits ^ (bits >>> 32));
-		bits = Double.doubleToLongBits(9944.923);
-		expected = 31 * expected + (int) (bits ^ (bits >>> 32));
-
 		double[] array = {8449.65, 9944.923};
 		int actual = ObjectUtils.nullSafeHashCode(array);
-
-		assertThat(actual).isEqualTo(expected);
+		assertThat(actual).isEqualTo(Arrays.hashCode(array));
 	}
 
 	@Test
-	void nullSafeHashCodeWithDoubleArrayEqualToNull() {
-		assertThat(ObjectUtils.nullSafeHashCode((double[]) null)).isEqualTo(0);
+	@Deprecated
+	void nullSafeHashCodeWithObjectBeingDoubleArray() {
+		Object array = new double[] {68930.993, 9022.009};
+		int expected = ObjectUtils.nullSafeHashCode((double[]) array);
+		assertEqualHashCodes(expected, array);
 	}
 
 	@Test
+	@Deprecated
+	void nullSafeHashCodeWithNullFloatArray() {
+		float[] array = null;
+		assertThat(ObjectUtils.nullSafeHashCode(array)).isEqualTo(0);
+	}
+
+	@Test
+	@Deprecated
 	void nullSafeHashCodeWithFloatArray() {
-		int expected = 31 * 7 + Float.floatToIntBits(9.6f);
-		expected = 31 * expected + Float.floatToIntBits(7.4f);
-
 		float[] array = {9.6f, 7.4f};
 		int actual = ObjectUtils.nullSafeHashCode(array);
-
-		assertThat(actual).isEqualTo(expected);
+		assertThat(actual).isEqualTo(Arrays.hashCode(array));
 	}
 
 	@Test
-	void nullSafeHashCodeWithFloatArrayEqualToNull() {
-		assertThat(ObjectUtils.nullSafeHashCode((float[]) null)).isEqualTo(0);
+	@Deprecated
+	void nullSafeHashCodeWithObjectBeingFloatArray() {
+		Object array = new float[] {9.9f, 9.54f};
+		int expected = ObjectUtils.nullSafeHashCode((float[]) array);
+		assertEqualHashCodes(expected, array);
 	}
 
 	@Test
+	@Deprecated
+	void nullSafeHashCodeWithNullIntArray() {
+		int[] array = null;
+		assertThat(ObjectUtils.nullSafeHashCode(array)).isEqualTo(0);
+	}
+
+	@Test
+	@Deprecated
 	void nullSafeHashCodeWithIntArray() {
-		int expected = 31 * 7 + 884;
-		expected = 31 * expected + 340;
-
 		int[] array = {884, 340};
 		int actual = ObjectUtils.nullSafeHashCode(array);
-
-		assertThat(actual).isEqualTo(expected);
+		assertThat(actual).isEqualTo(Arrays.hashCode(array));
 	}
 
 	@Test
-	void nullSafeHashCodeWithIntArrayEqualToNull() {
-		assertThat(ObjectUtils.nullSafeHashCode((int[]) null)).isEqualTo(0);
+	@Deprecated
+	void nullSafeHashCodeWithObjectBeingIntArray() {
+		Object array = new int[] {89, 32};
+		int expected = ObjectUtils.nullSafeHashCode((int[]) array);
+		assertEqualHashCodes(expected, array);
 	}
 
 	@Test
+	@Deprecated
+	void nullSafeHashCodeWithNullLongArray() {
+		long[] array = null;
+		assertThat(ObjectUtils.nullSafeHashCode(array)).isEqualTo(0);
+	}
+
+	@Test
+	@Deprecated
 	void nullSafeHashCodeWithLongArray() {
-		long lng = 7993L;
-		int expected = 31 * 7 + (int) (lng ^ (lng >>> 32));
-		lng = 84320L;
-		expected = 31 * expected + (int) (lng ^ (lng >>> 32));
-
 		long[] array = {7993L, 84320L};
 		int actual = ObjectUtils.nullSafeHashCode(array);
-
-		assertThat(actual).isEqualTo(expected);
+		assertThat(actual).isEqualTo(Arrays.hashCode(array));
 	}
 
 	@Test
-	void nullSafeHashCodeWithLongArrayEqualToNull() {
-		assertThat(ObjectUtils.nullSafeHashCode((long[]) null)).isEqualTo(0);
+	@Deprecated
+	void nullSafeHashCodeWithObjectBeingLongArray() {
+		Object array = new long[] {4389, 320};
+		int expected = ObjectUtils.nullSafeHashCode((long[]) array);
+		assertEqualHashCodes(expected, array);
+	}
+
+	@Test
+	@Deprecated
+	void nullSafeHashCodeWithNullShortArray() {
+		short[] array = null;
+		assertThat(ObjectUtils.nullSafeHashCode(array)).isEqualTo(0);
+	}
+
+	@Test
+	@Deprecated
+	void nullSafeHashCodeWithShortArray() {
+		short[] array = {4, 25};
+		int actual = ObjectUtils.nullSafeHashCode(array);
+		assertThat(actual).isEqualTo(Arrays.hashCode(array));
+	}
+
+	@Test
+	@Deprecated
+	void nullSafeHashCodeWithObjectBeingShortArray() {
+		Object array = new short[] {5, 3};
+		int expected = ObjectUtils.nullSafeHashCode((short[]) array);
+		assertEqualHashCodes(expected, array);
 	}
 
 	@Test
@@ -501,71 +581,21 @@ class ObjectUtilsTests {
 	}
 
 	@Test
+	@Deprecated
 	void nullSafeHashCodeWithObjectArray() {
-		int expected = 31 * 7 + "Leia".hashCode();
-		expected = 31 * expected + "Han".hashCode();
-
 		Object[] array = {"Leia", "Han"};
 		int actual = ObjectUtils.nullSafeHashCode(array);
-
-		assertThat(actual).isEqualTo(expected);
+		assertThat(actual).isEqualTo(Arrays.hashCode(array));
 	}
 
 	@Test
+	@Deprecated
 	void nullSafeHashCodeWithObjectArrayEqualToNull() {
 		assertThat(ObjectUtils.nullSafeHashCode((Object[]) null)).isEqualTo(0);
 	}
 
 	@Test
-	void nullSafeHashCodeWithObjectBeingBooleanArray() {
-		Object array = new boolean[] {true, false};
-		int expected = ObjectUtils.nullSafeHashCode((boolean[]) array);
-		assertEqualHashCodes(expected, array);
-	}
-
-	@Test
-	void nullSafeHashCodeWithObjectBeingByteArray() {
-		Object array = new byte[] {6, 39};
-		int expected = ObjectUtils.nullSafeHashCode((byte[]) array);
-		assertEqualHashCodes(expected, array);
-	}
-
-	@Test
-	void nullSafeHashCodeWithObjectBeingCharArray() {
-		Object array = new char[] {'l', 'M'};
-		int expected = ObjectUtils.nullSafeHashCode((char[]) array);
-		assertEqualHashCodes(expected, array);
-	}
-
-	@Test
-	void nullSafeHashCodeWithObjectBeingDoubleArray() {
-		Object array = new double[] {68930.993, 9022.009};
-		int expected = ObjectUtils.nullSafeHashCode((double[]) array);
-		assertEqualHashCodes(expected, array);
-	}
-
-	@Test
-	void nullSafeHashCodeWithObjectBeingFloatArray() {
-		Object array = new float[] {9.9f, 9.54f};
-		int expected = ObjectUtils.nullSafeHashCode((float[]) array);
-		assertEqualHashCodes(expected, array);
-	}
-
-	@Test
-	void nullSafeHashCodeWithObjectBeingIntArray() {
-		Object array = new int[] {89, 32};
-		int expected = ObjectUtils.nullSafeHashCode((int[]) array);
-		assertEqualHashCodes(expected, array);
-	}
-
-	@Test
-	void nullSafeHashCodeWithObjectBeingLongArray() {
-		Object array = new long[] {4389, 320};
-		int expected = ObjectUtils.nullSafeHashCode((long[]) array);
-		assertEqualHashCodes(expected, array);
-	}
-
-	@Test
+	@Deprecated
 	void nullSafeHashCodeWithObjectBeingObjectArray() {
 		Object array = new Object[] {"Luke", "Anakin"};
 		int expected = ObjectUtils.nullSafeHashCode((Object[]) array);
@@ -573,31 +603,10 @@ class ObjectUtilsTests {
 	}
 
 	@Test
-	void nullSafeHashCodeWithObjectBeingShortArray() {
-		Object array = new short[] {5, 3};
-		int expected = ObjectUtils.nullSafeHashCode((short[]) array);
-		assertEqualHashCodes(expected, array);
-	}
-
-	@Test
+	@Deprecated
 	void nullSafeHashCodeWithObjectEqualToNull() {
-		assertThat(ObjectUtils.nullSafeHashCode((Object) null)).isEqualTo(0);
-	}
-
-	@Test
-	void nullSafeHashCodeWithShortArray() {
-		int expected = 31 * 7 + 70;
-		expected = 31 * expected + 8;
-
-		short[] array = {70, 8};
-		int actual = ObjectUtils.nullSafeHashCode(array);
-
-		assertThat(actual).isEqualTo(expected);
-	}
-
-	@Test
-	void nullSafeHashCodeWithShortArrayEqualToNull() {
-		assertThat(ObjectUtils.nullSafeHashCode((short[]) null)).isEqualTo(0);
+		Object[] array = null;
+		assertThat(ObjectUtils.nullSafeHashCode(array)).isEqualTo(0);
 	}
 
 	@Test