Comparing two integer arrays in Java effectively requires understanding the nuances of array comparison. At COMPARE.EDU.VN, we provide a comprehensive guide on the various methods available, ensuring you choose the most appropriate approach for your specific needs. This article explores different techniques, from using the equality operator to employing specialized methods like Arrays.equals() and Arrays.deepEquals(), and provides a clear understanding of their applications. Learn array comparison techniques, deep comparison, and multidimensional array comparison in Java.
1. Introduction to Integer Array Comparison in Java
In Java, directly comparing two integer arrays using the == operator can be misleading. This operator only checks if both arrays reference the same memory location, not whether their contents are identical. To accurately compare the contents of two integer arrays, developers must use methods specifically designed for this purpose. compare.edu.vn is dedicated to simplifying these complexities. Understanding the difference between reference comparison and content comparison is crucial when working with arrays in Java. This article delves into these methods, explaining their functionality and demonstrating their usage with practical examples. You’ll gain insights into techniques like element-by-element comparison, deep comparison for nested arrays, and considerations for multi-dimensional arrays. This knowledge is essential for writing robust and reliable Java code, particularly in applications where data integrity is paramount.
2. The Pitfalls of Using “==” for Array Comparison
The == operator in Java checks for reference equality, meaning it verifies if two variables point to the same object in memory. When applied to arrays, this operator does not compare the elements within the arrays. Instead, it checks if the two array variables refer to the exact same array object.
int[] arr1 = {1, 2, 3};
int[] arr2 = {1, 2, 3};
if (arr1 == arr2) {
System.out.println("Arrays are the same");
} else {
System.out.println("Arrays are not the same");
}Output:
Arrays are not the same2.1. Explanation of Reference Equality
In the example above, arr1 and arr2 are two distinct array objects, even though they contain the same elements. The == operator returns false because arr1 and arr2 refer to different memory locations. This behavior highlights the need for alternative methods to compare array contents effectively. Understanding reference equality is essential for avoiding common pitfalls when working with arrays in Java. To accurately compare the data within the arrays, developers must turn to methods specifically designed for content comparison.
2.2. When “==” Might Seem to Work (But Shouldn’t Be Used)
There are rare cases where the == operator might appear to work correctly when comparing arrays. This happens when two array variables are explicitly made to point to the same array object.
int[] arr1 = {1, 2, 3};
int[] arr2 = arr1; // arr2 now points to the same array as arr1
if (arr1 == arr2) {
System.out.println("Arrays are the same");
} else {
System.out.println("Arrays are not the same");
}Output:
Arrays are the sameWhile the == operator returns true in this case, it’s not because the contents are being compared. It’s because arr1 and arr2 are merely two references to the same array object. Relying on this behavior is dangerous because it doesn’t actually compare the array’s contents. Instead, always use appropriate methods like Arrays.equals() or Arrays.deepEquals() to reliably compare array contents. This ensures that your comparisons are based on the actual data within the arrays, not just their memory addresses.
3. Using Arrays.equals() for Content Comparison
The Arrays.equals() method is a standard and reliable way to compare the contents of two arrays in Java. It checks if two arrays have the same length and if the elements at corresponding indices are equal. This method is suitable for comparing one-dimensional arrays of primitive types or objects.
import java.util.Arrays;
int[] arr1 = {1, 2, 3};
int[] arr2 = {1, 2, 3};
if (Arrays.equals(arr1, arr2)) {
System.out.println("Arrays are equal");
} else {
System.out.println("Arrays are not equal");
}Output:
Arrays are equalArrays.equals() provides a straightforward and accurate way to compare array contents, ensuring that you’re evaluating the data within the arrays, not just their references. This method is widely used and recommended for its simplicity and reliability.
3.1. Syntax and Parameters of Arrays.equals()
The Arrays.equals() method has a simple syntax. It takes two arrays as input and returns a boolean value indicating whether the arrays are equal.
public static boolean equals(type[] a, type[] a2)a: The first array to compare.a2: The second array to compare.type: This refers to the data type of the array elements, which can be primitive types (likeint,char,boolean) or object types (likeString,Integer, custom classes).
3.2. Comparing Arrays of Primitive Types
Arrays.equals() works seamlessly with arrays of primitive types such as int, char, boolean, byte, short, long, float, and double. It compares the elements at corresponding indices for equality.
import java.util.Arrays;
int[] intArr1 = {1, 2, 3};
int[] intArr2 = {1, 2, 3};
System.out.println("Integer arrays equal: " + Arrays.equals(intArr1, intArr2)); // Output: true
char[] charArr1 = {'a', 'b', 'c'};
char[] charArr2 = {'a', 'b', 'c'};
System.out.println("Character arrays equal: " + Arrays.equals(charArr1, charArr2)); // Output: true
boolean[] boolArr1 = {true, false, true};
boolean[] boolArr2 = {true, false, true};
System.out.println("Boolean arrays equal: " + Arrays.equals(boolArr1, boolArr2)); // Output: trueThis ensures that elements of the same type are accurately compared, providing a reliable way to determine if the arrays are identical.
3.3. Comparing Arrays of Objects
When comparing arrays of objects, Arrays.equals() uses the equals() method of the objects to determine equality. It’s crucial that the objects in the array have a properly implemented equals() method. If the equals() method is not overridden, the default implementation (from the Object class) will compare object references, which might not be the desired behavior.
import java.util.Arrays;
class Dog {
String name;
public Dog(String name) {
this.name = name;
}
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (obj == null || getClass() != obj.getClass()) return false;
Dog dog = (Dog) obj;
return name.equals(dog.name);
}
}
public class Main {
public static void main(String[] args) {
Dog[] dogs1 = {new Dog("Buddy"), new Dog("Lucy")};
Dog[] dogs2 = {new Dog("Buddy"), new Dog("Lucy")};
System.out.println("Dog arrays equal: " + Arrays.equals(dogs1, dogs2)); // Output: true
}
}In the example above, the Dog class overrides the equals() method to compare the names of the dogs. This ensures that Arrays.equals() correctly compares the contents of the Dog arrays.
3.4. Limitations of Arrays.equals()
Arrays.equals() has limitations when dealing with multi-dimensional arrays or nested arrays. It performs a shallow comparison, meaning it only compares the references of the inner arrays, not their contents.
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] arr1 = {1, 2, 3};
int[] arr2 = {1, 2, 3};
Object[] outerArr1 = {arr1};
Object[] outerArr2 = {arr2};
System.out.println("Outer arrays equal: " + Arrays.equals(outerArr1, outerArr2)); // Output: false
}
}In this case, even though arr1 and arr2 have the same contents, Arrays.equals() returns false because outerArr1 and outerArr2 contain different array objects. For deep comparison of multi-dimensional arrays, you need to use Arrays.deepEquals().
4. Deep Comparison with Arrays.deepEquals()
For comparing multi-dimensional arrays or arrays containing nested objects, Arrays.deepEquals() is the appropriate method. It performs a deep comparison, recursively comparing the elements of the arrays and their nested structures. This ensures that the entire structure and content of the arrays are compared for equality.
4.1. When to Use Arrays.deepEquals()
Use Arrays.deepEquals() when you need to compare arrays that contain other arrays or objects as elements. This is particularly useful for multi-dimensional arrays, nested arrays, or arrays of custom objects where the equality of the objects needs to be determined by their contents rather than their references. Arrays.deepEquals() ensures that the comparison goes beyond the surface level, delving into the contents of nested structures to determine true equality.
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] arr1 = {1, 2, 3};
int[] arr2 = {1, 2, 3};
Object[] outerArr1 = {arr1};
Object[] outerArr2 = {arr2};
System.out.println("Outer arrays deep equal: " + Arrays.deepEquals(outerArr1, outerArr2)); // Output: true
}
}4.2. Comparing Multi-Dimensional Arrays
Arrays.deepEquals() is specifically designed for comparing multi-dimensional arrays. It recursively traverses the array structure, comparing elements at each level.
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[][] matrix1 = {{1, 2}, {3, 4}};
int[][] matrix2 = {{1, 2}, {3, 4}};
System.out.println("Matrices deep equal: " + Arrays.deepEquals(matrix1, matrix2)); // Output: true
}
}4.3. Comparing Arrays with Nested Objects
When dealing with arrays containing nested objects, Arrays.deepEquals() uses the equals() method of the objects for comparison. This ensures that the comparison is based on the contents of the objects, not just their references.
import java.util.Arrays;
class Point {
int x, y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (obj == null || getClass() != obj.getClass()) return false;
Point point = (Point) obj;
return x == point.x && y == point.y;
}
}
public class Main {
public static void main(String[] args) {
Point[] points1 = {new Point(1, 2), new Point(3, 4)};
Point[] points2 = {new Point(1, 2), new Point(3, 4)};
Object[] outerArr1 = {points1};
Object[] outerArr2 = {points2};
System.out.println("Outer arrays deep equal: " + Arrays.deepEquals(outerArr1, outerArr2)); // Output: true
}
}In this example, the Point class overrides the equals() method to compare the x and y coordinates. Arrays.deepEquals() uses this method to compare the Point objects in the arrays.
4.4. Limitations and Considerations
Arrays.deepEquals() can handle cyclic object graphs without entering an endless loop due to its cycle detection mechanism. However, it’s essential to ensure that the equals() methods of the objects in the arrays are properly implemented to avoid unexpected results. Additionally, using Arrays.deepEquals() can be more resource-intensive than Arrays.equals() due to its recursive nature, so it should be used judiciously.
5. Implementing Custom Comparison Logic
In some cases, the default comparison behavior provided by Arrays.equals() and Arrays.deepEquals() might not be sufficient. You may need to implement custom comparison logic based on specific criteria. This can be achieved by iterating through the arrays and applying your own comparison rules.
5.1. Using Loops for Element-by-Element Comparison
One way to implement custom comparison logic is to use loops to iterate through the arrays and compare elements individually. This approach provides fine-grained control over the comparison process.
public class Main {
public static boolean customEquals(int[] arr1, int[] arr2) {
if (arr1 == null && arr2 == null) return true;
if (arr1 == null || arr2 == null) return false;
if (arr1.length != arr2.length) return false;
for (int i = 0; i < arr1.length; i++) {
if (arr1[i] != arr2[i]) {
return false;
}
}
return true;
}
public static void main(String[] args) {
int[] arr1 = {1, 2, 3};
int[] arr2 = {1, 2, 3};
int[] arr3 = {1, 2, 4};
System.out.println("Arrays arr1 and arr2 custom equal: " + customEquals(arr1, arr2)); // Output: true
System.out.println("Arrays arr1 and arr3 custom equal: " + customEquals(arr1, arr3)); // Output: false
}
}This method allows you to implement specific comparison rules, such as ignoring certain elements or applying custom transformations before comparison.
5.2. Implementing a Custom Comparator
For more complex comparison scenarios, you can implement a custom Comparator. A Comparator is an interface that defines a method for comparing two objects. By implementing a custom Comparator, you can define your own comparison logic and use it with methods like Arrays.sort() or custom comparison functions.
import java.util.Arrays;
import java.util.Comparator;
class Student {
String name;
int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
}
class AgeComparator implements Comparator<Student> {
@Override
public int compare(Student s1, Student s2) {
return Integer.compare(s1.age, s2.age);
}
}
public class Main {
public static void main(String[] args) {
Student[] students = {
new Student("Alice", 20),
new Student("Bob", 22),
new Student("Charlie", 21)
};
Arrays.sort(students, new AgeComparator());
for (Student student : students) {
System.out.println(student.name + " " + student.age);
}
}
}5.3. Considerations for Performance
When implementing custom comparison logic, it’s essential to consider performance implications. Iterating through arrays and applying complex comparison rules can be time-consuming, especially for large arrays. Optimize your comparison logic by minimizing unnecessary computations and using efficient data structures. If performance is critical, consider using optimized libraries or algorithms for array comparison.
6. Comparing Arrays of Different Data Types
When comparing arrays of different data types, you need to consider how to handle the type differences. Java’s strong typing requires explicit type conversions or casting when comparing values of different types.
6.1. Type Conversion and Casting
If you need to compare arrays of different numeric types (e.g., int[] and double[]), you can convert the elements to a common type before comparison. Be aware of potential loss of precision when converting from double to int.
public class Main {
public static boolean compareIntDoubleArrays(int[] intArr, double[] doubleArr) {
if (intArr.length != doubleArr.length) return false;
for (int i = 0; i < intArr.length; i++) {
if ((double) intArr[i] != doubleArr[i]) {
return false;
}
}
return true;
}
public static void main(String[] args) {
int[] intArr = {1, 2, 3};
double[] doubleArr = {1.0, 2.0, 3.0};
System.out.println("Arrays equal: " + compareIntDoubleArrays(intArr, doubleArr)); // Output: true
}
}6.2. Handling Different Object Types
When comparing arrays of different object types, you need to ensure that the comparison logic is appropriate for the types involved. You might need to use instanceof to check the type of the objects and apply different comparison rules accordingly.
public class Main {
public static boolean compareObjectArrays(Object[] arr1, Object[] arr2) {
if (arr1.length != arr2.length) return false;
for (int i = 0; i < arr1.length; i++) {
if (arr1[i] instanceof Integer && arr2[i] instanceof Double) {
if (((Integer) arr1[i]).doubleValue() != ((Double) arr2[i])) {
return false;
}
} else if (!arr1[i].equals(arr2[i])) {
return false;
}
}
return true;
}
public static void main(String[] args) {
Object[] arr1 = {1, 2, 3};
Object[] arr2 = {1.0, 2.0, 3.0};
System.out.println("Arrays equal: " + compareObjectArrays(arr1, arr2)); // Output: true
}
}6.3. Best Practices for Mixed-Type Comparisons
- Use a common interface: If possible, use a common interface that both types implement.
- Handle null values: Be sure to handle null values appropriately to avoid
NullPointerException. - Document your assumptions: Document any assumptions made about the types and their comparison logic.
7. Comparing Large Arrays Efficiently
When dealing with large arrays, performance becomes a critical consideration. Naive comparison methods can be inefficient and time-consuming. Optimizing the comparison process is essential to ensure that your application remains responsive and scalable.
7.1. Optimizing Loops
When using loops for element-by-element comparison, there are several ways to optimize the process:
-
Minimize computations: Avoid unnecessary computations within the loop.
-
Cache array lengths: Cache the array lengths to avoid repeated access.
-
Unroll loops: Unroll loops to reduce loop overhead.
-
Use enhanced for loops: Enhanced for loops can be more efficient for simple iterations.
public class Main { public static boolean optimizedEquals(int[] arr1, int[] arr2) { int length = arr1.length; if (length != arr2.length) return false; for (int i = 0; i < length; i++) { if (arr1[i] != arr2[i]) { return false; } } return true; } public static void main(String[] args) { int[] arr1 = new int[1000000]; int[] arr2 = new int[1000000]; Arrays.fill(arr1, 1); Arrays.fill(arr2, 1); long startTime = System.nanoTime(); boolean isEqual = optimizedEquals(arr1, arr2); long endTime = System.nanoTime(); System.out.println("Arrays equal: " + isEqual); System.out.println("Time taken: " + (endTime - startTime) / 1000000 + " ms"); } }
7.2. Using Hash Codes for Quick Comparison
Hash codes can be used for quick comparison of arrays. If the hash codes of two arrays are different, the arrays are definitely not equal. However, if the hash codes are the same, the arrays might be equal, so you still need to compare the elements.
import java.util.Arrays;
public class Main {
public static boolean hashCodeEquals(int[] arr1, int[] arr2) {
if (arr1.length != arr2.length) return false;
int hashCode1 = Arrays.hashCode(arr1);
int hashCode2 = Arrays.hashCode(arr2);
if (hashCode1 != hashCode2) return false;
return Arrays.equals(arr1, arr2);
}
public static void main(String[] args) {
int[] arr1 = {1, 2, 3};
int[] arr2 = {1, 2, 3};
System.out.println("Arrays equal: " + hashCodeEquals(arr1, arr2));
}
}7.3. Parallel Processing
For very large arrays, you can use parallel processing to speed up the comparison. Divide the arrays into smaller chunks and compare them in parallel using multiple threads or executors. This can significantly reduce the comparison time.
import java.util.Arrays;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
public class Main {
public static boolean parallelEquals(int[] arr1, int[] arr2, int numThreads) throws InterruptedException {
if (arr1.length != arr2.length) return false;
int length = arr1.length;
ExecutorService executor = Executors.newFixedThreadPool(numThreads);
AtomicBoolean isEqual = new AtomicBoolean(true);
int chunkSize = (int) Math.ceil((double) length / numThreads);
for (int i = 0; i < numThreads; i++) {
int start = i * chunkSize;
int end = Math.min(start + chunkSize, length);
executor.execute(() -> {
for (int j = start; j < end; j++) {
if (arr1[j] != arr2[j]) {
isEqual.set(false);
break;
}
}
});
}
executor.shutdown();
executor.awaitTermination(1, TimeUnit.MINUTES);
return isEqual.get();
}
public static void main(String[] args) throws InterruptedException {
int[] arr1 = new int[1000000];
int[] arr2 = new int[1000000];
Arrays.fill(arr1, 1);
Arrays.fill(arr2, 1);
long startTime = System.nanoTime();
boolean isEqual = parallelEquals(arr1, arr2, 4);
long endTime = System.nanoTime();
System.out.println("Arrays equal: " + isEqual);
System.out.println("Time taken: " + (endTime - startTime) / 1000000 + " ms");
}
}7.4. Using Libraries
Consider using optimized libraries like Apache Commons Lang or Guava, which provide utility methods for array comparison. These libraries often implement efficient algorithms and data structures for handling large arrays.
8. Common Mistakes to Avoid
When comparing arrays in Java, there are several common mistakes that developers often make. Avoiding these mistakes can help ensure that your array comparisons are accurate and reliable.
8.1. Using “==” Instead of equals()
As mentioned earlier, using the == operator to compare array contents is a common mistake. This operator only checks if the two array variables refer to the same array object, not whether their contents are identical. Always use Arrays.equals() or Arrays.deepEquals() to compare array contents.
8.2. Not Implementing equals() for Custom Objects
When comparing arrays of custom objects, it’s crucial to implement the equals() method in your custom class. If you don’t implement equals(), the default implementation (from the Object class) will compare object references, which might not be the desired behavior.
class Person {
String name;
int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// Missing equals() method
@Override
public String toString() {
return "Person{" +
"name='" + name + ''' +
", age=" + age +
'}';
}
}
public class Main {
public static void main(String[] args) {
Person[] people1 = {new Person("Alice", 30), new Person("Bob", 25)};
Person[] people2 = {new Person("Alice", 30), new Person("Bob", 25)};
System.out.println("Arrays equal: " + Arrays.equals(people1, people2)); // Output: false
}
}In the example above, the Person class does not implement the equals() method. As a result, Arrays.equals() compares the object references, not their contents, and returns false.
8.3. Ignoring Null Values
When comparing arrays, it’s important to handle null values appropriately. If an array or an element within the array is null, you need to check for it to avoid NullPointerException.
public class Main {
public static boolean safeEquals(int[] arr1, int[] arr2) {
if (arr1 == null && arr2 == null) return true;
if (arr1 == null || arr2 == null) return false;
return Arrays.equals(arr1, arr2);
}
public static void main(String[] args) {
int[] arr1 = {1, 2, 3};
int[] arr2 = null;
System.out.println("Arrays equal: " + safeEquals(arr1, arr2)); // Output: false
}
}8.4. Not Considering Multi-Dimensional Arrays
When comparing multi-dimensional arrays, using Arrays.equals() will not work as expected. You need to use Arrays.deepEquals() to compare the contents of the nested arrays recursively.
8.5. Assuming Arrays are Sorted
Some comparison algorithms assume that the arrays are sorted. If your arrays are not sorted, you need to sort them before comparing them, or use a comparison algorithm that doesn’t require sorted arrays.
9. Best Practices for Array Comparison
To ensure that your array comparisons are accurate, reliable, and efficient, follow these best practices:
- Use the appropriate method: Choose the appropriate method based on the type of arrays you are comparing (
Arrays.equals()for one-dimensional arrays andArrays.deepEquals()for multi-dimensional arrays). - Implement
equals()for custom objects: Implement theequals()method in your custom classes to ensure that objects are compared based on their contents. - Handle null values: Check for null values to avoid
NullPointerException. - Consider performance: Optimize your comparison logic to ensure that it is efficient, especially for large arrays.
- Use libraries: Consider using optimized libraries like Apache Commons Lang or Guava for array comparison.
- Write unit tests: Write unit tests to verify that your array comparison logic works correctly.
By following these best practices, you can avoid common mistakes and ensure that your array comparisons are accurate, reliable, and efficient.
10. Practical Examples and Use Cases
To illustrate the practical applications of array comparison in Java, let’s consider some real-world examples and use cases.
10.1. Comparing Test Results
In software testing, it’s common to compare the expected output of a test case with the actual output. If the output is stored in arrays, you can use array comparison to verify that the test case passed.
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] expectedOutput = {1, 2, 3, 4, 5};
int[] actualOutput = {1, 2, 3, 4, 5};
if (Arrays.equals(expectedOutput, actualOutput)) {
System.out.println("Test case passed");
} else {
System.out.println("Test case failed");
}
}
}10.2. Comparing Image Data
In image processing, images are often represented as multi-dimensional arrays of pixel data. You can use array comparison to compare two images and determine if they are identical.
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[][] image1 = {{1, 2}, {3, 4}};
int[][] image2 = {{1, 2}, {3, 4}};
if (Arrays.deepEquals(image1, image2)) {
System.out.println("Images are identical");
} else {
System.out.println("Images are different");
}
}
}10.3. Comparing Game States
In game development, the state of a game is often represented as arrays of data. You can use array comparison to compare two game states and determine if they are the same.
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] gameState1 = {1, 0, 2, 1, 0};
int[] gameState2 = {1, 0, 2, 1, 0};
if (Arrays.equals(gameState1, gameState2)) {
System.out.println("Game states are the same");
} else {
System.out.println("Game states are different");
}
}
}10.4. Comparing Data from Different Sources
In data processing, you might need to compare data from different sources to ensure consistency. If the data is stored in arrays, you can use array comparison to verify that the data is the same.
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
String[] data1 = {"Alice", "Bob", "Charlie"};
String[] data2 = {"Alice", "Bob", "Charlie"};
if (Arrays.equals(data1, data2)) {
System.out.println("Data is consistent");
} else {
System.out.println("Data is inconsistent");
}
}
}11. Advanced Techniques and Considerations
Beyond the basic methods for array comparison, there are several advanced techniques and considerations that can be useful in specific scenarios.
11.1. Bitwise Comparison
For arrays of boolean values or arrays of integers where each bit represents a boolean value, bitwise comparison can be an efficient way to compare the arrays. Bitwise comparison involves performing bitwise operations (e.g., AND, OR, XOR) on the elements of the arrays and comparing the results.
public class Main {
public static boolean bitwiseEquals(int[] arr1, int[] arr2) {
if (arr1.length != arr2.length) return false;
for (int i = 0; i < arr1.length; i++) {
if ((arr1[i] ^ arr2[i]) != 0) {
return false;
}
}
return true;
}
public static void main(String[] args) {
int[] arr1 = {5, 10, 15}; // Binary: 0101, 1010, 1111
int[] arr2 = {5, 10, 15}; // Binary: 0101, 1010, 1111
System.out.println("Arrays equal: " + bitwiseEquals(arr1, arr2));
}
}11.2. Using Hashing Algorithms
Hashing algorithms like MD5 or SHA-256 can be used to generate hash codes for arrays. Comparing the hash codes of two arrays can be a quick way to determine if they are different. However, if the hash codes are the same, you still need to compare the elements to ensure that the arrays are identical.
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
public class Main {
public static String hashArray(int[] arr) throws NoSuchAlgorithmException {
MessageDigest md = MessageDigest.getInstance("SHA-256");
byte[] byteArray = new byte[arr.length * 4];
for (int i = 0; i < arr.length; i++) {
intToBytes(arr[i], byteArray, i * 4);
}
byte[] hashBytes = md.digest(byteArray);
StringBuilder sb = new StringBuilder();
for (byte b : hashBytes) {
sb.append(String.format("%02x", b));
}
return sb.toString();
}
private static void intToBytes(int value, byte[] byteArray, int offset) {
byteArray[offset + 0] = (byte) (value >>> 24);
byteArray[offset + 1] = (byte) (value >>> 16);
byteArray[offset + 2] = (byte) (value >>> 8);
byteArray[offset + 3] = (byte) (value >>> 0);
}
public static boolean hashEquals(int[] arr1, int[] arr2) throws NoSuchAlgorithmException {
String hash1 =