Java Program To Sort The Elements Of An Array In Ascending Order

Sorting an array is a fundamental operation in computer science, crucial for organizing data efficiently. An array sorted in ascending order arranges its elements from the smallest to the largest value. In this article, you will learn how to sort the elements of an array in ascending order using various approaches in Java, from built-in methods to manual implementations.

Problem Statement

When working with collections of data, it's often necessary to arrange elements in a specific order to facilitate searching, analysis, or presentation. The core problem is to take an unsorted array of numbers and rearrange its elements such that each element is less than or equal to the element that follows it. For example, presenting a list of scores from lowest to highest, or arranging product IDs for quick lookup, requires sorting.

Example

Consider an unsorted array: int[] originalArray = {5, 2, 8, 1, 9, 4};

After sorting in ascending order, the array should become: int[] sortedArray = {1, 2, 4, 5, 8, 9};

Background & Knowledge Prerequisites

To understand the concepts presented in this article, readers should have a basic understanding of:

• Java Syntax: Variables, data types (especially int and String), and basic operators.
• Arrays in Java: How to declare, initialize, and access elements of an array.
• Loops: for loops for iterating over array elements.
• Conditional Statements: if statements for comparisons.

Use Cases or Case Studies

Sorting arrays in ascending order has numerous practical applications across various domains:

• Data Analysis and Reporting: Arranging datasets by a specific metric (e.g., sales figures, student grades) to easily identify trends, minimums, or maximums.
• Search Algorithms: Many efficient search algorithms, like binary search, require the data to be sorted. Sorting an array first significantly speeds up subsequent search operations.
• Database Indexing: Databases often sort data in indexes to quickly locate records, improving query performance.
• Resource Scheduling: Sorting tasks by priority or deadline helps in efficient resource allocation and job scheduling.
• Data Visualization: Presenting data in a sorted manner makes charts and graphs more readable and understandable.

Solution Approaches

There are multiple ways to sort an array in ascending order in Java, ranging from using built-in library functions to implementing sorting algorithms manually. We will explore three common approaches.

Approach 1: Using Arrays.sort() Method

This is the simplest and most recommended approach for sorting arrays in Java, as it leverages highly optimized algorithms (like Timsort) provided by the Java Development Kit (JDK).

• One-line summary: Utilizes Java's built-in java.util.Arrays.sort() method for efficient and straightforward array sorting.

// Sort Array using Arrays.sort()
import java.util.Arrays; // Required for Arrays.sort() method

public class Main {
    public static void main(String[] args) {
        // Step 1: Declare and initialize an unsorted integer array.
        int[] numbers = {5, 2, 8, 1, 9, 4};
        System.out.println("Original array: " + Arrays.toString(numbers));

        // Step 2: Use Arrays.sort() to sort the array in ascending order.
        // This method sorts the array in-place.
        Arrays.sort(numbers);

        // Step 3: Print the sorted array.
        System.out.println("Sorted array (Arrays.sort()): " + Arrays.toString(numbers));
    }
}

Run

Sample Output:

Original array: [5, 2, 8, 1, 9, 4]
Sorted array (Arrays.sort()): [1, 2, 4, 5, 8, 9]

Stepwise Explanation:

1. An integer array numbers is initialized with unsorted values.
2. java.util.Arrays.sort(numbers) is called. This static method takes the array as an argument and sorts its elements directly, modifying the original array.
3. Arrays.toString(numbers) is used to easily print the contents of the array before and after sorting.

Approach 2: Implementing Bubble Sort

Bubble Sort is a simple comparison-based sorting algorithm. It repeatedly steps through the list, compares adjacent elements, and swaps them if they are in the wrong order. This process is repeated until no swaps are needed, indicating the array is sorted.

• One-line summary: A straightforward sorting algorithm that iteratively compares and swaps adjacent elements to move larger values towards the end of the array.

