arraysortjava

『壹』 java中Arrays.sort使用的是什麼演算法

Arrays.sort()
先來看看Arrays.sort();，一點進這個方法會看到是這樣子的
publicstaticvoidsort(int[]a){
DualPivotQuicksort.sort(a,0,a.length-1,null,0,0);
}123
果然沒這么簡單，DualPivotQuicksort翻譯過來就是雙軸快速排序，關於雙軸排序可以去這里http://www.cnblogs.com/nullzx/p/5880191.html看看。那再次點進去，可以發現有這么一段代碼
if(right-left<QUICKSORT_THRESHOLD){
sort(a,left,right,true);
return;
}1234
可以發現如果數組的長度小於QUICKSORT_THRESHOLD的話就會使用這個雙軸快速排序，而這個值是286。
那如果大於286呢，它就會堅持數組的連續升序和連續降序性好不好，如果好的話就用歸並排序，不好的話就用快速排序，看下面這段注釋就可以看出
*Thearrayisnothighlystructured,
*.
123
那現在再回到上面的決定用雙軸快速排序的方法上，再點進去，發現又會多一條判斷
//Useinsertionsortontinyarrays
if(length<INSERTION_SORT_THRESHOLD)
123
即如果數組長度小於INSERTION_SORT_THRESHOLD(值為47)的話，那麼就會用插入排序了，不然再用雙軸快速排序。
所以總結一下Arrays.sort()方法，如果數組長度大於等於286且連續性好的話，就用歸並排序，如果大於等於286且連續性不好的話就用雙軸快速排序。如果長度小於286且大於等於47的話就用雙軸快速排序，如果長度小於47的話就用插入排序。真是有夠繞的~

『貳』 JAVA中如何用array類中的sort排序方法實現數組排序

public static void main(String[] args) {
int[] iii={4,5,61,3,2,4,26,21,2,-82,34};
Arrays.sort(iii);
for (int i : iii) {
System.out.println(i);
}
}

『叄』 java array.sort用的是什麼排序

