Quicksort using Comparable can sort out negative value well !!

Question

man , i have waste another day try to solve this logic problem. It was not easy as what i thought. The Qsort method which i found it on the net and i apply it into my java code .. i do understand his code well , however the result does not sort out well especially negative number or if there is there are small number at the end of the array. Below are some result which i compile .Hope someone can help me , i going crazy soon.
sample 1:
Before Soft()
[93, 50, 34, 24, -48, 27, 45, 11, 60, 51, -95, 16, -12, -71, -37, 2]
After Soft()
[-12, -37, -48, -71, -95, 11, 16, 2, 24, 27, 34, 45, 50, 51, 60, 93]
sample 2:
Before Soft()
[-93, 50, -34, -24, 48, -27, -45, 11, 60, 51, -95, 16, -12, -71, -37, 2]
After Soft()
[-12, -24, -27, -34, -37, -45, -71, -93, -95, 11, 16, 2, 48, 50, 51, 60]
sample 3 ==> this one is correct ;-)
Before Soft()
[93, 50, 34, 24, 48, 27, 45, 11, 60, 51, 95, 16, 12, 71, 37, 20]
After Soft()
[11, 12, 16, 20, 24, 27, 34, 37, 45, 48, 50, 51, 60, 71, 93, 95]
import java.util.*;
import java.lang.Comparable;
public class QuickSort {
// static Comparable [] array;
public QuickSort(){}
public static void main ( String [] args){
          QuickSort qs =new QuickSort ( );
          Object [] test = new Object [16];
          test[0]="93";
          test[1]="50";
          test[2]="34";
          test[3]="24";
          test[4]="-48";
          test[5]="27";
          test[6]="45";
          test[7]="11";
          test[8]="60";
          test[9]="51";
          test[10]="-95";
          test[11]="16";
          test[12]="-12";
          test[13]="-71";
          test[14]="-37";
          test[15]="2";
          for (int i=0;i<test.length;i++)
          System.out.println(test);
          System.out.println();
/* Copy the value from the Object [ ]test into Comparable [] array. /*
Comparable [] array = new Comparable [test.length];
for(int i=0;i<array.length;i++)
     array [i]=(Comparable) test[i];          
     System.out.println(array[i]); //test if the value is the same as the test Object //
System.out.println("Before Soft()");
System.out.println(Arrays.asList(array));
qs.sort(array); //call sort method to sort the array
System.out.println("After Soft()");
     System.out.println(Arrays.asList(array));
* Sorts the array of Comparable objects using the QuickSort algorithm.
* @param comparable an array of java.lang.Comparable objects
public void sort(Comparable comparable[]) {
QSort(comparable, 0, comparable.length - 1);
* @param comparable an array of java.lang.Comparable objects
* @param lowInt int containing lowest index of array partition
* @param highInt int containing highest index of array partition
static void QSort(Comparable comparable[], int lowInt, int highInt) {
int low = lowInt;
int high = highInt;
Comparable middle;
// The partion to be sorted is split into two separate sections which are
// sorted individually. This is done by arbitrarily establishing the middle
// object as the starting point.
if (highInt > lowInt) {
middle = comparable[(lowInt + highInt) / 2];
// Increment low and decrement high until they cross.
while (low <= high) {
// Increment low until low >= highInt or the comparison between
// middle and comparable[low] no longer yields -1 (ie comparable[low]
// is >= middle).
while (low < highInt && (comparable[low].compareTo(middle) < 0)) {
++low;
// Decrement high until high <= lowInt or the comparison between
// middle and comparable[high] no longer yields 1 (ie comparable[high]
// is <= middle).
while (high > lowInt && (comparable[high].compareTo(middle) > 0 )) {
--high;
/*switch over */
if (low <= high) {
Comparable obj;
obj = comparable[low];
comparable[low] = comparable[high];
comparable[high] = obj;
++low;
--high;
if (lowInt < high) {
QSort(comparable, lowInt, high);
if (low < highInt) {
QSort(comparable, low, highInt);

Answer 1

the problem is solve after cos i cast a string variable into the object comparable. The problem is solve after i use cast Integer into the object.
regards
st