What is the correct way to sort an array of random integers in Java, and how can I print the sorted result?

General Discussions
, ,
1

I’m creating a program with an array of 10 integers, each assigned a random value. That part works fine, but now I want to apply a Java array sort from lowest to highest and then print the sorted numbers on the screen. I’m still learning loops and arrays in Java, so what’s the best way to do this cleanly and efficiently?

2

Been working with Java for a few years now, and trust me, when it comes to quick and clean, built-in methods are gold.

If you’re just getting started or want a no-fuss solution, the best way is using Arrays.sort()—simple and super reliable. It handles the sorting internally using a dual-pivot quicksort for primitives.

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] array = new int[10];

        // Fill with random values
        for (int i = 0; i < array.length; i++) {
            array[i] = (int)(Math.random() * 100 + 1);
        }

        // Sort the array
        Arrays.sort(array);

        // Print the sorted array
        System.out.println(Arrays.toString(array));
    }
}

If you’re looking for a quick win using java array sort, this is your go-to. Plus, Arrays.toString() makes the output super readable.

3

Totally agree with @yanisleidi-rodriguez for quick results—but if you’re into really understanding what’s going on behind the curtain, try writing your own sort logic.

A few years ago, I started learning sorting by implementing Bubble Sort manually—it really helps in understanding comparisons and control flow. Here’s how you could do it after generating your array:

for (int i = 0; i < array.length - 1; i++) {
    for (int j = 0; j < array.length - i - 1; j++) {
        if (array[j] > array[j + 1]) {
            int temp = array[j];
            array[j] = array[j + 1];
            array[j + 1] = temp;
        }
    }
}

It’s not production-optimized, but as a learning step in java array sort, it’s invaluable. You’ll grasp how sorting algorithms handle value swapping and index tracking.

4

Been dabbling in Java collections for a while now—so if you’re thinking long-term scalability, switching to Lists is the natural next step.

If you’re planning to do more than just static array sorting—like adding or removing values on the fly—consider using List<Integer> along with Collections.sort():

import java.util.*;

public class Main {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            list.add((int)(Math.random() * 100 + 1));
        }

        Collections.sort(list);

        System.out.println(list);
    }
}

This approach not only simplifies dynamic data handling but also ties into more real-world use cases. For anyone exploring java array sort in a flexible app context, this is the next level.