Here are the most common sort algorithms:

Bubble sort: traverses the list and swap contiguous items, if not sorted. It repeats the process until the entire list is sorted.

Selection sort: finds the smallest element and move it at the very left. It repeats the process with the rest of the list, until when fully sorted.

Insertion sort: selects an item and move it to the left of the list. Move another item to the left in the right order compared to the ones already moved. Then it repeats the process until when the list is fully ordered.

Shell short: insertions order subsets made of equidistant items, then performs a normal insertions order.

Quick sort: partitions the items by using a pivot item, then moves to the right items bigger than the pivot value and to the left items smaller than the pivot value. It propagates the same process to each partition, recursively.

Merge sort: use recursion to divide the list to the smallest unit, then order each subset. It merges subset bigger and bigger, that being already order are easy to merge in an ordered list. This is repeated until two big subset are merged into the full ordered list.

Here's an example with bubble sort, that is the slowest but simplest algorithm:

```	import java.util.Arrays;

public class App {

private static int[] array = { 5,7,23,54,74,12,54,3,67 };

/**
* Bubble sort an array
*/
private static void bubbleSort(int array[]) {

// Repeat the below process as many times as the items
for (int c =  array.length; c >= 0; c--) {

// Traverse the array and swap items out of order
for (int i = 0; i <  array.length - 1; i++) {

// Checks if contiguous items are in order
if (array[i] > array[i + 1])
swap(i, i + 1);
}
}
}

/**
* Swap the values because they are not in the correct order
*/
private static void swap(int i, int j) {

int temp = array[i];
array[i] = array[j];
array[j] = temp;
}

/**
* Demonstrates the bubble sort
*/
public static void main(String[] args) {

bubbleSort(array);
System.out.println(Arrays.toString(array));

}
}
```