java.util.Arrays.sort方法

java.util.Arrays.sort方法

Modifier and Type	方法	描述
static void	sort(byte[] a)	按照数字顺序排列指定的数组。
static void	sort(byte[] a, int fromIndex, int toIndex)	按升序排列数组的指定范围。
static void	sort(char[] a)	按照数字顺序排列指定的数组。
static void	sort(char[] a, int fromIndex, int toIndex)	按升序排列数组的指定范围。
static void	sort(double[] a)	按照数字顺序排列指定的数组。
static void	sort(double[] a, int fromIndex, int toIndex)	按升序排列数组的指定范围。
static void	sort(float[] a)	按照数字顺序排列指定的数组。
static void	sort(float[] a, int fromIndex, int toIndex)	按升序排列数组的指定范围。
static void	sort(int[] a)	按照数字顺序排列指定的数组。
static void	sort(int[] a, int fromIndex, int toIndex)	按升序排列数组的指定范围。
static void	sort(long[] a)	按照数字顺序排列指定的数组。
static void	sort(long[] a, int fromIndex, int toIndex)	按升序排列数组的指定范围。
static void	sort(short[] a)	按照数字顺序排列指定的数组。
static void	sort(short[] a, int fromIndex, int toIndex)	按升序排列数组的指定范围。
static void	sort(Object[] a)	根据其元素的natural ordering按照升序排列指定的对象数组。
static void	sort(Object[] a, int fromIndex, int toIndex)	根据其元素的natural ordering按照升序排列指定数组对象的指定范围。
static void	sort(T[] a, int fromIndex, int toIndex, Comparator c)	根据指定的比较器引发的顺序对指定的对象数组的指定范围进行排序。
static void	sort(T[] a, Comparator c)	根据指定的比较器引发的顺序对指定的对象数组进行排序。

sort(int[] a)

import java.util.Arrays;

public class TestSort {
    public static void main(String[] args) {
        test();

    }
    //测试  sort()方法
    public static void test(){
        int[] a = {1,2,3,5,10,8};
        Arrays.sort(a);
        System.out.println("排序后的数组："+Arrays.toString(a));
    }
}

排序后的数组：[1, 2, 3, 5, 8, 10]

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

import java.util.Arrays;

public class TestSort {
    public static void main(String[] args) {
        test();

    }
    //测试  sort()方法
    public static void test(){
        int[] a = {1,2,6,5,10,8};
        Arrays.sort(a,0,4);
        System.out.println("0-4位元素排序后的数组："+Arrays.toString(a));
    }
}

0-4位元素排序后的数组：[1, 2, 5, 6, 10, 8]

sort(T[] a, Comparator c)

import java.util.Arrays;
import java.util.Comparator;

public class TestSort {
    public static void main(String[] args) {
        test();

    }
    //测试  sort()方法
    public static void test(){
        String[] a = {"Natalie","小猪","Jack","miss","小花"};
        Arrays.sort(a,new StringComparator());
        System.out.println("排序后的字符串："+Arrays.toString(a));
    }
}

class StringComparator implements Comparator<String> {

    @Override
    public int compare(String o1, String o2) {
        return o1.compareTo(o2);
    }
}

排序后的字符串：[Jack, Natalie, miss, 小猪, 小花]

compare()方法

s

import java.util.Arrays;

public class TestSort {
    public static void main(String[] args) {
        test();

    }
    //测试  sort()方法
    public static void test(){
        StringComparable[] a = {new StringComparable("Natalie",3),
                new StringComparable("小猪",3),new StringComparable("Jack",2),
                new StringComparable("miss",1),new StringComparable("小花",1)};
        Arrays.sort(a);
        StringBuilder sb = new StringBuilder();
        sb.append("按id排序后的对象：[");
        for (StringComparable cp : a) {
            sb.append("id=").append(cp.id).append(" name=").append(cp.name).append(",");
        }
        sb.setCharAt(sb.length()-1,'}');
        System.out.println(sb.toString());
    }
}

class StringComparable implements Comparable<StringComparable> {
    int id;
    String name;

    public StringComparable(String name, int id) {
        this.id = id;
        this.name = name;
    }

    @Override
    public int compareTo(StringComparable o) {
        //升序
        if (this.id > o.id) {
            return 1;
        }

        else if (this.id < o.id) {
            return -1;
        }
        return 0;
    }
}

按id排序后的对象：[id=1 name=miss,id=1 name=小花,id=2 name=Jack,id=3 name=Natalie,id=3 name=小猪}

参考链接