用Arrays類sort()對數組元素進行降序排列： import java.util.Arrays; class SortDemo { public static void main(String[] args) { int[] vec={0,15,-14,45,20,70}; Arrays.sort(vec); System.out.println("/n"); System.out.println("降序排列

『肆』 關於Java中Array.sort()排序原理，越詳細越好！

是Arrays.sort(a);吧

給你看源碼

=============

/**/publicstaticvoidsort(int[]paramArrayOfInt)
/**/{
/*96*/sort1(paramArrayOfInt,0,paramArrayOfInt.length);
/**/}

//

/**/privatestaticvoidsort1(int[]paramArrayOfInt,intparamInt1,intparamInt2)
/**/{
/*558*/if(paramInt2<7){
/*559*/for(i=paramInt1;i<paramInt2+paramInt1;i++)
/*560*/for(j=i;(j>paramInt1)&&(paramArrayOfInt[(j-1)]>paramArrayOfInt[j]);j--)
/*561*/swap(paramArrayOfInt,j,j-1);
/*562*/return;
/**/}
/**/
/**/
/*566*/inti=paramInt1+(paramInt2>>1);
/*567*/if(paramInt2>7){
/*568*/j=paramInt1;
/*569*/k=paramInt1+paramInt2-1;
/*570*/if(paramInt2>40){
/*571*/m=paramInt2/8;
/*572*/j=med3(paramArrayOfInt,j,j+m,j+2*m);
/*573*/i=med3(paramArrayOfInt,i-m,i,i+m);
/*574*/k=med3(paramArrayOfInt,k-2*m,k-m,k);
/**/}
/*576*/i=med3(paramArrayOfInt,j,i,k);
/**/}
/*578*/intj=paramArrayOfInt[i];
/**/
/**/
/*581*/intk=paramInt1;intm=k;intn=paramInt1+paramInt2-1;inti1=n;
/**/for(;;){
/*583*/if((m<=n)&&(paramArrayOfInt[m]<=j)){
/*584*/if(paramArrayOfInt[m]==j)
/*585*/swap(paramArrayOfInt,k++,m);
/*586*/m++;
/**/}else{
/*588*/while((n>=m)&&(paramArrayOfInt[n]>=j)){
/*589*/if(paramArrayOfInt[n]==j)
/*590*/swap(paramArrayOfInt,n,i1--);
/*591*/n--;
/**/}
/*593*/if(m>n)
/**/break;
/*595*/swap(paramArrayOfInt,m++,n--);
/**/}
/**/}
/**/
/*599*/inti3=paramInt1+paramInt2;
/*600*/inti2=Math.min(k-paramInt1,m-k);vecswap(paramArrayOfInt,paramInt1,m-i2,i2);
/*601*/i2=Math.min(i1-n,i3-i1-1);vecswap(paramArrayOfInt,m,i3-i2,i2);
/**/
/**/
/*604*/if((i2=m-k)>1)
/*605*/sort1(paramArrayOfInt,paramInt1,i2);
/*606*/if((i2=i1-n)>1){
/*607*/sort1(paramArrayOfInt,i3-i2,i2);
/**/}
/**/}
/**/
/**/
/**/privatestaticvoidswap(int[]paramArrayOfInt,intparamInt1,intparamInt2)
/**/{
/*614*/inti=paramArrayOfInt[paramInt1];
/*615*/paramArrayOfInt[paramInt1]=paramArrayOfInt[paramInt2];
/*616*/paramArrayOfInt[paramInt2]=i;
/**/}

『伍』 Arrays.sort(a);在java中是什麼意思，起什麼作用

a
是個數組吧，Array.sort()是個排序的方法，就是對數組a進行從小到大的排序

『陸』 java中如何使用arrays.sort()對二維數組排序

沒辦法直接排序的。自己寫排序方法吧。你也可以用List或Map存放數據，再用Collections的sort(list,comprator)進行排序。comprator是重寫的比較器，要怎麼排都隨你。

『柒』 java數組排序問題：array.sort()是從小到大排序，那麼如何從大到小排序

你先用array.sort()從小到大排序，然後我記得array裡面應該有個方法叫reverse()，就是把這個數組反過來，也就是從大到小了。
不過這樣小數據量還好，大數據效率就不高哈

『捌』 java 中 Arrays.sort()的使用疑問

a
是個數組吧，array.sort()是個排序的方法，就是對數組a進行從小到大的排序

『玖』 JAVA中Arrays.sort()排序的原理是什麼

有的時候需要對數組里的element進行排序。當然可以自己編寫合適的排序方法，但既然java包里有自帶的Arrays.sort排序方法，在 數組元素比較少的時候為何不用？

Sorting an Array 1. 數字排序 int[] intArray = new int[] { 4, 1, 3, -23 };

Arrays.sort(intArray);

輸出： [-23, 1, 3, 4]

2. 字元串排序，先大寫後小寫 String[] strArray = new String[] { "z", "a", "C" };

Arrays.sort(strArray);

輸出： [C, a, z]

3. 嚴格按字母表順序排序，也就是忽略大小寫排序 Case-insensitive sort

Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER);

輸出： [a, C, z]

4. 反向排序， Reverse-order sort

Arrays.sort(strArray, Collections.reverseOrder());

輸出：[z, a, C]

5. 忽略大小寫反向排序 Case-insensitive reverse-order sort

Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER);

Collections.reverse(Arrays.asList(strArray));

輸出： [z, C, a]

java初學者最常見的錯誤思想，就是試圖去寫一些方法來完成數組的排序功能，其實，數組排序功能，在java的api裡面早已實現，我們沒有 必要去重復製造輪子。

Arrays類有一個靜態方法sort,利用這個方法我們可以傳入我們要排序的數組進去排序，因為我們傳入的是一個數組的引用，所以排序完成的 結果也通過這個引用的來更改數組.對於整數、字元串排序，jdk提供了默認的實現，如果要對一個對象數組排序，則要自己實現 java.util.Comparator介面。

packagecom.gjh.gee.arrays;
importjava.util.Arrays;
publicclassArraySortDemo{
	publicvoidsortIntArray(){
		int[]arrayToSort=newint[]{48,5,89,80,81,23,45,16,2};
		System.out.println("排序前");
		for(inti=0;i<arrayToSort.length;i++)
			System.out.println(arrayToSort[i]);
		//調用數組的靜態排序方法sort
		Arrays.sort(arrayToSort);
		System.out.println("排序後");
		for(inti=0;i<arrayToSort.length;i++)
			System.out.println(arrayToSort[i]);
	}
	publicvoidsortStringArray(){
		String[]arrayToSort=newString[]{"Oscar","Charlie","Ryan",
		"Adam","David"};
		System.out.println("排序前");
		for(inti=0;i<arrayToSort.length;i++)
			System.out.println(arrayToSort[i]);
		System.out.println("排序後");
		//調用數組的靜態排序方法sort
		Arrays.sort(arrayToSort);
		for(inti=0;i<arrayToSort.length;i++)
			System.out.println(arrayToSort[i]);
	}
	publicvoidsortObjectArray(){
		Dogo1=newDog("dog1",1);
		Dogo2=newDog("dog2",4);
		Dogo3=newDog("dog3",5);
		Dogo4=newDog("dog4",2);
		Dogo5=newDog("dog5",3);
		Dog[]dogs=newDog[]{o1,o2,o3,o4,o5};
		System.out.println("排序前");
		for(inti=0;i<dogs.length;i++){
			Dogdog=dogs[i];
			System.out.println(dog.getName());
		}
		Arrays.sort(dogs,newByWeightComparator());
		System.out.println("排序後：");
		for(inti=0;i<dogs.length;i++){
			Dogdog=dogs[i];
			System.out.println(dog.getName());
		}
	}
	publicstaticvoidmain(String[]args){
		ArraySortDemot=newArraySortDemo();
		t.sortIntArray();
		t.sortStringArray();
		t.sortObjectArray();
	}
}

『拾』 java中用Arrays sort()如何將字元串倒序排列如,將"abcdefg"排序為"gfedcba".

java中用arrays sort（）方法將abcdefg倒序，可以先試用java的comparable介面先進行比較，然後排序，實例如下：

packagetest;

importjava.util.Arrays;
importjava.util.Comparator;

publicclassArraysort{
publicstaticvoidmain(String[]args){
Strings="a,b,c,d,e,f,g";
String[]strArr=s.split(",");
Arrays.sort(strArr,newcom());//排序
for(Stringstr:strArr){
System.out.print(str+",");
}
}
}

classcom<T>implementsComparator<T>{//對abcdefg進行比較大小，排序
publicintcompare(To1,To2){
inti=Integer.parseInt(String.valueOf(o1));
intj=Integer.parseInt(String.valueOf(o2));
if(i>j)return1;
if(i<j)return-1;
return0;
}
}