int[] testNums = {1,3,6,5,4,1,2,8};
Arrays.sort(testNums);
System.out.println(Arrays.toString(testNums));
//输出：[1, 1, 2, 3, 4, 5, 6, 8]
int[] testNums2 = {1,3,6,5,4,1,2,8};
Arrays.sort(testNums2,1,6);
System.out.println(Arrays.toString(testNums2));
//输出：[1, 1, 3, 4, 5, 6, 2, 8]
int[][] testNums3 = {{1,2},{3,4},{1,3},{2,4}};
Arrays.sort(testNums3, new Comparator<int[]>() {
@Override
public int compare(int[] o1, int[] o2) {
return (o1[0]+o1[1])-(o2[0]+o2[1]);
}
});
for (int[] nums:testNums3){
System.out.println(Arrays.toString(nums));
}
/*
输出：
[1, 2]
[1, 3]
[2, 4]
[3, 4]
*/
4.使用lambda表达式自定义排序规则（重要!）
在3中，对应的接口函数可以用lambda表达式简写如下：
Arrays.sort(testNums3,(o1, o2) -> {
return (o1[0]+o1[1])-(o2[0]+o2[1]);
}
});
注意，要想改变默认的排列顺序，不能使用基本类型（int,double, char） ，而要使用它们对应的包装类。
分析：先考虑两个数的情况，假设有两个数num1，num2，则答案要么是num1+num2，要么是num2+num1（注意这里的+表示拼接操作：1+2 = 12）
定义num1>num2：num1+num2>num2+num1，举例说明：因为"3"+“31”=“331”>“31”+“3”=“313”，所以"3">“31”。
不难看出，当整个数组都按照我们定义的大小关系降序排序，最后依次拼接即为结果。比如：“31”>“30”>“2”，"31302"为所求最大数。代码如下：
public class Solution179 {
/*
给定一组非负整数 nums，重新排列每个数的顺序（每个数不可拆分）使之组成一个最大的整数。
注意：输出结果可能非常大，所以你需要返回一个字符串而不是整数。
输入：nums = [3,30,34,5,9]
输出："9534330"
链接：https://leetcode-cn.com/problems/largest-number/
*/
public static void main(String[] args) {
int[] nums = {0,20,2190,5,38,21,1};
System.out.println(Solution.largestNumber(nums));
}
static class Solution {
public static String largestNumber(int[] nums) {
String ans = "";
String[] temp = new String[nums.length];
for (int i = 0; i < nums.length; i++) {
temp[i] = Integer.toString(nums[i]);
}
Arrays.sort(temp, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
String o12 = o1+o2,o21 = o2+o1;
for (int i = 0; i < o12.length(); i++) {//逐个比较对应字符的大小
//返回负数，顺序为(o1，o2)
if(o12.charAt(i)>o21.charAt(i)) return -1;
//返回正数，顺序为(o2,o1)
else if(o12.charAt(i)<o21.charAt(i)) return 1;
//无论是那种顺序，字符大的都在前面，因此是按降序排列
}
//若直到最后一个字符都相等，按照最后一个字符的大小来决定
return o12.charAt(o12.length()-1)<o21.charAt(o21.length()-1)?1:-1;
}
});
for (String s :
temp) {
ans += s;
}
return ans;
}
}
}
分析：首先对intervals进行排序，排序规则为第一列按升序，第一列相等时第二列按降序，例如：[1,2]>[0,3]，[2,2]>[2,3]（思考为什么要这样排序）。
然后再遍历intervals进行合并。
/*
以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。
请你合并所有重叠的区间，并返回一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间。
[[1,3],[1,2],[2,6],[8,10],[15,18]]
输入：intervals = [[1,3],[2,6],[8,10],[15,18]]
输出：[[1,6],[8,10],[15,18]]
解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].
链接：https://leetcode-cn.com/problems/merge-intervals
*/
public class Solution56 {
public static void main(String[] args) {
int[][] intervals = {{1,3},{1,2},{2,6},{8,10},{15,18},{19,20}};
// int[][] intervals = {{1,4},{0,4}};
System.out.println(Arrays.deepToString(Solution.merge(intervals)));
}
private static class Solution {
public static int[][] merge(int[][] intervals) {
//1.第一维升序，第二维降序进行排序
//2.遍历数组，记录当前区间的端点；
// 若下一个区间的左端点相同，直接跳过；若大于前一个的右端点，记录前一个区间，更新区间的左右端点；若小于前一个的右端点，则存在重合区域，更新区间端点
int[][] ans = new int[10005][2];
Arrays.sort(intervals, new Comparator<int[]>() {
@Override
public int compare(int[] o1, int[] o2) {
if(o1[0]!=o2[0]) return o1[0]-o2[0];
else return o2[1]-o1[1];
}
});
int L = 0,R = 0;//左右端点
int nums = 0;//合并后的区间个数
for (int i = 0; i < intervals.length; i++) {
if(i==0){
L = intervals[0][0];R = intervals[0][1];continue;
}
if(intervals[i][0]==L) continue;//左区间端点相等直接跳过
else if (intervals[i][0]>L){ //左区间端点大于前一个的左区间端点
if(intervals[i][0]>R){ //仍然大于右区间端点，记录
ans[nums][0] = L;ans[nums][1] = R;L = intervals[i][0];R = intervals[i][1];nums++;
}
else {//若小于等于右区间端点，比较它的右端点和原右端点的值，更新R
R = Math.max(intervals[i][1],R);
}
}
}
//存在结束循环但是最后一个区间还没有加入ans的情况
//最后一个区间也是首个区间
if(nums==0) {ans[nums][0]=L;ans[nums][1]=R;}
//最后一个区间不是首个区间的话只需要判断左端点是否相等，不相等说明还没有记录
if(nums!=0 && ans[nums][0]!=L) {ans[nums][0]=L;ans[nums][1]=R;}
return Arrays.copyOfRange(ans,0,nums+1);
}
}
}
在理解各类排序算法的情况下，熟练使用Arrays.sort()方法解决问题，尤其掌握Comparator接口或lambda表达式的写法！