How to Check If a List Is Sorted in Java

Introduction

In this lab, you will learn how to check if a list is sorted in Java. We will explore different approaches to accomplish this task, starting with a fundamental method of comparing adjacent elements within the list.

You will then discover how to leverage the power of the Java Stream API for a more concise and potentially efficient way to perform the sorted check. Finally, we will address how to handle different sorting orders, such as ascending and descending, to make your sorting checks more versatile.

Skills Graph

Compare Adjacent List Elements

In this step, we will learn how to compare adjacent elements in a list (or more specifically, a List in Java). This is a common task when you need to check for patterns or order within a sequence of data. We will start by creating a simple Java program that uses a loop to iterate through a list and compare each element with the one that comes right after it.

First, let's create a new Java file named ListComparison.java in your ~/project directory. You can do this using the WebIDE's File Explorer on the left. Right-click in the ~/project area, select "New File", and type ListComparison.java.

Now, open the ListComparison.java file in the editor and add the following code:

import java.util.ArrayList;
import java.util.List;

public class ListComparison {

    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(3);
        numbers.add(2);
        numbers.add(4);
        numbers.add(5);

        System.out.println("Original list: " + numbers);

        // Loop through the list, comparing adjacent elements
        for (int i = 0; i < numbers.size() - 1; i++) {
            Integer currentElement = numbers.get(i);
            Integer nextElement = numbers.get(i + 1);

            System.out.println("Comparing " + currentElement + " and " + nextElement);

            if (currentElement < nextElement) {
                System.out.println(currentElement + " is less than " + nextElement);
            } else if (currentElement > nextElement) {
                System.out.println(currentElement + " is greater than " + nextElement);
            } else {
                System.out.println(currentElement + " is equal to " + nextElement);
            }
        }
    }
}

Let's break down this code:

• import java.util.ArrayList; and import java.util.List;: These lines import the necessary classes to work with lists in Java.
• List<Integer> numbers = new ArrayList<>();: This creates a new list called numbers that can hold Integer (whole number) objects.
• numbers.add(...): These lines add elements to our list.
• for (int i = 0; i < numbers.size() - 1; i++): This is a for loop that iterates through the list. Notice that the loop condition is i < numbers.size() - 1. This is important because we are comparing numbers.get(i) with numbers.get(i + 1). If we looped up to numbers.size(), i + 1 would go out of bounds on the last iteration.
• Integer currentElement = numbers.get(i);: This gets the element at the current index i.
• Integer nextElement = numbers.get(i + 1);: This gets the element at the next index i + 1.
• System.out.println(...): These lines print information to the console, showing which elements are being compared and the result of the comparison.
• if, else if, else: These are conditional statements that check if the currentElement is less than, greater than, or equal to the nextElement.

Save the ListComparison.java file (Ctrl+S or Cmd+S).

Now, let's compile and run the program. Open the Terminal at the bottom of the WebIDE. Make sure you are in the ~/project directory (you can use cd ~/project if needed).

Compile the code using javac:

javac ListComparison.java

If there are no errors, a ListComparison.class file will be created. Now, run the compiled code using java:

java ListComparison

You should see output similar to this:

Original list: [1, 3, 2, 4, 5]
Comparing 1 and 3
1 is less than 3
Comparing 3 and 2
3 is greater than 2
Comparing 2 and 4
2 is less than 4
Comparing 4 and 5
4 is less than 5

This output shows that our program successfully iterated through the list and compared each adjacent pair of elements, printing the result of each comparison.

Use Stream API for Sorted Check

In this step, we will explore a more modern and often more concise way to check if a list is sorted using Java's Stream API. The Stream API, introduced in Java 8, provides a functional approach to processing collections of data.

We will modify our previous program to include a method that checks if the list is sorted in ascending order using streams.

Open the ListComparison.java file in the WebIDE editor. Add a new method called isSortedAscending to the ListComparison class, outside of the main method but inside the ListComparison class curly braces {}.

Here's the updated code for ListComparison.java:

import java.util.ArrayList;
import java.util.List;
import java.util.stream.IntStream;

public class ListComparison {

    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(3);
        numbers.add(2);
        numbers.add(4);
        numbers.add(5);

        System.out.println("Original list: " + numbers);

        // Check if the list is sorted using the new method
        boolean sorted = isSortedAscending(numbers);

        if (sorted) {
            System.out.println("The list is sorted in ascending order.");
        } else {
            System.out.println("The list is NOT sorted in ascending order.");
        }

        // The previous loop for comparison is removed for simplicity in this step
        // but you can keep it if you want to see both methods in action.
    }

    // Method to check if the list is sorted in ascending order using Streams
    public static boolean isSortedAscending(List<Integer> list) {
        if (list == null || list.size() <= 1) {
            return true; // An empty or single-element list is considered sorted
        }

        return IntStream.range(0, list.size() - 1)
                .allMatch(i -> list.get(i).compareTo(list.get(i + 1)) <= 0);
    }
}

Let's look at the new parts:

• import java.util.stream.IntStream;: This imports the IntStream class, which is useful for working with sequences of integers in streams.
• public static boolean isSortedAscending(List<Integer> list): This declares a new static method named isSortedAscending that takes a List of Integer and returns a boolean (true if sorted, false otherwise).
• if (list == null || list.size() <= 1): This handles edge cases: an empty list or a list with one element is always considered sorted.
• IntStream.range(0, list.size() - 1): This creates a stream of integers from 0 up to (but not including) list.size() - 1. These integers represent the indices of the list elements we want to compare.
• .allMatch(i -> list.get(i).compareTo(list.get(i + 1)) <= 0): This is the core of the stream operation.
  • allMatch() is a terminal operation that checks if all elements in the stream match a given condition.
  • i -> list.get(i).compareTo(list.get(i + 1)) <= 0 is a lambda expression that defines the condition. For each index i from the IntStream, it gets the element at index i and the element at index i + 1.
  • list.get(i).compareTo(list.get(i + 1)) compares the two elements. compareTo returns a negative integer if the first element is less than the second, zero if they are equal, and a positive integer if the first element is greater than the second.
  • <= 0 checks if the result of compareTo is less than or equal to zero. This condition is true if the current element is less than or equal to the next element, which is the definition of ascending order.
  • allMatch returns true only if this condition is true for all adjacent pairs in the list.

