java中Arrays.sort()排序的方法總結

java中使用Arrays.sort()排序對一個數組進行排序

• Arrays.sort(int[] a)
• Arrays.sort(int[] a, int fromIndex, int toIndex)
• public static void ort(T[] a,int fromIndex,int toIndex, Comparator c)

 

---

 

 

Arrays.sort(int[] a)

對一個數組的所有元素進行排序，按從小到大排序

import java.util.Arrays;

 public class Main {
     public static void main(String[] args) {

         int[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
         Arrays.sort(a);
         for(int i = 0; i < a.length; i ++) {
              System.out.print(a[i] + " ");
         }
     }

 }

 

結果為：0 1 2 3 4 5 6 7 8 9

 

---

 

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

對數組部分排序，也就是對數組a的下標從fromIndex到toIndex-1的元素排序，注意：下標為toIndex的元素不參與排序哦！

import java.util.Arrays;

  public class Main {
      public static void main(String[] args) {

          int[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
          Arrays.sort(a, 0, 3);
          for(int i = 0; i < a.length; i ++) {
              System.out.print(a[i] + " ");
          }
      }

  }

 

結果為：7 8 9 2 3 4 1 0 6 5

 

---

 

 

public static void ort(T[] a,int fromIndex,int toIndex, Comparator c)

在上述方法中，我們只能對數組進行從小到大的排序，並且排序的類型只能是java的基本類型。如果我們想要定義自己的排序規則，例如，從大到小排序、針對類中的某一變量進行排序。此時，我們可以繼承接口Comparable中並重寫CompareTo（）方法來達到目的。

我將這種方法分為兩種運用場景。

• 針對java的類
• 針對自己創建的類

針對java的類

package TestCodes;
import java.util.Arrays;
import java.util.Comparator;

// Comparator是一個接口， 所以這里我們自己定義的類MyComparable要implents接口
// 而不是extends Comparator
class MyComparator implements Comparator<Integer>{
    @Override
    public int compare(Integer a1, Integer a2) {
        //  a1 < a2 => 1; a1 > a2 => -1; a1 == a2 => 0        這是從小到大的排序
        // 顛倒一下就是從大到小
        
        //return -Integer.compare(a1, a2);
        if(a1 > a2)
            return 1;
        else if(a1 < a2)
            return -1;
        else {
            return 0;
        }
    }
}

public class Test_02 {
    public static void main(String[] args) {
        // 注意，要想改變默認的排列順序，不能使用基本類型（int，double，char）
        //而要使用它們對應的類
        Integer[] aIntegers = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
        Comparator cmpComparable = new MyComparator();
        Arrays.sort(aIntegers, cmpComparable);
        for(int i : aIntegers)
            System.out.print(i + " ");
    }
}

 

注意：

1. 不能使用基本類型（int、double、char），而是使用它們對應的類，例如Intergers
2. 在這里implents的接口是Comparator，重寫compare方法

 

針對自己創建的類

• 第一種寫法

public class Car implements Comparable{
	private double speed

	public Car(double speed) {
		this.speed = speed;
	}

	@Override
	public int compareTo(Object newCar) {
		return Double.compare(this.getSpeed(),((Car)newCar).getSpeed());
	}	
}

 

• 第二種寫法

public class Car implements Comparable<Car>{
	private double speed;

	public Car(double speed) {
		this.speed = speed;
	}

	@Override
	public int compareTo(Car newCar) {
		return Double.compare(this.getSpeed(),newCar.getSpeed());
	}	
}

 

main方法：

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());
		}
	}
	
}

 注意：

1. 第一種寫法中使用了對象的強制轉換，而第二種寫法是使用了泛型。使用泛型時在使用接口時需聲明是哪一種對象，然后后面就不需要強制轉換了。推薦泛型的方法。
2. 在這里implents的接口是Comparable，重寫compareTo方法。
3. 需要注意區分與針對java的類的寫法。

 

綜合應用（華東師范大學Java慕課上的作業題）

package 華東師范java慕課第十章數據結構作業;

import java.util.Arrays;
import java.util.Scanner;

class Currency{
    private String nameString;        // 貨幣名稱
    private int originalValue;        // 原始值
    private int value;            // 轉換為人民幣后的值
    
    // 這里每個對象都會用到它，所以可以定義為常量
    public static String[] CURRENCY_NAME = {"CNY", "HKD", "USD", "EUR"};    
    public static int[]    CURRENCY_RATIO = {100, 118, 15, 13};
    
    public String getnameString() {
        return nameString;
    }
    
    public void setNameString(String nameString) {
        this.nameString = nameString;
    }
    
    public int getOriginalValue() {
        return originalValue;
    }
    public void setOriginalValue(int originalValue) {
        this.originalValue = originalValue;
    }

    public int getValue() {
        return value;
    }
    public void setValue(int value) {
        this.value = value;
    }
}

class HKD extends Currency implements Comparable{
    HKD(int a){
        this.setNameString("HKD");
        this.setOriginalValue(a);
        double money = ((double)a)/this.CURRENCY_RATIO[1] * this.CURRENCY_RATIO[0];
        this.setValue((int)money);
    }
    
    //@Override
    public int compareTo(Object cur){
        return Integer.compare(this.getValue(), ((Currency)cur).getValue());
    }

}
class USD extends Currency implements Comparable {
    // 實現你的構造函數與Comparable中的接口    
    USD(int a){
        this.setNameString("USD");
        this.setOriginalValue(a);
        double money = ((double)a)/this.CURRENCY_RATIO[2] * this.CURRENCY_RATIO[0];
        this.setValue((int)money);
    }
    
    public int compareTo(Object cur){
        return Integer.compare(this.getValue(), ((Currency)cur).getValue());
    }
}

class EUR extends Currency implements Comparable {
    // 實現你的構造函數與Comparable中的接口    
    EUR(int a){
        this.setNameString("EUR");
        this.setOriginalValue(a);
        double money = ((double)a)/this.CURRENCY_RATIO[3] * this.CURRENCY_RATIO[0];
        this.setValue((int)money);
    }
    
    public int compareTo(Object cur){
        return Integer.compare(this.getValue(), ((Currency)cur).getValue());
    }
}



public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Currency[] cs = new Currency[3];
        Scanner sc = new Scanner(System.in);
        //hasNext（）時，它會先掃描緩沖區中是否有字符，有則返回true,繼續掃描。直到掃描為空，
        //這時並不返回false,而是將方法阻塞，等待你輸入內容然后繼續掃描
        
        int a = 0;
        int b = 0;
        int c = 0;
        if (sc.hasNext()) {
            a = sc.nextInt();
            cs[0] = new HKD(a);
        }

        if (sc.hasNext()) {
            b = sc.nextInt();
            cs[1] = new USD(b);
        }

        if (sc.hasNext()) {
            c = sc.nextInt();
            cs[2] = new EUR(c);
        }

        Arrays.sort(cs);
        
        for(Currency myCurrency : cs) {
            System.out.println(myCurrency.getnameString()+": "+myCurrency.getValue());
        }
    }

}

 

 

 

 

 參考博客：

1. java中Arrays.sort()的幾種用法

2. Java使用Arrays.sort()方法給對象排序