// Sort Array using Bubble Sort
public class Main {
    public static void main(String[] args) {
        // Step 1: Declare and initialize an unsorted integer array.
        int[] numbers = {5, 2, 8, 1, 9, 4};
        System.out.print("Original array: ");
        printArray(numbers);

        // Step 2: Implement Bubble Sort logic.
        // Outer loop for passes. A pass ensures at least one element bubbles to its correct place.
        for (int i = 0; i < numbers.length - 1; i++) {
            // Inner loop for comparisons and swaps within each pass.
            // (numbers.length - 1 - i) optimizes by not re-checking elements already at their final position.
            for (int j = 0; j < numbers.length - 1 - i; j++) {
                // Compare adjacent elements
                if (numbers[j] > numbers[j + 1]) {
                    // Swap if the element found is greater than the next element
                    int temp = numbers[j];
                    numbers[j] = numbers[j + 1];
                    numbers[j + 1] = temp;
                }
            }
        }

        // Step 3: Print the sorted array.
        System.out.print("Sorted array (Bubble Sort): ");
        printArray(numbers);
    }

    // Helper method to print the array elements
    public static void printArray(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + (i < arr.length - 1 ? ", " : ""));
        }
        System.out.println();
    }
}

Run

Sample Output:

Original array: 5, 2, 8, 1, 9, 4
Sorted array (Bubble Sort): 1, 2, 4, 5, 8, 9

Stepwise Explanation:

1. An unsorted integer array numbers is declared. A helper method printArray is used for displaying array contents.
2. The outer for loop iterates n-1 times, where n is the number of elements. Each iteration is a "pass" through the array.
3. The inner for loop performs comparisons and swaps. It iterates from the beginning of the array up to the unsorted portion.
4. Inside the inner loop, adjacent elements numbers[j] and numbers[j+1] are compared.
5. If numbers[j] is greater than numbers[j+1], they are swapped using a temporary variable temp. This moves the larger element "up" the array.
6. After each pass of the outer loop, the largest unsorted element "bubbles" to its correct position at the end of the unsorted portion. The range of the inner loop decreases in subsequent passes to avoid re-checking already sorted elements.

Approach 3: Implementing Selection Sort

Selection Sort is another simple sorting algorithm. It works by repeatedly finding the minimum element from the unsorted part of the array and putting it at the beginning of the sorted part.

• One-line summary: Identifies the smallest element in the unsorted portion of the array and places it at the beginning of the sorted portion in each iteration.

Let's briefly outline its logic:

1. Initialize the current minimum value's index to the first unsorted element.
2. Iterate through the rest of the unsorted array to find the true minimum element.
3. If a smaller element is found, update the minimum value's index.
4. After scanning the entire unsorted part, swap the minimum element with the first unsorted element.
5. Repeat this process for the remaining unsorted part until the entire array is sorted.

While Arrays.sort() is efficient for practical use, understanding algorithms like Bubble Sort and Selection Sort provides valuable insight into how sorting works at a fundamental level.

Conclusion

Sorting an array in ascending order is a common requirement in programming, and Java offers robust tools to achieve this. The Arrays.sort() method is the most efficient and recommended approach for general-purpose sorting due to its optimized implementation. For educational purposes or specific scenarios where a simpler algorithm might be preferred, manual implementations like Bubble Sort offer clear examples of comparison-based sorting logic.

Summary

• Arrays.sort(): The easiest and most efficient way to sort primitive arrays and object arrays (if objects implement Comparable or a Comparator is provided) in Java. It uses a highly optimized algorithm (Timsort).
• Bubble Sort: A basic sorting algorithm that repeatedly compares adjacent elements and swaps them if they are in the wrong order. It is simple to understand but generally inefficient for large datasets due to its O(n^2) time complexity.
• Selection Sort: Another simple algorithm that finds the minimum element in the unsorted portion and places it at the correct position. Like Bubble Sort, it has an O(n^2) time complexity, making it less suitable for large arrays.