Save the ListComparison.java file.

Now, compile and run the updated program in the Terminal:

javac ListComparison.java

java ListComparison

The output should now indicate whether the list is sorted in ascending order based on the isSortedAscending method:

Original list: [1, 3, 2, 4, 5]
The list is NOT sorted in ascending order.

Modify the list in the main method to be sorted, for example:

        List<Integer> numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        numbers.add(5);

Save the file, compile, and run again. The output should now be:

Original list: [1, 2, 3, 4, 5]
The list is sorted in ascending order.

This demonstrates how to use the Stream API to perform a concise check for ascending order.

Handle Different Sorting Orders

In the previous step, we created a method to check if a list is sorted in ascending order. In this step, we will expand our program to handle different sorting orders: ascending and descending. We will add a new method that takes the list and the desired sorting order as input.

Open the ListComparison.java file in the WebIDE editor. We will add a new method called isSorted that takes the list and a boolean indicating if we want to check for ascending order (true) or descending order (false).

Here's the updated code for ListComparison.java:

import java.util.ArrayList;
import java.util.List;
import java.util.stream.IntStream;

public class ListComparison {

    public static void main(String[] args) {
        List<Integer> numbersAsc = new ArrayList<>();
        numbersAsc.add(1);
        numbersAsc.add(2);
        numbersAsc.add(3);
        numbersAsc.add(4);
        numbersAsc.add(5);

        List<Integer> numbersDesc = new ArrayList<>();
        numbersDesc.add(5);
        numbersDesc.add(4);
        numbersDesc.add(3);
        numbersDesc.add(2);
        numbersDesc.add(1);

        List<Integer> numbersUnsorted = new ArrayList<>();
        numbersUnsorted.add(1);
        numbersUnsorted.add(3);
        numbersUnsorted.add(2);
        numbersUnsorted.add(4);
        numbersUnsorted.add(5);


        System.out.println("Checking list: " + numbersAsc);
        System.out.println("Is ascending sorted? " + isSorted(numbersAsc, true));
        System.out.println("Is descending sorted? " + isSorted(numbersAsc, false));
        System.out.println();

        System.out.println("Checking list: " + numbersDesc);
        System.out.println("Is ascending sorted? " + isSorted(numbersDesc, true));
        System.out.println("Is descending sorted? " + isSorted(numbersDesc, false));
        System.out.println();

        System.out.println("Checking list: " + numbersUnsorted);
        System.out.println("Is ascending sorted? " + isSorted(numbersUnsorted, true));
        System.out.println("Is descending sorted? " + isSorted(numbersUnsorted, false));
        System.out.println();

    }

    // Method to check if the list is sorted based on the specified order
    public static boolean isSorted(List<Integer> list, boolean ascending) {
        if (list == null || list.size() <= 1) {
            return true; // An empty or single-element list is considered sorted
        }

        return IntStream.range(0, list.size() - 1)
                .allMatch(i -> {
                    int comparison = list.get(i).compareTo(list.get(i + 1));
                    if (ascending) {
                        return comparison <= 0; // For ascending, current must be <= next
                    } else {
                        return comparison >= 0; // For descending, current must be >= next
                    }
                });
    }
}

Let's look at the changes:

• We've created three different lists in main: numbersAsc (sorted ascending), numbersDesc (sorted descending), and numbersUnsorted.
• We call the new isSorted method with each list and both true (for ascending) and false (for descending) for the ascending parameter.
• public static boolean isSorted(List<Integer> list, boolean ascending): This is our new method signature, accepting the list and a boolean flag for the order.
• Inside the allMatch lambda:
  • int comparison = list.get(i).compareTo(list.get(i + 1));: We perform the comparison between adjacent elements.
  • if (ascending): If the ascending flag is true, we check if comparison <= 0 (current is less than or equal to the next).
  • else: If the ascending flag is false (meaning we are checking for descending order), we check if comparison >= 0 (current is greater than or equal to the next).

Save the ListComparison.java file.

Now, compile and run the updated program in the Terminal:

javac ListComparison.java

java ListComparison

The output should show the results for checking each list against both ascending and descending order:

Checking list: [1, 2, 3, 4, 5]
Is ascending sorted? true
Is descending sorted? false

Checking list: [5, 4, 3, 2, 1]
Is ascending sorted? false
Is descending sorted? true

Checking list: [1, 3, 2, 4, 5]
Is ascending sorted? false
Is descending sorted? false

This demonstrates how to create a flexible method using the Stream API to check for different sorting orders by adjusting the comparison logic based on an input parameter.

Summary

In this lab, we learned how to check if a list is sorted in Java using different approaches. We started by implementing a method to compare adjacent elements in a list using a traditional loop, which provides a fundamental understanding of the sorting check logic. This involved iterating through the list and comparing each element with its successor to identify any unsorted pairs.

Subsequently, we explored how to leverage the Java Stream API for a more concise and functional approach to checking list sortedness. This method utilizes stream operations to efficiently determine if the elements are in the desired order. Finally, we addressed the handling of different sorting orders (ascending and descending) when performing the sorted check, demonstrating how to adapt the comparison logic to accommodate various sorting requirements.