public class Car{
	private double speed;//車輛的速度屬性
	public Car(double speed) {
		this.speed = speed;
	}
	public double getSpeed() {
		return speed;
	}
	public void setSpeed(double speed) {
		this.speed = speed;
	}	
}

for(int i=0;i<a.length-1;i++)//a為一個(gè)存儲(chǔ)了很多Car對(duì)象的數(shù)組
{
	for(int j=0;j<a.length-i-1;j++)
	{
		if(a[j].getSpeed()>a[j+1].getSpeed())//交換操作
		{
			Car temp=a[j];
			a[j]=a[j+1];
			a[j+1]=temp;
		}
	}
}

public class Car implements Comparable<Car>{
	private double speed;
	public Car(double speed) {
		this.speed = speed;
	}
	public double getSpeed() {
		return speed;
	}
	public void setSpeed(double speed) {
		this.speed = speed;
	}
	@Override
	public int compareTo(Car newCar) {
		return Double.compare(this.getSpeed(),newCar.getSpeed());
	}	
}

public class Car implements Comparable{
	private double speed;
	public Car(double speed) {
		this.speed = speed;
	}
	public double getSpeed() {
		return speed;
	}
	public void setSpeed(double speed) {
		this.speed = speed;
	}
	@Override
	public int compareTo(Object newCar) {
		return Double.compare(this.getSpeed(),((Car)newCar).getSpeed());
	}	
}

public class Test8 {
	public static void main(String[] args) {
		Car[] carList = new Car[3];
		carList[0] = new Car(30);
		carList[1] = new Car(10);
		carList[2] = new Car(55);
		Arrays.sort(carList);
		
		for(Car c:carList)
		{
			System.out.println(c.getSpeed());
		}
	}	
}

Arrays.sort(int[] a)

 //注意一定要用Integer對(duì)象類
        Integer[] a1 = {34, 57, 46, 89, 98, 12, 55, 84, 29};
        Integer[] a2 = {34, 57, 46, 89, 98, 12, 55, 84, 29};
        //增序，Arrays.sort()默認(rèn)升序
        Arrays.sort(a1);
        System.out.println("Arrays.sort()升序:");
        for (int i = 0; i < a1.length; i++) {
            System.out.print(a1[i] + " ");
        }
        //降序，可用Comparator()匿名內(nèi)部類
        Arrays.sort(a2, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2.compareTo(o1);
            }
        });
        System.out.println("\nArrays.sort()降序:");
        for (int i = 0; i < a2.length; i++) {
            System.out.print(a2[i]+ " ");
        }

Arrays.sort(int[] a, int fromIndex, int toIndex)

//注意一定要用Integer對(duì)象類
Integer[] a1 = {34, 57, 46, 89, 98, 12, 55, 84, 29};
 //對(duì)數(shù)組中的第四位到第7位（不包含第七位）（左閉右開(kāi)原則）進(jìn)行排序
 Arrays.sort(a1,3,6);
 System.out.println("Arrays.sort()升序:");
 for (int i = 0; i < a1.length; i++) {
     System.out.print(a1[i] + " ");
 }

 // Use Quicksort on small arrays
    if (right - left < QUICKSORT_THRESHOLD) {
            sort(a, left, right, true);
            return;
    }
    // Merge sort
    ......

 // Use insertion sort on tiny arrays
    if (length < INSERTION_SORT_THRESHOLD) {
    // Insertion sort
    ......
    }

 // Inexpensive approximation of length / 7
    int seventh = (length >> 3) + (length >> 6) + 1;

 /*
     * Sort five evenly spaced elements around (and including) the
     * center element in the range. These elements will be used for
     * pivot selection as described below. The choice for spacing
     * these elements was empirically determined to work well on
     * a wide variety of inputs.
     */
    int e3 = (left + right) >>> 1; // The midpoint
    int e2 = e3 - seventh;
    int e1 = e2 - seventh;
    int e4 = e3 + seventh;
    int e5 = e4 + seventh;

