Implementing a sorting algorithm in Java involves writing code that arranges elements in a specific order (e.g., ascending or descending). There are various sorting algorithms, each with its own advantages and disadvantages in terms of time complexity and stability. Below, I'll show you an example of implementing one of the simplest sorting algorithms, the "Bubble Sort," in Java:

```java
public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};

        System.out.println("Original array:");
        printArray(arr);

        bubbleSort(arr);

        System.out.println("Sorted array:");
        printArray(arr);
    }

    // Bubble Sort implementation
    static void bubbleSort(int[] arr) {
        int n = arr.length;
        boolean swapped;
        for (int i = 0; i < n - 1; i++) {
            swapped = false;
            for (int j = 0; j < n - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    // Swap arr[j] and arr[j+1]
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    swapped = true;
                }
            }

            // If no two elements were swapped in inner loop, the array is already sorted
            if (!swapped) {
                break;
            }
        }
    }

    // Utility method to print an array
    static void printArray(int[] arr) {
        for (int value : arr) {
            System.out.print(value + " ");
        }
        System.out.println();
    }
}
```

In this example, we implement the Bubble Sort algorithm to sort an array of integers. Here's a step-by-step explanation:

1. We define a `bubbleSort` method to perform the sorting operation. This method takes an array of integers as its input.

2. Inside the `bubbleSort` method, we use nested loops. The outer loop runs from `i = 0` to `i < n - 1`, where `n` is the length of the array. The outer loop controls the number of passes over the array.

3. Inside the outer loop, we have an inner loop that compares adjacent elements in the array. If an element is greater than the element to its right, we swap them.

4. We keep track of whether any swaps occurred in the inner loop by using a boolean flag `swapped`. If no swaps occurred in a pass, it means the array is already sorted, and we break out of the outer loop early to optimize the sorting process.

5. Finally, we print the sorted array using the `printArray` utility method.

You can replace the input array with your own data or implement other sorting algorithms like Quick Sort, Merge Sort, or Insertion Sort based on your requirements. Sorting algorithms differ in terms of efficiency and suitability for different types of data and use cases.