Comparing elements within an array in Java is a fundamental task in programming. At COMPARE.EDU.VN, we provide detailed guides on how to efficiently and effectively compare elements in Java arrays. This comprehensive guide explores various methods and techniques, ensuring you can choose the best approach for your specific needs. Discover expert advice and clear explanations to master array comparison in Java.
1. What Are the Different Ways to Compare Elements in an Array in Java?
There are several ways to compare elements in an array in Java, each with its own advantages and use cases. These methods range from simple iterative approaches to leveraging Java’s built-in utilities. Here’s an overview of the common techniques:
- Iterative Comparison: This involves looping through the array and comparing each element with others using
ifstatements. - Using
Arrays.equals(): This method is used to compare two arrays to see if they are equal. - Using
Arrays.deepEquals(): This method is used to compare multi-dimensional arrays. - Using the
ComparableInterface: This interface is used when comparing objects based on their natural ordering. - Using the
ComparatorInterface: This interface allows you to define custom comparison logic. - Using Java Streams: Streams provide a functional way to compare elements using methods like
anyMatch(),allMatch(), andnoneMatch(). - Using Data Structures (e.g., Sets): Converting arrays to sets can help in identifying unique elements and comparing arrays based on their contents.
Each of these methods will be detailed in the following sections, providing you with a thorough understanding of how to compare elements in an array in Java.
2. How to Use Iterative Comparison in Java Arrays?
Iterative comparison is a basic yet powerful method for comparing elements within a Java array. This approach involves using loops to traverse the array and if statements to check for specific conditions or relationships between elements.
2.1. Basic Iterative Comparison
The simplest form of iterative comparison involves comparing each element with every other element in the array. This is useful for finding duplicates, identifying the largest or smallest element, or checking if the array is sorted.
public class IterativeComparison {
public static void main(String[] args) {
int[] numbers = {5, 2, 8, 1, 9, 2};
// Find duplicates
for (int i = 0; i < numbers.length; i++) {
for (int j = i + 1; j < numbers.length; j++) {
if (numbers[i] == numbers[j]) {
System.out.println("Duplicate found: " + numbers[i]);
}
}
}
// Find the largest number
int largest = numbers[0];
for (int i = 1; i < numbers.length; i++) {
if (numbers[i] > largest) {
largest = numbers[i];
}
}
System.out.println("Largest number: " + largest);
}
}In this example, the first nested loop finds duplicate elements, and the second loop identifies the largest number in the array.
2.2. Comparing Adjacent Elements
Another common use case is comparing adjacent elements in the array. This is particularly useful for checking if an array is sorted in ascending or descending order.
public class AdjacentComparison {
public static void main(String[] args) {
int[] numbers = {1, 2, 3, 4, 5, 6};
boolean isSorted = true;
for (int i = 0; i < numbers.length - 1; i++) {
if (numbers[i] > numbers[i + 1]) {
isSorted = false;
break;
}
}
if (isSorted) {
System.out.println("Array is sorted in ascending order.");
} else {
System.out.println("Array is not sorted in ascending order.");
}
}
}This code checks if the array numbers is sorted in ascending order by comparing each element with the next one.
2.3. Custom Comparison Logic
Iterative comparison allows you to implement custom comparison logic based on specific requirements. For example, you can compare elements based on a certain condition or criteria.
public class CustomComparison {
public static void main(String[] args) {
String[] words = {"apple", "banana", "apricot", "kiwi", "orange"};
// Find words starting with 'a'
System.out.println("Words starting with 'a':");
for (String word : words) {
if (word.startsWith("a")) {
System.out.println(word);
}
}
}
}Here, the code iterates through an array of strings and prints out the words that start with the letter ‘a’.
2.4. Advantages and Disadvantages
Advantages:
- Simple and Easy to Understand: Iterative comparison is straightforward and doesn’t require complex syntax or libraries.
- Flexible: You can implement any comparison logic you need.
- Control: You have full control over the comparison process.
Disadvantages:
- Potentially Inefficient: For large arrays, iterative comparison can be slow, especially with nested loops.
- Verbose: It can require more code compared to using built-in methods.
Iterative comparison is a fundamental technique for comparing elements in Java arrays. While it may not always be the most efficient method, its simplicity and flexibility make it a valuable tool for many scenarios. For more complex comparison needs, consider exploring other methods such as using the Comparable or Comparator interfaces, or Java Streams, as discussed in other sections of this guide at COMPARE.EDU.VN.
3. How to Use Arrays.equals() to Compare Java Arrays?
The Arrays.equals() method is a convenient way to compare two arrays in Java to determine if they are equal. This method checks if the two arrays have the same number of elements and if the corresponding elements in the two arrays are equal.
3.1. Basic Usage of Arrays.equals()
The simplest way to use Arrays.equals() is to pass two arrays of the same type as arguments. The method returns true if the arrays are equal and false otherwise.
import java.util.Arrays;
public class ArrayEqualsExample {
public static void main(String[] args) {
int[] arr1 = {1, 2, 3, 4, 5};
int[] arr2 = {1, 2, 3, 4, 5};
int[] arr3 = {5, 4, 3, 2, 1};
System.out.println("arr1 equals arr2: " + Arrays.equals(arr1, arr2)); // Output: true
System.out.println("arr1 equals arr3: " + Arrays.equals(arr1, arr3)); // Output: false
}
}In this example, arr1 and arr2 are equal because they have the same elements in the same order, while arr1 and arr3 are not equal.
3.2. Comparing Arrays of Objects
Arrays.equals() can also be used to compare arrays of objects. However, it’s important to note that the method uses the equals() method of the objects to determine equality. Therefore, the objects in the array must properly implement the equals() method.
import java.util.Arrays;
class Dog {
String name;
int age;
public Dog(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (obj == null || getClass() != obj.getClass()) return false;
Dog dog = (Dog) obj;
return age == dog.age && name.equals(dog.name);
}
}
public class ObjectArrayEquals {
public static void main(String[] args) {
Dog[] dogs1 = {new Dog("Buddy", 3), new Dog("Lucy", 5)};
Dog[] dogs2 = {new Dog("Buddy", 3), new Dog("Lucy", 5)};
Dog[] dogs3 = {new Dog("Buddy", 3), new Dog("Max", 4)};
System.out.println("dogs1 equals dogs2: " + Arrays.equals(dogs1, dogs2)); // Output: true
System.out.println("dogs1 equals dogs3: " + Arrays.equals(dogs1, dogs3)); // Output: false
}
}In this example, the Dog class overrides the equals() method to compare Dog objects based on their name and age.
3.3. Comparing Subarrays
Arrays.equals() can also be used to compare specific portions of arrays using the Arrays.equals(array1, fromIndex1, toIndex1, array2, fromIndex2, toIndex2) method.
import java.util.Arrays;
public class SubArrayEquals {
public static void main(String[] args) {
int[] arr1 = {1, 2, 3, 4, 5};
int[] arr2 = {0, 2, 3, 4, 6};
// Compare arr1[1...3] with arr2[1...3]
System.out.println("Subarrays equal: " + Arrays.equals(arr1, 1, 4, arr2, 1, 4)); // Output: true
}
}This code compares the subarray of arr1 from index 1 to 3 with the subarray of arr2 from index 1 to 3.
3.4. Advantages and Disadvantages
Advantages:
- Simple and Concise:
Arrays.equals()provides a straightforward way to compare arrays. - Handles Object Arrays: It works with arrays of objects as long as the objects have a proper
equals()implementation. - Subarray Comparison: It can compare specific portions of arrays.
Disadvantages:
- Order Matters: The order of elements must be the same for the arrays to be considered equal.
- Shallow Comparison: For object arrays, it performs a shallow comparison using the
equals()method of the objects.
Arrays.equals() is a useful method for comparing arrays in Java. It is simple, concise, and can handle arrays of primitive types and objects. However, it’s important to remember that the order of elements matters and that object arrays require a proper equals() implementation. For comparing multi-dimensional arrays, you should use Arrays.deepEquals(), which is discussed in the next section at COMPARE.EDU.VN.
4. How to Use Arrays.deepEquals() to Compare Multi-Dimensional Arrays in Java?
When working with multi-dimensional arrays in Java, comparing them for equality requires a different approach than using Arrays.equals(), which only performs a shallow comparison. The Arrays.deepEquals() method is designed specifically for comparing multi-dimensional arrays, ensuring that the elements within nested arrays are also compared.
4.1. Understanding Arrays.deepEquals()
The Arrays.deepEquals() method is part of the java.util.Arrays class and provides a way to deeply compare two arrays. It recursively compares the elements of the arrays, including nested arrays, to determine if they are equal.
4.2. Basic Usage of Arrays.deepEquals()
To use Arrays.deepEquals(), you simply pass the two multi-dimensional arrays you want to compare as arguments. The method returns true if the arrays are deeply equal and false otherwise.
import java.util.Arrays;
public class DeepEqualsExample {
public static void main(String[] args) {
int[][] arr1 = {{1, 2}, {3, 4}};
int[][] arr2 = {{1, 2}, {3, 4}};
int[][] arr3 = {{1, 2}, {3, 5}};
System.out.println("arr1 deep equals arr2: " + Arrays.deepEquals(arr1, arr2)); // Output: true
System.out.println("arr1 deep equals arr3: " + Arrays.deepEquals(arr1, arr3)); // Output: false
}
}In this example, arr1 and arr2 are deeply equal because they have the same elements in the same nested structure, while arr1 and arr3 are not deeply equal because one of their elements differs.
4.3. Comparing Multi-Dimensional Arrays of Objects
Arrays.deepEquals() can also be used to compare multi-dimensional arrays of objects. As with Arrays.equals(), it relies on the equals() method of the objects to determine equality. Therefore, the objects in the array must properly implement the equals() method.
import java.util.Arrays;
class Point {
int x;
int 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 DeepEqualsObjectArray {
public static void main(String[] args) {
Point[][] points1 = {{new Point(1, 2), new Point(3, 4)}, {new Point(5, 6), new Point(7, 8)}};
Point[][] points2 = {{new Point(1, 2), new Point(3, 4)}, {new Point(5, 6), new Point(7, 8)}};
Point[][] points3 = {{new Point(1, 2), new Point(3, 4)}, {new Point(5, 6), new Point(7, 9)}};
System.out.println("points1 deep equals points2: " + Arrays.deepEquals(points1, points2)); // Output: true
System.out.println("points1 deep equals points3: " + Arrays.deepEquals(points1, points3)); // Output: false
}
}In this example, the Point class overrides the equals() method to compare Point objects based on their x and y coordinates.
4.4. Advantages and Disadvantages
Advantages:
- Deep Comparison:
Arrays.deepEquals()performs a deep comparison of multi-dimensional arrays, including nested arrays. - Handles Object Arrays: It works with arrays of objects as long as the objects have a proper
equals()implementation. - Recursive Comparison: It recursively compares elements, ensuring all levels of the array are checked.
Disadvantages:
- Order Matters: The order of elements must be the same for the arrays to be considered deeply equal.
- Performance: Deep comparison can be slower than shallow comparison, especially for large arrays.
Arrays.deepEquals() is an essential method for comparing multi-dimensional arrays in Java. It ensures that the elements within nested arrays are also compared, providing a thorough comparison. However, it’s important to remember that the order of elements matters and that object arrays require a proper equals() implementation. For comparing arrays based on custom criteria or ordering, consider using the Comparable or Comparator interfaces, which are discussed in other sections of this guide at COMPARE.EDU.VN.
5. How to Use the Comparable Interface to Compare Java Objects in an Array?
The Comparable interface in Java is used to define a natural ordering for objects of a class. When a class implements the Comparable interface, it provides a way to compare its instances with each other. This is particularly useful when you need to sort or compare objects in an array based on their inherent properties.
5.1. Understanding the Comparable Interface
The Comparable interface is part of the java.lang package and contains a single method, compareTo(). This method compares the current object with another object of the same type and returns an integer value:
- Negative value: If the current object is less than the other object.
- Zero: If the current object is equal to the other object.
- Positive value: If the current object is greater than the other object.
5.2. Implementing the Comparable Interface
To use the Comparable interface, a class must implement it and provide an implementation for the compareTo() method. Here’s an example of a Student class implementing Comparable:
class Student implements Comparable<Student> {
String name;
int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public int compareTo(Student other) {
// Compare based on age
return Integer.compare(this.age, other.age);
}
@Override
public String toString() {
return "Student{name='" + name + "', age=" + age + '}';
}
}In this example, the compareTo() method compares Student objects based on their age.
5.3. Using Comparable to Sort an Array
Once a class implements the Comparable interface, you can use the Arrays.sort() method to sort an array of objects of that class.
import java.util.Arrays;
public class ComparableExample {
public static void main(String[] args) {
Student[] students = {
new Student("Alice", 20),
new Student("Bob", 22),
new Student("Charlie", 19)
};
Arrays.sort(students);
System.out.println("Sorted students by age:");
for (Student student : students) {
System.out.println(student);
}
}
}This code sorts the students array based on the natural ordering defined by the compareTo() method in the Student class.
5.4. Custom Comparison Logic
The compareTo() method can implement any custom comparison logic you need. For example, you can compare objects based on multiple fields or criteria.
class Student implements Comparable<Student> {
String name;
int age;
double gpa;
public Student(String name, int age, double gpa) {
this.name = name;
this.age = age;
this.gpa = gpa;
}
@Override
public int compareTo(Student other) {
// Compare based on GPA, then age, then name
int gpaComparison = Double.compare(other.gpa, this.gpa); // Higher GPA first
if (gpaComparison != 0) {
return gpaComparison;
}
int ageComparison = Integer.compare(this.age, other.age);
if (ageComparison != 0) {
return ageComparison;
}
return this.name.compareTo(other.name);
}
@Override
public String toString() {
return "Student{name='" + name + "', age=" + age + ", gpa=" + gpa + '}';
}
}In this example, the compareTo() method compares Student objects based on their GPA (in descending order), then age, and then name.
5.5. Advantages and Disadvantages
Advantages:
- Natural Ordering:
Comparabledefines a natural ordering for objects of a class. - Easy Sorting: It allows you to easily sort arrays of objects using
Arrays.sort(). - Custom Logic: You can implement any custom comparison logic you need.
Disadvantages:
- Single Ordering: A class can only have one natural ordering defined by
Comparable. - Class Modification: You need to modify the class to implement the
Comparableinterface.
The Comparable interface is a powerful tool for defining a natural ordering for objects in Java. It allows you to easily sort and compare objects based on their inherent properties. However, if you need to define multiple comparison strategies or cannot modify the class, consider using the Comparator interface, which is discussed in the next section at COMPARE.EDU.VN.
6. How to Use the Comparator Interface to Compare Java Objects in an Array?
The Comparator interface in Java is used to define a custom ordering for objects of a class. Unlike the Comparable interface, which defines a natural ordering within the class itself, Comparator allows you to create separate classes that define different comparison strategies. This is particularly useful when you need to sort or compare objects in an array based on multiple criteria or when you cannot modify the class directly.
6.1. Understanding the Comparator Interface
The Comparator interface is part of the java.util package and contains a single method, compare(). This method compares two objects and returns an integer value:
- Negative value: If the first object is less than the second object.
- Zero: If the first object is equal to the second object.
- Positive value: If the first object is greater than the second object.
6.2. Implementing the Comparator Interface
To use the Comparator interface, you create a class that implements it and provides an implementation for the compare() method. Here’s an example of a Student class and a StudentNameComparator class:
import java.util.Comparator;
class Student {
String name;
int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Student{name='" + name + "', age=" + age + '}';
}
}
class StudentNameComparator implements Comparator<Student> {
@Override
public int compare(Student s1, Student s2) {
return s1.name.compareTo(s2.name);
}
}In this example, the StudentNameComparator class compares Student objects based on their name.
6.3. Using Comparator to Sort an Array
Once you have a class that implements the Comparator interface, you can use the Arrays.sort() method to sort an array of objects using the custom comparison strategy.
import java.util.Arrays;
public class ComparatorExample {
public static void main(String[] args) {
Student[] students = {
new Student("Alice", 20),
new Student("Bob", 22),
new Student("Charlie", 19)
};
Arrays.sort(students, new StudentNameComparator());
System.out.println("Sorted students by name:");
for (Student student : students) {
System.out.println(student);
}
}
}This code sorts the students array based on the comparison strategy defined by the StudentNameComparator class.
6.4. Multiple Comparison Strategies
One of the key advantages of using Comparator is that you can define multiple comparison strategies for the same class. For example, you can create a StudentAgeComparator class to compare Student objects based on their age.
import java.util.Comparator;
class StudentAgeComparator implements Comparator<Student> {
@Override
public int compare(Student s1, Student s2) {
return Integer.compare(s1.age, s2.age);
}
}You can then use this comparator to sort the students array based on age.
import java.util.Arrays;
public class MultipleComparators {
public static void main(String[] args) {
Student[] students = {
new Student("Alice", 20),
new Student("Bob", 22),
new Student("Charlie", 19)
};
Arrays.sort(students, new StudentAgeComparator());
System.out.println("Sorted students by age:");
for (Student student : students) {
System.out.println(student);
}
}
}6.5. Anonymous Class Implementation
You can also implement the Comparator interface using an anonymous class. This is useful when you need a simple comparison strategy that you don’t want to define as a separate class.
import java.util.Arrays;
import java.util.Comparator;
public class AnonymousComparator {
public static void main(String[] args) {
Student[] students = {
new Student("Alice", 20),
new Student("Bob", 22),
new Student("Charlie", 19)
};
Arrays.sort(students, new Comparator<Student>() {
@Override
public int compare(Student s1, Student s2) {
return s1.name.compareTo(s2.name);
}
});
System.out.println("Sorted students by name (anonymous class):");
for (Student student : students) {
System.out.println(student);
}
}
}6.6. Advantages and Disadvantages
Advantages:
- Multiple Ordering: You can define multiple comparison strategies for the same class.
- No Class Modification: You don’t need to modify the class to define a custom ordering.
- Flexibility: It provides great flexibility in defining comparison logic.
Disadvantages:
- More Code: It can require more code compared to using the
Comparableinterface. - Complexity: It can be more complex to understand and implement.
The Comparator interface is a powerful tool for defining custom ordering for objects in Java. It allows you to sort and compare objects based on multiple criteria and provides great flexibility in defining comparison logic. However, if you only need to define a single, natural ordering for a class, consider using the Comparable interface instead. For more advanced comparison techniques, such as using Java Streams, refer to other sections of this guide at COMPARE.EDU.VN.
7. How to Use Java Streams to Compare Elements in an Array?
Java Streams provide a functional and declarative way to process collections of data, including arrays. When it comes to comparing elements in an array, streams offer powerful methods like anyMatch(), allMatch(), and noneMatch() to perform complex comparisons efficiently.
7.1. Understanding Java Streams
Java Streams are a sequence of elements that support sequential and parallel aggregate operations. They are part of the java.util.stream package and provide a high-level abstraction for working with collections of data.
7.2. Using anyMatch() to Check for Any Matching Element
The anyMatch() method is used to check if any element in the stream matches a given predicate. It returns true if at least one element matches the predicate, and false otherwise.
import java.util.Arrays;
public class AnyMatchExample {
public static void main(String[] args) {
int[] numbers = {1, 2, 3, 4, 5};
// Check if any number is greater than 3
boolean anyGreaterThan3 = Arrays.stream(numbers)
.anyMatch(n -> n > 3);
System.out.println("Any number greater than 3: " + anyGreaterThan3); // Output: true
}
}In this example, the code checks if there is any number in the numbers array that is greater than 3.
7.3. Using allMatch() to Check if All Elements Match
The allMatch() method is used to check if all elements in the stream match a given predicate. It returns true if all elements match the predicate, and false otherwise.
import java.util.Arrays;
public class AllMatchExample {
public static void main(String[] args) {
int[] numbers = {2, 4, 6, 8, 10};
// Check if all numbers are even
boolean allEven = Arrays.stream(numbers)
.allMatch(n -> n % 2 == 0);
System.out.println("All numbers are even: " + allEven); // Output: true
}
}This code checks if all numbers in the numbers array are even.
7.4. Using noneMatch() to Check if No Elements Match
The noneMatch() method is used to check if no elements in the stream match a given predicate. It returns true if no elements match the predicate, and false otherwise.
import java.util.Arrays;
public class NoneMatchExample {
public static void main(String[] args) {
int[] numbers = {1, 3, 5, 7, 9};
// Check if no number is even
boolean noneEven = Arrays.stream(numbers)
.noneMatch(n -> n % 2 == 0);
System.out.println("No number is even: " + noneEven); // Output: true
}
}This code checks if there are no even numbers in the numbers array.
7.5. Comparing Objects Using Streams
Streams can also be used to compare objects in an array using custom comparison logic. You can use the filter() method to select elements that meet certain criteria and then use anyMatch(), allMatch(), or noneMatch() to compare the selected elements.
import java.util.Arrays;
class Person {
String name;
int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person{name='" + name + "', age=" + age + '}';
}
}
public class StreamObjectComparison {
public static void main(String[] args) {
Person[] people = {
new Person("Alice", 25),
new Person("Bob", 30),
new Person("Charlie", 20)
};
// Check if any person is older than 25
boolean anyOlderThan25 = Arrays.stream(people)
.anyMatch(p -> p.age > 25);
System.out.println("Any person older than 25: " + anyOlderThan25); // Output: true
}
}In this example, the code checks if there is any person in the people array who is older than 25.
7.6. Advantages and Disadvantages
Advantages:
- Functional and Declarative: Streams provide a functional and declarative way to process collections of data.
- Efficient: Streams can be processed in parallel, which can improve performance for large arrays.
- Concise: Streams can often perform complex comparisons with less code than traditional loops.
Disadvantages:
- Learning Curve: Streams can be more complex to understand and use than traditional loops.
- Overhead: Streams can have some overhead, which can make them less efficient for small arrays.
Java Streams provide a powerful and efficient way to compare elements in an array. They offer methods like anyMatch(), allMatch(), and noneMatch() to perform complex comparisons with less code than traditional loops. However, it’s important to consider the learning curve and potential overhead when using streams. For more specialized comparison techniques, such as using data structures like Sets, refer to other sections of this guide at compare.edu.vn.
8. How to Use Data Structures (e.g., Sets) to Compare Java Arrays?
Using data structures like Sets can be an efficient way to compare Java arrays, especially when you need to identify unique elements or compare arrays based on their contents regardless of order. Sets, by definition, store only unique elements, which can simplify certain comparison tasks.
8.1. Understanding Sets
A Set is a collection that contains no duplicate elements. Java provides several implementations of the Set interface, including HashSet, TreeSet, and LinkedHashSet. Each implementation has its own characteristics and performance trade-offs.
- HashSet: Provides the best performance but does not guarantee the order of elements.
- TreeSet: Stores elements in a sorted order but has slower performance.
- LinkedHashSet: Preserves the order in which elements were inserted and provides good performance.
8.2. Converting Arrays to Sets
To use Sets for comparing arrays, you first need to convert the arrays to Sets. This can be done using the Arrays.asList() method and the Set constructor.
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
public class ArrayToSetExample {
public static void main(String[] args) {
Integer[] arr1 = {1, 2, 3, 4, 5};
Integer[] arr2 = {3, 4, 5, 6, 7};
Set<Integer> set1 = new HashSet<>(Arrays.asList(arr1));
Set<Integer> set2 = new HashSet<>(Arrays.asList(arr2));
System.out.println("Set 1: " + set1);
System.out.println("Set 2: " + set2);
}
}In this example, the arr1 and arr2 arrays are converted to set1 and set2 Sets, respectively.
8.3. Identifying Unique Elements
Sets can be used to easily identify unique elements in an array. Since Sets only store unique elements, any duplicates in the array will be automatically removed when converting to a Set.
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
public class UniqueElementsExample {
public static void main(String[] args) {
Integer[] arr = {1, 2, 2, 3, 3, 3, 4, 5};
Set<Integer> uniqueElements = new HashSet<>(Arrays.asList(arr));
System.out.println("Unique elements: " + uniqueElements); // Output: [1, 2, 3, 4, 5]
}
}This code identifies the unique elements in the arr array by converting it to a HashSet.
8.4. Comparing Arrays Based on Contents
Sets can be used to compare arrays based on their contents, regardless of the order of elements. You can use methods like containsAll() to check if one Set contains all the elements of another Set.
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
public class SetComparisonExample {
public static void main(String[] args) {
Integer[] arr1 = {1, 2, 3, 4, 5};
Integer[] arr2 = {5, 4, 3, 2, 1};
Integer[] arr3