Three way Quicksort in Java What do you think about this implementation of quicksort? Is it possible to make it shorter?

/**
 * 3-way quicksort
 * &lt;p/&gt;
 * Choose a value an put the greater values to the right, lowers to the
 * left, and equals in the center. recursive. O(n^2) but avg O(n log n). Memory: In place
 */
public static void quickSort(int[] array) {
    shuffleArray(array);
    quickSort(array, 0, array.length - 1);
}

private static void quickSort(int[] array, int lo, int hi) {
    if (hi &lt;= lo)
        return;

    int lowerIndex = lo;
    int greaterIndex = hi;
    int element = array[lo];
    int i = lo;

    while (i &lt;= greaterIndex) {
        if (array[i] &lt; element)
            swap(array, lowerIndex++, i++);
        else if (array[i] &gt; element)
            swap(array, i, greaterIndex--);
        else
            i++;
    }

    quickSort(array, lo, lowerIndex - 1);
    quickSort(array, greaterIndex + 1, hi);
}

// O(n)
private static void shuffleArray(int[] ar) {
    Random rnd = new Random();
    for (int i = ar.length - 1; i &gt; 0; i--) {
        int index = rnd.nextInt(i + 1); // random between 0 and i
        swap(ar, i, index);
    }
}

private static void swap(int[] array, int i, int j) {
    int a = array[i];
    array[i] = array[j];
    array[j] = a;
}
i should be initialized to lo + 1 this will reduce the while loop by 1
you should use braces {} for single if statements. This will make your code less errorprone.  
instead of doing this recursively, you could do is iterativ by adding a while loop with (lo &lt; lowerIndex - 1 &amp;&amp; greaterIndex + 1 &lt; hi) as condition.  
for make the if..else if you shoul consider to swap the position of element and array [i] because if you imagine the array, index 0 will be on the left  

if (element &gt; array[i])