Java Compare is a cornerstone of sorting and ordering objects in Java. compare.edu.vn explains its usage, benefits, and how to use it effectively. Learn how to leverage comparators for custom sorting, data structure ordering, and more to make informed decisions.
1. What Is the Purpose of Java Compare?
The purpose of Java compare is to define a total ordering on a collection of objects, enabling precise control over sorting and ordering within data structures. It provides a mechanism to customize the way objects are compared, especially when their natural ordering is not sufficient or doesn’t exist. Let’s dive deeper into understanding what Java compare entails and its myriad applications.
1.1 Understanding Java Compare Function
In Java, a comparison function, often embodied by the Comparator interface, imposes a total ordering on a collection of objects. This means it defines how any two objects within that collection relate to each other in terms of order. The beauty of this lies in its flexibility. Rather than relying on an object’s inherent ordering (defined by implementing the Comparable interface), a comparator allows you to specify a custom ordering.
Imagine you have a list of Person objects, each with a firstName and lastName. The natural ordering might be by firstName, but what if you need to sort by lastName? This is where Comparator shines. You can create a Comparator that compares Person objects based on their lastName, providing the desired sorting behavior.
1.2 Applications of Java Compare
Comparators have diverse applications in Java:
- Sorting: Comparators can be passed to sorting methods like
Collections.sortorArrays.sortto dictate the sorting order. - Data Structures: Comparators can control the order of elements in sorted sets (e.g.,
TreeSet) and sorted maps (e.g.,TreeMap). - Custom Ordering: Comparators provide an ordering for collections of objects that lack a natural ordering.
1.3 Benefits of Using Java Compare
The benefits of using Java compare include:
- Flexibility: Comparators provide a way to customize the ordering of objects based on specific criteria.
- Reusability: Comparators can be reused across different sorting and data structure operations.
- Decoupling: Comparators decouple the ordering logic from the object itself, promoting cleaner code.
2. How Does Java Compare Work?
Java compare works by implementing the Comparator interface, which requires defining a compare method that takes two objects as input and returns an integer indicating their relative order. A negative value means the first object is less than the second, a positive value means the first object is greater, and zero means they are equal. Now, let’s understand the detailed mechanism of Java compare and the principles behind its operation.
2.1 The Comparator Interface
The Comparator interface is the heart of Java compare. It’s a functional interface, meaning it has a single abstract method:
int compare(T o1, T o2);This method is the core of the comparison logic. It takes two objects (o1 and o2) of type T and returns an integer that signifies their relative ordering. The return value follows this convention:
- Negative value:
o1is less thano2 - Zero:
o1is equal too2 - Positive value:
o1is greater thano2
2.2 Implementing the compare Method
The implementation of the compare method is where the magic happens. Here’s a simple example comparing two Integer objects:
Comparator<Integer> integerComparator = (Integer a, Integer b) -> {
return a - b;
};In this case, the comparator subtracts b from a. If a is smaller than b, the result is negative. If a is larger, the result is positive. If they are equal, the result is zero.
2.3 Consistent with Equals
An important consideration is whether the ordering imposed by a Comparator is consistent with equals. This means that if c.compare(e1, e2) == 0, then e1.equals(e2) should also be true, and vice versa, for all elements e1 and e2 in the set S.
If a Comparator is not consistent with equals, sorted sets and maps may behave unexpectedly. For instance, adding two elements a and b to a TreeSet where a.equals(b) is true but c.compare(a, b) != 0 may lead to the TreeSet violating the general contract for sets.
2.4 Comparator and Serializable Interface
It’s generally recommended that comparators also implement java.io.Serializable, especially if they are used in serializable data structures like TreeSet or TreeMap. This ensures that the data structure can be serialized successfully, preserving the ordering logic.
2.5 Mathematical Perspective
From a mathematical standpoint, the relation defined by a comparator c on a set of objects S is:
{(x, y) such that c.compare(x, y) The <i>quotient</i> for this total order is: {(x, y) such that c.compare(x, y) == 0}.This implies that the imposed ordering is a total order on S, meaning any two elements in S can be compared.
3. When Should You Use Java Compare?
You should use Java compare when you need to sort objects based on a custom criteria, when the natural ordering of objects is insufficient, or when you want to control the order of elements in sorted data structures. Let’s look at some specific scenarios where comparators can greatly enhance your code’s flexibility and maintainability.
3.1 Custom Sorting
The most common scenario is when you need to sort a collection of objects based on a specific field or combination of fields. For instance, sorting a list of Employee objects by salary, name, or department.
public class Employee {
private String name;
private int salary;
public Employee(String name, int salary) {
this.name = name;
this.salary = salary;
}
public String getName() {
return name;
}
public int getSalary() {
return salary;
}
}
Comparator<Employee> salaryComparator = (e1, e2) -> e1.getSalary() - e2.getSalary();
List<Employee> employees = new ArrayList<>();
employees.add(new Employee("Alice", 50000));
employees.add(new Employee("Bob", 60000));
employees.add(new Employee("Charlie", 45000));
Collections.sort(employees, salaryComparator);3.2 Non-Comparable Objects
Sometimes you might have to deal with classes that don’t implement the Comparable interface. In such cases, Comparator is your go-to solution for providing an ordering.
public class Product {
private String name;
private double price;
public Product(String name, double price) {
this.name = name;
this.price = price;
}
public String getName() {
return name;
}
public double getPrice() {
return price;
}
}
Comparator<Product> priceComparator = (p1, p2) -> Double.compare(p1.getPrice(), p2.getPrice());
List<Product> products = new ArrayList<>();
products.add(new Product("Laptop", 1200.0));
products.add(new Product("Mouse", 25.0));
products.add(new Product("Keyboard", 75.0));
Collections.sort(products, priceComparator);3.3 Sorted Data Structures
TreeSet and TreeMap are sorted data structures that rely on either the natural ordering of elements (if they implement Comparable) or a Comparator provided during their creation.
Comparator<String> reverseStringComparator = (s1, s2) -> s2.compareTo(s1);
TreeSet<String> sortedSet = new TreeSet<>(reverseStringComparator);
sortedSet.add("Alice");
sortedSet.add("Bob");
sortedSet.add("Charlie");
System.out.println(sortedSet); // Output: [Charlie, Bob, Alice]3.4 Multiple Sorting Criteria
You can create complex comparators that combine multiple sorting criteria. For example, sorting a list of students first by their grade, and then by their name if the grades are the same.
public class Student {
private String name;
private int grade;
public Student(String name, int grade) {
this.name = name;
this.grade = grade;
}
public String getName() {
return name;
}
public int getGrade() {
return grade;
}
}
Comparator<Student> studentComparator = Comparator.comparing(Student::getGrade)
.thenComparing(Student::getName);
List<Student> students = new ArrayList<>();
students.add(new Student("Alice", 90));
students.add(new Student("Bob", 80));
students.add(new Student("Charlie", 90));
Collections.sort(students, studentComparator);3.5 Null-Safe Comparisons
Comparators can also handle null values gracefully, ensuring that your sorting logic doesn’t throw NullPointerExceptions.
Comparator<String> nullSafeStringComparator = Comparator.nullsFirst(String::compareTo);
List<String> names = new ArrayList<>();
names.add("Alice");
names.add(null);
names.add("Bob");
Collections.sort(names, nullSafeStringComparator);3.6 Case-Insensitive Sorting
Sometimes you need to sort strings in a case-insensitive manner. Comparators make this easy.
Comparator<String> caseInsensitiveComparator = String.CASE_INSENSITIVE_ORDER;
List<String> words = new ArrayList<>();
words.add("apple");
words.add("Banana");
words.add("Cherry");
Collections.sort(words, caseInsensitiveComparator);4. How to Implement Java Compare?
To implement Java compare, you need to create a class that implements the Comparator interface and override the compare method. This method defines the logic for comparing two objects. Then, you can use this comparator with sorting methods or sorted data structures. Let’s outline the steps and provide clear examples to get you started.
4.1 Steps to Implement Java Compare
-
Create a Class: Start by creating a new class that will implement the
Comparatorinterface.import java.util.Comparator; public class MyComparator implements Comparator<MyObject> { // Implementation will go here } -
Specify the Type: Specify the type of objects your comparator will compare using generics. In the example above,
MyObjectis the type. -
Implement the
compareMethod: Override thecomparemethod to define the comparison logic.@Override public int compare(MyObject o1, MyObject o2) { // Comparison logic } -
Define Comparison Logic: Inside the
comparemethod, implement the logic to compare the two objects (o1ando2). Return a negative integer ifo1is less thano2, zero if they are equal, and a positive integer ifo1is greater thano2. -
Use the Comparator: Instantiate your comparator class and pass it to sorting methods or sorted data structures.
4.2 Example: Comparing Custom Objects
Let’s create a Person class and a comparator to sort Person objects by age.
public class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + ''' +
", age=" + age +
'}';
}
}
import java.util.Comparator;
public class AgeComparator implements Comparator<Person> {
@Override
public int compare(Person p1, Person p2) {
return p1.getAge() - p2.getAge();
}
}Now, let’s use the AgeComparator to sort a list of Person objects.
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<Person> people = new ArrayList<>();
people.add(new Person("Alice", 30));
people.add(new Person("Bob", 20));
people.add(new Person("Charlie", 25));
Collections.sort(people, new AgeComparator());
for (Person person : people) {
System.out.println(person);
}
}
}4.3 Using Lambda Expressions for Comparators
Java 8 introduced lambda expressions, which provide a concise way to create comparators.
Comparator<Person> ageComparator = (p1, p2) -> p1.getAge() - p2.getAge();This lambda expression is equivalent to the AgeComparator class we defined earlier.
4.4 Chaining Comparators
You can chain multiple comparators together to sort objects based on multiple criteria.
Comparator<Person> nameComparator = (p1, p2) -> p1.getName().compareTo(p2.getName());
Comparator<Person> chainedComparator = ageComparator.thenComparing(nameComparator);This chainedComparator will first sort by age and then, if ages are equal, it will sort by name.
4.5 Handling Null Values
Comparators can also handle null values gracefully using the Comparator.nullsFirst or Comparator.nullsLast methods.
Comparator<String> nullSafeComparator = Comparator.nullsFirst(String::compareTo);This comparator will place null values at the beginning of the sorted list.
4.6 Practical Example with Arrays.sort
Comparators are commonly used with Arrays.sort for sorting arrays of objects.
Person[] personArray = new Person[3];
personArray[0] = new Person("Alice", 30);
personArray[1] = new Person("Bob", 20);
personArray[2] = new Person("Charlie", 25);
Arrays.sort(personArray, ageComparator);
for (Person person : personArray) {
System.out.println(person);
}5. Common Mistakes to Avoid When Using Java Compare
When using Java compare, it’s crucial to avoid common mistakes such as inconsistent comparison logic, null pointer exceptions, and neglecting the “consistent with equals” contract. These errors can lead to unexpected behavior and incorrect sorting. Let’s highlight these pitfalls and offer strategies to sidestep them.
5.1 Inconsistent Comparison Logic
One of the most common mistakes is writing comparison logic that isn’t consistent. This means that for a given pair of objects, the comparison result might change unpredictably. This can lead to unstable sorting, where the order of equal elements is not preserved.
Example of Inconsistent Logic:
Comparator<Integer> badComparator = (a, b) -> {
if (Math.random() > 0.5) {
return a - b;
} else {
return b - a;
}
};How to Avoid:
- Always ensure your comparison logic is deterministic and produces the same result for the same pair of objects.
- Test your comparator thoroughly with various inputs to catch any inconsistencies.
5.2 Null Pointer Exceptions
Another frequent issue is encountering NullPointerExceptions when comparing objects that might be null.
Example of Null Pointer Exception:
Comparator<String> nullComparator = (a, b) -> a.compareTo(b); // This will throw NPE if a or b is nullHow to Avoid:
-
Use
Comparator.nullsFirst()orComparator.nullsLast()to handle null values gracefully.Comparator<String> nullSafeComparator = Comparator.nullsFirst(String::compareTo); -
Alternatively, explicitly check for null values in your comparison logic.
Comparator<String> nullCheckComparator = (a, b) -> { if (a == null && b == null) return 0; if (a == null) return -1; if (b == null) return 1; return a.compareTo(b); };
5.3 Neglecting “Consistent with Equals”
As mentioned earlier, a comparator’s ordering should ideally be “consistent with equals.” This means that if a.equals(b) is true, then comparator.compare(a, b) should return 0. Failing to adhere to this can cause issues with sorted sets and maps.
Example of Inconsistency:
public class CaseInsensitiveString {
private String value;
public CaseInsensitiveString(String value) {
this.value = value;
}
public String getValue() {
return value;
}
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (obj == null || getClass() != obj.getClass()) return false;
CaseInsensitiveString that = (CaseInsensitiveString) obj;
return value.equalsIgnoreCase(that.value);
}
@Override
public int hashCode() {
return value.toLowerCase().hashCode();
}
}
Comparator<CaseInsensitiveString> inconsistentComparator = (s1, s2) -> s1.getValue().compareTo(s2.getValue());In this example, two CaseInsensitiveString objects might be considered equal by the equals method but not by the comparator, leading to unexpected behavior in sorted sets.
How to Avoid:
- Ensure that your comparator’s logic aligns with the
equalsmethod of the objects being compared. - When using custom classes in sorted sets or maps, carefully consider the implications of the “consistent with equals” contract.
5.4 Integer Overflow
When comparing integer fields, a common mistake is to directly subtract one value from the other, which can lead to integer overflow.
Example of Integer Overflow:
Comparator<Integer> overflowComparator = (a, b) -> a - b; // Potential integer overflowHow to Avoid:
-
Use
Integer.compare()instead, which avoids the risk of overflow.Comparator<Integer> safeComparator = Integer::compare; -
Alternatively, cast the integers to
longbefore subtracting.Comparator<Integer> safeComparatorLong = (a, b) -> (int) ((long) a - b);
5.5 Ignoring Edge Cases
Failing to consider edge cases, such as empty strings or zero values, can lead to unexpected behavior in your comparator.
How to Avoid:
- Thoroughly analyze the possible input values and ensure your comparator handles all cases correctly.
- Add explicit checks for edge cases in your comparison logic.
By being mindful of these common mistakes, you can write robust and reliable comparators that ensure your Java code behaves as expected.
6. Examples of Java Compare in Real-World Scenarios
Java compare is a fundamental tool in many real-world scenarios, including sorting data in various applications, implementing custom ordering in data structures, and handling complex comparison logic in business applications. Let’s explore these scenarios with detailed examples.
6.1 Sorting Data in E-Commerce Applications
In e-commerce applications, sorting products by price, rating, or popularity is a common requirement. Java compare can be used to implement these sorting functionalities.
Example:
public class Product {
private String name;
private double price;
private double rating;
private int popularity;
public Product(String name, double price, double rating, int popularity) {
this.name = name;
this.price = price;
this.rating = rating;
this.popularity = popularity;
}
public String getName() {
return name;
}
public double getPrice() {
return price;
}
public double getRating() {
return rating;
}
public int getPopularity() {
return popularity;
}
}
// Comparator to sort products by price
Comparator<Product> priceComparator = Comparator.comparingDouble(Product::getPrice);
// Comparator to sort products by rating
Comparator<Product> ratingComparator = Comparator.comparingDouble(Product::getRating).reversed();
// Comparator to sort products by popularity
Comparator<Product> popularityComparator = Comparator.comparingInt(Product::getPopularity).reversed();These comparators can then be used to sort a list of products based on the desired criteria.
List<Product> products = new ArrayList<>();
products.add(new Product("Laptop", 1200.0, 4.5, 1000));
products.add(new Product("Mouse", 25.0, 4.0, 500));
products.add(new Product("Keyboard", 75.0, 4.2, 750));
Collections.sort(products, priceComparator); // Sort by price
Collections.sort(products, ratingComparator); // Sort by rating
Collections.sort(products, popularityComparator); // Sort by popularity6.2 Implementing Custom Ordering in Data Structures
In applications that require custom ordering in data structures like TreeSet or TreeMap, Java compare is essential.
Example:
// Custom class
public class Event {
private String name;
private LocalDateTime dateTime;
public Event(String name, LocalDateTime dateTime) {
this.name = name;
this.dateTime = dateTime;
}
public String getName() {
return name;
}
public LocalDateTime getDateTime() {
return dateTime;
}
}
// Comparator to sort events by date and time
Comparator<Event> eventComparator = Comparator.comparing(Event::getDateTime);
// Using TreeSet with custom comparator
TreeSet<Event> events = new TreeSet<>(eventComparator);
events.add(new Event("Meeting", LocalDateTime.now().plusHours(1)));
events.add(new Event("Conference", LocalDateTime.now().plusDays(1)));
events.add(new Event("Webinar", LocalDateTime.now()));In this example, the TreeSet will maintain the events in chronological order based on their date and time.
6.3 Handling Complex Comparison Logic in Business Applications
Business applications often require complex comparison logic, such as sorting customers based on multiple criteria like loyalty points, purchase history, and account status.
Example:
public class Customer {
private String name;
private int loyaltyPoints;
private int purchaseCount;
private boolean isActive;
public Customer(String name, int loyaltyPoints, int purchaseCount, boolean isActive) {
this.name = name;
this.loyaltyPoints = loyaltyPoints;
this.purchaseCount = purchaseCount;
this.isActive = isActive;
}
public String getName() {
return name;
}
public int getLoyaltyPoints() {
return loyaltyPoints;
}
public int getPurchaseCount() {
return purchaseCount;
}
public boolean isActive() {
return isActive;
}
}
// Comparator to sort customers by loyalty points, purchase count, and account status
Comparator<Customer> customerComparator = Comparator.comparing(Customer::isActive, Comparator.reverseOrder())
.thenComparing(Customer::getLoyaltyPoints, Comparator.reverseOrder())
.thenComparing(Customer::getPurchaseCount, Comparator.reverseOrder());This comparator sorts customers first by their account status (active customers first), then by loyalty points (highest first), and finally by purchase count (highest first).
6.4 Sorting Files by Name, Size, or Date
In file management applications, sorting files by name, size, or date is a common requirement.
Example:
import java.io.File;
import java.util.Arrays;
import java.util.Comparator;
public class FileSortExample {
public static void main(String[] args) {
File directory = new File("/path/to/directory");
File[] files = directory.listFiles();
// Comparator to sort files by name
Comparator<File> nameComparator = Comparator.comparing(File::getName);
// Comparator to sort files by size
Comparator<File> sizeComparator = Comparator.comparingLong(File::length);
// Comparator to sort files by date
Comparator<File> dateComparator = Comparator.comparingLong(File::lastModified);
if (files != null) {
Arrays.sort(files, nameComparator); // Sort by name
Arrays.sort(files, sizeComparator); // Sort by size
Arrays.sort(files, dateComparator); // Sort by date
for (File file : files) {
System.out.println(file.getName());
}
}
}
}6.5 Custom Sorting in Data Analysis and Reporting
In data analysis and reporting applications, custom sorting is often required to present data in a meaningful way.
Example:
public class ReportEntry {
private String category;
private int value;
public ReportEntry(String category, int value) {
this.category = category;
this.value = value;
}
public String getCategory() {
return category;
}
public int getValue() {
return value;
}
}
// Comparator to sort report entries by category and value
Comparator<ReportEntry> reportEntryComparator = Comparator.comparing(ReportEntry::getCategory)
.thenComparing(ReportEntry::getValue, Comparator.reverseOrder());This comparator sorts report entries first by category and then by value (highest first).
7. Advanced Techniques in Java Compare
Java compare offers advanced techniques such as chaining comparators, using comparing methods, and handling null values, allowing for more sophisticated and flexible sorting logic. These techniques can greatly enhance the power and expressiveness of your code. Let’s examine these advanced techniques and demonstrate their practical applications.
7.1 Chaining Comparators with thenComparing
Chaining comparators allows you to combine multiple comparison criteria. The thenComparing method is used to specify a secondary comparator that is applied when the primary comparator considers two elements equal.
Example:
public class Person {
private String firstName;
private String lastName;
private int age;
public Person(String firstName, String lastName, int age) {
this.firstName = firstName;
this.lastName = lastName;
this.age = age;
}
public String getFirstName() {
return firstName;
}
public String getLastName() {
return lastName;
}
public int getAge() {
return age;
}
}
Comparator<Person> lastNameComparator = Comparator.comparing(Person::getLastName);
Comparator<Person> firstNameComparator = Comparator.comparing(Person::getFirstName);
// Chain comparators to sort by last name and then by first name
Comparator<Person> chainedComparator = lastNameComparator.thenComparing(firstNameComparator);In this example, the chainedComparator first compares Person objects by their last name. If the last names are equal, it then compares them by their first name.
7.2 Using comparing Methods for Concise Comparisons
The Comparator interface provides several comparing methods that simplify the creation of comparators, especially when comparing based on a single field or property.
Example:
// Comparator to sort strings in a case-insensitive manner
Comparator<String> caseInsensitiveComparator = String.CASE_INSENSITIVE_ORDER;
// Comparator to sort integers in reverse order
Comparator<Integer> reverseIntegerComparator = Comparator.reverseOrder();
// Comparator to sort Person objects by age
Comparator<Person> ageComparator = Comparator.comparingInt(Person::getAge);These comparing methods make the code more readable and less verbose.
7.3 Handling Null Values with nullsFirst and nullsLast
When dealing with data that may contain null values, it’s important to handle these values gracefully to avoid NullPointerExceptions. The nullsFirst and nullsLast methods allow you to specify how null values should be treated during comparison.
Example:
// Comparator that places null values at the beginning
Comparator<String> nullsFirstComparator = Comparator.nullsFirst(String::compareTo);
// Comparator that places null values at the end
Comparator<String> nullsLastComparator = Comparator.nullsLast(String::compareTo);These methods ensure that null values are handled consistently and predictably.
7.4 Combining Multiple Criteria with thenComparingInt, thenComparingDouble, and thenComparingLong
When chaining comparators, you can use thenComparingInt, thenComparingDouble, and thenComparingLong for comparing integer, double, and long values, respectively. These methods provide type-specific optimizations that can improve performance.
Example:
public class Product {
private String name;
private double price;
private int quantity;
public Product(String name, double price, int quantity) {
this.name = name;
this.price = price;
this.quantity = quantity;
}
public String getName() {
return name;
}
public double getPrice() {
return price;
}
public int getQuantity() {
return quantity;
}
}
// Comparator to sort products by price and quantity
Comparator<Product> productComparator = Comparator.comparingDouble(Product::getPrice)
.thenComparingInt(Product::getQuantity);7.5 Using Lambda Expressions for Complex Comparison Logic
Lambda expressions can be used to create comparators with complex comparison logic in a concise and readable manner.
Example:
// Comparator to sort strings by length and then alphabetically
Comparator<String> complexStringComparator = (s1, s2) -> {
int lengthComparison = Integer.compare(s1.length(), s2.length());
if (lengthComparison != 0) {
return lengthComparison;
} else {
return s1.compareTo(s2);
}
};This comparator first compares strings by their length and then, if the lengths are equal, it compares them alphabetically.
By mastering these advanced techniques, you can create powerful and flexible comparators that meet the complex sorting requirements of your Java applications.
8. Comparing Java Compare with Other Sorting Techniques
Java offers several sorting techniques, including using the Comparable interface, custom sorting algorithms, and libraries like Guava. Understanding the differences between these approaches and when to use each can lead to more efficient and maintainable code. Now, let’s compare Java compare with other prevalent sorting techniques.
8.1 Java Compare vs. Comparable Interface
The Comparable interface allows a class to define its natural ordering, while Comparator provides external ordering.
| Feature | Comparable |
Comparator |
|---|---|---|
| Implementation | Implemented by the class itself | Implemented by a separate class or lambda |
| Number of Orders | Single natural order | Multiple custom orders |
| Flexibility | Less flexible, tied to the class’s definition | More flexible, can be used for different criteria |
| Use Case | Defining a default sorting order | Sorting based on different criteria, external to the class |
Example of Comparable:
public class Book implements Comparable<Book> {
private String title;
private String author;
public Book(String title, String author) {
this.title = title;
this.author = author;
}
public String getTitle() {
return title;
}
public String getAuthor() {
return author;
}
@Override
public int compareTo(Book other) {
return this.title.compareTo(other.title);
}
}In this example, the Book class defines its natural ordering based on the title.
8.2 Java Compare vs. Custom Sorting Algorithms
Custom sorting algorithms like bubble sort, insertion sort, or merge sort can be implemented for specific use cases. However, they are generally less efficient than the built-in sorting methods that use optimized algorithms like quicksort or mergesort.
| Feature | Java Compare (with Collections.sort) |
Custom Sorting Algorithm |
|---|---|---|
| Efficiency | O(n log n) | O(n^2) or O(n log n) |
| Complexity | Low | High |
| Maintainability | High | Low |
| Use Case | General-purpose sorting | Specific, optimized cases |
Example of Custom Sorting Algorithm (Bubble Sort):
public class BubbleSort {
public static void sort(int[] array) {
int n = array.length;
for (int i = 0; i n - i - 1; j++) {
if (array[j] > array[j + 1]) {
// swap array[j+1] and array[j]
int temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