// Sort these elements using insertion sort
    if (a[e2] < a[e1]) { int t = a[e2]; a[e2] = a[e1]; a[e1] = t; }
    if (a[e3] < a[e2]) { int t = a[e3]; a[e3] = a[e2]; a[e2] = t;
    if (t < a[e1]) { a[e2] = a[e1]; a[e1] = t; }
    }
    if (a[e4] < a[e3]) { int t = a[e4]; a[e4] = a[e3]; a[e3] = t;
        if (t < a[e2]) { a[e3] = a[e2]; a[e2] = t;
            if (t < a[e1]) { a[e2] = a[e1]; a[e1] = t; }
        }
    }
    if (a[e5] < a[e4]) { int t = a[e5]; a[e5] = a[e4]; a[e4] = t;
        if (t < a[e3]) { a[e4] = a[e3]; a[e3] = t;
            if (t < a[e2]) { a[e3] = a[e2]; a[e2] = t;
                if (t < a[e1]) { a[e2] = a[e1]; a[e1] = t; }
            }
        }
    }

 /*
         * Use the second and fourth of the five sorted elements as pivots.
         * These values are inexpensive approximations of the first and
         * second terciles of the array. Note that pivot1 <= pivot2.
         */
        int pivot1 = a[e2];
        int pivot2 = a[e4];
        /*
         * The first and the last elements to be sorted are moved to the
         * locations formerly occupied by the pivots. When partitioning
         * is complete, the pivots are swapped back into their final
         * positions, and excluded from subsequent sorting.
         */
        a[e2] = a[left];
        a[e4] = a[right];
        /*
         * Skip elements, which are less or greater than pivot values.
         */
        while (a[++less] < pivot1);
        while (a[--great] > pivot2);

/*
 * Partitioning:
 *
 *   left part           center part                   right part
 * +--------------------------------------------------------------+
 * |  < pivot1  |  pivot1 <= && <= pivot2  |    ?    |  > pivot2  |
 * +--------------------------------------------------------------+
 *               ^                          ^       ^
 *               |                          |       |
 *              less                        k     great
 *
 * Invariants:
 *
 *              all in (left, less)   < pivot1
 *    pivot1 <= all in [less, k)     <= pivot2
 *              all in (great, right) > pivot2
 *
 * Pointer k is the first index of ?-part.
 */
        outer:
        for (int k = less - 1; ++k <= great; ) {
            int ak = a[k];
            if (ak < pivot1) { // Move a[k] to left part
                a[k] = a[less];
                /*
                 * Here and below we use "a[i] = b; i++;" instead
                 * of "a[i++] = b;" due to performance issue.
                 */
                a[less] = ak;
                ++less;
            } else if (ak > pivot2) { // Move a[k] to right part
                while (a[great] > pivot2) {
                    if (great-- == k) {
                        break outer;
                    }
                }
                if (a[great] < pivot1) { // a[great] <= pivot2
                    a[k] = a[less];
                    a[less] = a[great];
                    ++less;
                } else { // pivot1 <= a[great] <= pivot2
                    a[k] = a[great];
                }
                /*
                 * Here and below we use "a[i] = b; i--;" instead
                 * of "a[i--] = b;" due to performance issue.
                 */
                a[great] = ak;
                --great;
            }
        }

// Swap pivots into their final positions
        a[left]  = a[less  - 1]; a[less  - 1] = pivot1;
        a[right] = a[great + 1]; a[great + 1] = pivot2;

// Sort left and right parts recursively, excluding known pivots
        sort(a, left, less - 2, leftmost);
        sort(a, great + 2, right, false);

/*
         * If center part is too large (comprises > 4/7 of the array),
         * swap internal pivot values to ends.
         */
        if (less < e1 && e5 < great) {
            /*
             * Skip elements, which are equal to pivot values.
             */
            while (a[less] == pivot1) {
                ++less;
            }
            while (a[great] == pivot2) {
                --great;
            }
        }
        ......
        // Sort center part recursively
        sort(a, less, great, false);