Arrays.sort()

Java的Arrays类中有一个sort()方法，该方法是Arrays类的静态方法，在需要对数组进行排序时，可以直接调用。

首先我们IDEA，可以查看到它的用法有很多，但其实可以大致分为几类。

注：数组类型是Object（），即sort（）的参数类型也为Object。以int型数组为例。

用法1：

Arrays.sort(int[] a)

它是对数组的所有元素进行升序排序，即将数组中的元素按照从小到大进行排序。

代码实现：

import java.util.*;
public class leetcode {
    public static void main(String[] args) {
        int[] arr = {5,2,0,7,1,3,1,4};
        Arrays.sort(arr);
        for (int item:arr) {
            System.out.print(item + " ");
        }
        System.out.println();
    }
}

运行结果：

用法2：

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

它是对数组部分元素进行升序排序，也就是对数组a的下标从fromIndex到toIndex-1的元素排序—[fromIndex,toIndex)

注意：下标为toIndex的元素不参与排序！

代码实现：

import java.util.*;
public class leetcode {
    public static void main(String[] args) {
        int[] arr = {5,2,0,7,1,3,1,4};
        Arrays.sort(arr,1,3);
        for (int item:arr) {
            System.out.print(item + " ");
        }
        System.out.println();
    }
}

运行结果：

上面的两种用法很容易发现一个问题，那就是数组没有办法进行降序排序，如果想进行降序排序该怎么办呢？

用法3：

public static void sort(T[] a, Comparator c)

注：根据指定的比较器引发的顺序对指定的对象数组进行排序

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

注：根据指定的比较器引发的顺序对指定的对象数组的指定范围进行排序

代码实现：

import java.util.Arrays;

class Person implements Comparable<Person>{
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Person o) {
        return this.age - o.age;
    }
}
public class leetcode {
    public static void main(String[] args) {
        Person[] peoples = new Person[]{
                new Person("张三",15),
                new Person("李四",30),
                new Person("王五",11),
                new Person("赵六",10)
        };
        System.out.println("排序前：");
        for(Person p : peoples){
            System.out.println(p);
        }
        System.out.println("排序后：");
        Arrays.sort(peoples);
        for(Person p : peoples){
            System.out.println(p);
        }
    }
}

运行结果：

 实战演练：leetcode179题

题目：

给定一组非负整数 nums，重新排列每个数的顺序（每个数不可拆分）使之组成一个最大的整数。

注意：输出结果可能非常大，所以你需要返回一个字符串而不是整数。

解法：（关键代码）

class Solution {
    public String largestNumber(int[] nums) {
        //解法一
        String[] str=new String[nums.length];
        for(int i=0;i<nums.length;i++){
            str[i]=String.valueOf(nums[i]);
        }
        Arrays.sort(str,(o1,o2)->(o2+o1).compareTo(o1+o2));
        StringBuilder sb=new StringBuilder();
        for(String s:str){
            sb.append(s);           
        }
        return sb.toString().charAt(0)=='0'?"0":sb.toString();
        
        //解法二
        // PriorityQueue<String> p=new PriorityQueue<>((x,y)->(y+x).compareTo(x+y));
        // for(int i:nums){
        //     p.offer(String.valueOf(i));
        // }
        // String res="";
        // while(p.size()>0){
        //     res+=p.poll();
        // }
        // return res.charAt(0)=='0'?"0":res;

    }
}

更多用法：

lambda表达式详解：

https://www.cnblogs.com/knowledgesea/p/3163725.html

Arrays.sort()的深入理解：

Arrays.sort() ----- DualPivotQuicksort：https://www.cnblogs.com/wuweishuo/p/10648039.html

Arrays.sort() ----- TimSort：https://www.cnblogs.com/wuweishuo/p/10646045.html