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的类

 1 package TestCodes;
 2 import java.util.Arrays;
 3 import java.util.Comparator;
 4 
 5 // Comparator是一个接口， 所以这里我们自己定义的类MyComparable要implents接口
 6 // 而不是extends Comparator
 7 class MyComparator implements Comparator<Integer>{
 8     @Override
 9     public int compare(Integer a1, Integer a2) {
10         //  a1 < a2 => 1; a1 > a2 => -1; a1 == a2 => 0        这是从小到大的排序
11         // 颠倒一下就是从大到小
12         
13         //return -Integer.compare(a1, a2);
14         if(a1 > a2)
15             return 1;
16         else if(a1 < a2)
17             return -1;
18         else {
19             return 0;
20         }
21     }
22 }
23 
24 public class Test_02 {
25     public static void main(String[] args) {
26         // 注意，要想改变默认的排列顺序，不能使用基本类型（int，double，char）
27         //而要使用它们对应的类
28         Integer[] aIntegers = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
29         Comparator cmpComparable = new MyComparator();
30         Arrays.sort(aIntegers, cmpComparable);
31         for(int i : aIntegers)
32             System.out.print(i + " ");
33     }
34 }

View Code

 

注意：

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

}

View Code

 

 

 

 

 参考博客：

  1. java中Arrays.sort()的几种用法

  2. Java使用Arrays.sort()方法给对象排序

版权声明：本文为jiangshengyin原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/jiangshengyin/p/13939285.html?ivk_sa=1024320u