Java使用lambda自定義Arrays.sort排序規(guī)則說明

第Java使用lambda自定義Arrays.sort排序規(guī)則說明目錄lambda自定義Arrays.sort排序規(guī)則1.類間排序2.使用比較器(comparator)作為sort的參數(shù)(用于單個類型的排序)補充一下Arrays.sort()的一些用法1.對指定T型數(shù)組按指定數(shù)值升序排序2.對指定T型數(shù)組的指定范圍按指定數(shù)值升序排序3.根據(jù)指定比較器產(chǎn)生的順序?qū)χ付▽ο髷?shù)組進行排序

lambda自定義Arrays.sort排序規(guī)則

1.類間排序

首先注意默認排規(guī)則，當使用sort(Objetc[]a)來進行對象的自然排序，該對象必需實現(xiàn)Compareable接口，重寫compareableTo方法，并一般在此方法中定義這3種返回值（1，0，-1）來進行排序標準的確認。

return1時，按照從小到大排序（也可以是2，3.....正數(shù)）return0時，原位置不動return-1時，按照從大到小排序

publicclassPersonimplementsComparableEmployee{

privateStringname;

privateintage;

publicPerson(){

publicPerson(Stringname,intage){

=name;

this.age=age;

*Comparespersonbyage

*@paramotheranotherPersonobject

*returnanegativevalueifthisemployeehasaloweragethan

*otherObject,0iftheagearethesame,apositivevalueotherwise

publicintcompareTo(Personother){

returnIpare(age,other.age);

}

2.使用比較器(comparator)作為sort的參數(shù)(用于單個類型的排序)

//正常方式

Arrays.sort(arr,newComparatorint[](){

publicintcompare(int[]a,int[]b){

returna[0]-b[0];

});

//lambda方式

Integer[]numsArr=newInteger[10];

Arrays.sort(numsArr,(x,y)-{

intsx=10,sy=10;

while(x=sx){

sx*=10;

while(y=sy){

sy*=10;

return(int)(sx*y+y-sy*x-x);

});

需要注意傳入數(shù)組必須是對象類型

補充一下

注意：Arrays.sort()使用的是雙軸快排：

1.對于很小的數(shù)組（長度小于27），會使用插入排序。

2.選擇兩個點P1,P2作為軸心，比如我們可以使用第一個元素和最后一個元素。

3.P1必須比P2要小，否則將這兩個元素交換，現(xiàn)在將整個數(shù)組分為四部分：

（1）第一部分：比P1小的元素。

（2）第二部分：比P1大但是比P2小的元素。

（3）第三部分：比P2大的元素。

（4）第四部分：尚未比較的部分。

在開始比較前，除了軸點，其余元素幾乎都在第四部分，直到比較完之后第四部分沒有元素。

4.從第四部分選出一個元素a[K]，與兩個軸心比較，然后放到第一二三部分中的一個。

5.移動L，K，G指向。

6.重復45步，直到第四部分沒有元素。

7.將P1與第一部分的最后一個元素交換。將P2與第三部分的第一個元素交換。

8.遞歸的將第一二三部分排序。

對于基本類型的數(shù)組如int[],double[],char[],Arrays類只提供了默認的升序排列，沒有降序，需要傳入自定義比較器，使用Arrays.sort(num,c)，傳入一個實現(xiàn)了Comparator接口的類的對象c。

逆序排列：

Arrays.sort(num,newComparatorInteger(){

publicintcompare(Integera,Integerb){

returnb-a;

});

Compare函數(shù)：

Comparesitstwoargumentsfororder.Returnsanegativeinteger,zero,orapositiveintegerasthefirstargumentislessthan,equalto,orgreaterthanthesecond.

1：前面的數(shù)后面的數(shù)，是降序（從大到小）排列，如果想要改為升序排列，就需要返回1-1：前面的數(shù)后面的數(shù)，是升序（從小到大）排列，不改變位置就返回-1；0：二者相等，不進行交換，也就不排序。但是要根據(jù)題目來判斷返回什么。如果數(shù)組是無序的，不能直接返回0。若保證升序排列，要返回o1-o2，降序則o2-o1。

return0:不交換位置，不排序return1:交換位置return-1:不交換位置returno1-o2:升序排列returno2-o1:降序排列

compare方法中，寫成returnpareTo(o2)或者returno1-o2表示升序；（2）寫成returnpareTo(o1)或者returno2-o1表示降序

Arrays.sort()的一些用法

Arrays.sort()重載了四類方法

sort(T[]a)：對指定T型數(shù)組按數(shù)字升序排序。sort(T[]a,intformIndex,inttoIndex)：對指定T型數(shù)組的指定范圍按數(shù)字升序排序。sort(T[]a,Comparatorc)：根據(jù)指定比較器產(chǎn)生的順序?qū)χ付▽ο髷?shù)組進行排序。sort(T[]a,intformIndex,inttoIndex,Comparatorc)：根據(jù)指定比較器產(chǎn)生的順序?qū)χ付▽ο髷?shù)組的指定對象數(shù)組進行排序。

參數(shù)說明：查看源碼就知道重載的數(shù)據(jù)類型包括Object一共有八個,其他七個就是基本類型:int,long,short,char,byte,float,double.

1.對指定T型數(shù)組按指定數(shù)值升序排序

int[]ints=newint[]{12,4,6,7,2,8,3,9};//按數(shù)字

char[]chars=newchar[]{'a','c','b','i','+'};//按ascii碼

byte[]bytes=newbyte[]{7,5,6,10,-1};//按字節(jié)數(shù)

Arrays.sort(ints);

Arrays.sort(chars);

Arrays.sort(bytes);

System.out.println(Arrays.toString(ints));

//結(jié)果：[2,3,4,6,7,8,9,12]

System.out.println(Arrays.toString(chars));

//結(jié)果：[+,a,b,c,i]

System.out.println(Arrays.toString(bytes));

//結(jié)果：[-1,5,6,7,10]

2.對指定T型數(shù)組的指定范圍按指定數(shù)值升序排序

int[]ints=newint[]{12,4,6,7,2,8,3,9};//按數(shù)字

char[]chars=newchar[]{'a','c','b','i','+'};//按ascii碼

byte[]bytes=newbyte[]{7,5,6,10,-1};//按字節(jié)數(shù)

Arrays.sort(ints,2,5);

Arrays.sort(chars,2,5);

Arrays.sort(bytes,2,5);

System.out.println(Arrays.toString(ints));

//結(jié)果：[12,4,2,6,7,8,3,9]

System.out.println(Arrays.toString(chars));

//結(jié)果：[a,c,+,b,i]

System.out.println(Arrays.toString(bytes));

//結(jié)果：[7,5,-1,6,10]

3.根據(jù)指定比較器產(chǎn)生的順序?qū)χ付▽ο髷?shù)組進行排序

（1）一維數(shù)組降序排序

這里用降序演示一下;

/*注意，要想改變默認的排列順序，不能使用基本類型（int,double,char）

而要使用它們對應的包裝類*/

Integer[]ints=newInteger[]{12,4,6,7,2,8,3,9};

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

System.out.println(Arrays.toString(ints));

//結(jié)果：[12,9,8,7,6,4,3,2]

也可以使用自定義規(guī)則

Arrays.sort(ints,newComparatorInteger(){

@Override

publicintcompare(Integero1,Integero2){

returno2-o1;

}

//lambda表達式

Arrays.sort(ints,(o1,o2)-o2-o1);

（2）二維數(shù)組按一維數(shù)組排序升序

PS：這里提一下如果是Integer數(shù)組比較相等時用equals而不是用==。至于為什么請看==和equals的區(qū)別

int[][]nums=newint[][]{{1,3},{1,2},{5,1},{4,5},{3,3}};

//方法一

Arrays.sort(nums,newComparatorint[](){

@Override

publicintcompare(int[]a,int[]b){

//當?shù)谝痪S相等時比較第二維的

if(a[0]==b[0]){

returna[1]-b[1];

}else{

returna[0]-b[0];

}

}

//方法二，使用lambda表達式

Arrays.sort(nums,(a,b)-a[0]==b[0]a[1]-b[1]:a[0]-b[0]);

for(int[]num:nums){

System.out.print(Arrays.toString(num));

//結(jié)果：[1,2][1,3][3,3][4,5][5,1]

（3）二維數(shù)組按二維數(shù)組排序升序

int[][]nums=newint[][]{{1,3},{1,2},{5,1},{4,5},{3,3}};

//方法一

Arrays.sort(nums,newComparatorint[](){

@Override

publicintcompare(int[]a,int[]b){

//當?shù)诙S相等時比較第一維的

if(a[1]==b[1]){

returna[0]-b[0];

}else{

returna[1]-b[1];

}

}

//方法二，使用lambda表達式

Arrays.sort(nums,(a,b)-a[1]==b[1]

a[0]-b[0]:a[1]-b[1]);

for(int[]num:nums){

System.out.print(Arrays.toString(num));

//結(jié)果：[5,1][1,2][1,3][3,3][4,5]

（4）二維數(shù)組降序

對調(diào)返回值哪里的順序