Mocking is an essential part of unit testing, and the Mockito library makes it easy to write clean and intuitive unit tests for your Java code.
Get started with mocking and improve your application tests using our Mockito guide:
Handling concurrency in an application can be a tricky process with many potential pitfalls. A solid grasp of the fundamentals will go a long way to help minimize these issues.
Get started with understanding multi-threaded applications with our Java Concurrency guide:
Spring 5 added support for reactive programming with the Spring WebFlux module, which has been improved upon ever since. Get started with the Reactor project basics and reactive programming in Spring Boot:
Since its introduction in Java 8, the Stream API has become a staple of Java development. The basic operations like iterating, filtering, mapping sequences of elements are deceptively simple to use.
But these can also be overused and fall into some common pitfalls.
To get a better understanding on how Streams work and how to combine them with other language features, check out our guide to Java Streams:
Explore Spring Boot 3 and Spring 6 in-depth through building a full REST API with the framework:
Yes, Spring Security can be complex, from the more advanced functionality within the Core to the deep OAuth support in the framework.
I built the security material as two full courses - Core and OAuth, to get practical with these more complex scenarios. We explore when and how to use each feature and code through it on the backing project.
You can explore the course here:
Spring Data JPA is a great way to handle the complexity of JPA with the powerful simplicity of Spring Boot.
Get started with Spring Data JPA through the guided reference course:
Refactor Java code safely — and automatically — with OpenRewrite.
Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.
Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.
Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.
Distributed systems often come with complex challenges such as service-to-service communication, state management, asynchronous messaging, security, and more.
Dapr (Distributed Application Runtime) provides a set of APIs and building blocks to address these challenges, abstracting away infrastructure so we can focus on business logic.
In this tutorial, we'll focus on Dapr's pub/sub API for message brokering. Using its Spring Boot integration, we'll simplify the creation of a loosely coupled, portable, and easily testable pub/sub messaging system:
1. Overview
In this tutorial, we’ll discuss common methods to sort arrays in ascending and descending order.
We’ll look at using Java’s Arrays class sorting method as well as implementing our own Comparator to order our arrays’ values.
2. Object Definitions
Before we begin, let’s quickly define a few arrays that we’ll sort throughout this tutorial. First, we’ll create an array of ints and an array of strings:
int[] numbers = new int[] { -8, 7, 5, 9, 10, -2, 3 };
String[] strings = new String[] { "learning", "java", "with", "baeldung" };And let’s also create an array of Employee objects where each employee has an id and a name attribute:
Employee john = new Employee(6, "John");
Employee mary = new Employee(3, "Mary");
Employee david = new Employee(4, "David");
Employee[] employees = new Employee[] { john, mary, david };3. Sorting in Ascending Order
Java’s util.Arrays.sort method provides us with a quick and simple way to sort an array of primitives or objects that implement the Comparable interface in ascending order.
When sorting primitives, the Arrays.sort method uses a Dual-Pivot implementation of Quicksort. However, when sorting objects an iterative implementation of MergeSort is used.
3.1. Primitives
To sort a primitive array in ascending order, we pass our array to the sort method:
Arrays.sort(numbers);
assertArrayEquals(new int[] { -8, -2, 3, 5, 7, 9, 10 }, numbers);
3.2. Objects That Implement Comparable
For objects that implement the Comparable interface, as with our primitive array, we can also simply pass our array to the sort method:
Arrays.sort(strings);
assertArrayEquals(new String[] { "baeldung", "java", "learning", "with" }, strings);3.3. Objects That Don’t Implement Comparable
Sorting objects that don’t implement the Comparable Interface, like our array of Employees, requires us to specify our own comparator.
We can do this very easily in Java 8 by specifying the property that we would like to compare our Employee objects on within our Comparator:
Arrays.sort(employees, Comparator.comparing(Employee::getName));
assertArrayEquals(new Employee[] { david, john, mary }, employees);In this case, we’ve specified that we would like to order our employees by their name attributes.
We can also sort our objects on more that one attribute by chaining our comparisons using Comparator’s thenComparing method:
Arrays.sort(employees, Comparator.comparing(Employee::getName).thenComparing(Employee::getId));4. Sorting in Descending Order
4.1. Primitives
Sorting a primitive array in descending order is not quite as simple as sorting it in ascending order because Java doesn’t support the use of Comparators on primitive types. To overcome this shortfall we have a few options.
First, we could sort our array in ascending order and then do an in-place reversal of the array.
Second, could convert our array to a list, use Guava’s Lists.reverse() method and then convert our list back into an array.
Finally, we could transform our array to a Stream and then map it back to an int array. It has a nice advantage of being a one-liner and just using core Java:
numbers = IntStream.of(numbers).boxed().sorted(Comparator.reverseOrder()).mapToInt(i -> i).toArray();
assertArrayEquals(new int[] { 10, 9, 7, 5, 3, -2, -8 }, numbers);The reason this works is that boxed turns each int into an Integer, which does implement Comparator.
4.2. Objects That Implement Comparable
Sorting an object array that implements the Comparable interface in descending order is quite simple. All we need to do is pass a Comparator as the second parameter of our sort method.
In Java 8 we can use Comparator.reverseOrder() to indicate that we would like our array to be sorted in descending order:
Arrays.sort(strings, Comparator.reverseOrder());
assertArrayEquals(new String[] { "with", "learning", "java", "baeldung" }, strings);4.3. Objects That Don’t Implement Comparable
Similarly to sorting objects that implement comparable, we can reverse the order of our custom Comparator by adding reversed() at the end of our comparison definition:
Arrays.sort(employees, Comparator.comparing(Employee::getName).reversed());
assertArrayEquals(new Employee[] { mary, john, david }, employees);5. Conclusion
In this article, we discussed how to sort arrays of primitives and objects in ascending and descending order using the Arrays.sort method.
