分别比较在int[]数组、Integer[]数组、String数组、list集合中使用Java中常用的排序工具类:
public class TestComparator {
/**
* 测试不同情况下的比较器使用
*/
public static void main(String[] args) {
//测试comparator的使用
System.out.println("对int[]数组进行排列: ");
int[] n1 = {1,4,5,2,3};
Arrays.sort(n1);
//n1的升序排列
System.out.println("对int[]数组升序排列: " + Arrays.toString(n1));
//Arrays工具包中默认没有对基本类型int数组的降序排列,所以只能自己实现对int类型数组降序排列
//主要的实现思路就是对升序排列过后的数组翻个头
int j = n1.length - 1;
for (int i = 0; i < n1.length / 2; i++) {
int temp = n1[j];
n1[j] = n1[i];
n1[i] = temp;
j--;
}
System.out.println("对int[]数组降序排列: " + Arrays.toString(n1));
System.out.println("对Integer[]数组进行排列: ");
Integer[] n2 = {1,4,5,2,3};
Arrays.sort(n2, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
//升序排列
return o1 - o2;
}
});
//上边的写法等同于:
Arrays.sort(n2);
//也等同于
Arrays.sort(n2,(o1,o2) -> o1 - o2);
System.out.println("对Integer[]数组进行升序排列: " + Arrays.toString(n2));
Arrays.sort(n2, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2 - o1;
}
});
//上边的写法等同于:
Arrays.sort(n2,Comparator.reverseOrder());
System.out.println("对Integer[]数组进行降序排列: " + Arrays.toString(n2));
//对list集合中的数字排序
System.out.println("对list集合中的数字排序");
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(4);
list.add(5);
list.add(2);
list.add(3);
Collections.sort(list);
System.out.println("对list集合进行升序排列: " + list);
Collections.sort(list,Collections.reverseOrder());
System.out.println("对list集合进行降序排列: " + list);
//对于字符串的按照字典序排序
System.out.println("对字符串的list集合排序");
List<String> strList = new ArrayList<>();
strList.add("cap");
strList.add("to");
strList.add("cat");
strList.add("card");
strList.add("two");
strList.add("too");
strList.add("up");
strList.add("boat");
strList.add("boot");
System.out.println("字符串集合排序前的样子:" + strList);
Collections.sort(strList, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
char[] chars1=o1.toCharArray();
char[] chars2=o2.toCharArray();
int i=0;
while(i<chars1.length && i<chars2.length){
if(chars1[i]>chars2[i]){
return 1;
}else if(chars1[i]<chars2[i]){
return -1;
}else{
i++;
}
}
if(i==chars1.length){ //o1到头
return -1;
}
if(i== chars2.length){ //o2到头
return 1;
}
return 0;
}
});
System.out.println("字符串集合按照字典序排序后的样子(自定义):" + strList);
//直接使用sort的排序和上边的效果是一样的
Collections.sort(strList);
System.out.println("字符串集合按照字典序排序后的样子(Collections):" + strList);
//反字典序排序
Collections.sort(strList,Collections.reverseOrder());
System.out.println("字符串集合按照字典序反排序后的样子(Collections):" + strList);
//二维数组的排序
System.out.println("二维数组的排序");
int[][] arr = {{1,3},{2,6},{15,18},{8,10}};
String str1 = "";
for (int[] num : arr) {
str1 += Arrays.toString(num) + " , ";
}
System.out.println("没有排序之前的数组样子:" + str1);
//按照数组的第一个数字大小从小到大排列
Arrays.sort(arr,((o1, o2) -> o1[0] - o2[0]));
str1 = "";
for (int[] num : arr) {
str1 += Arrays.toString(num) + " , ";
}
System.out.println("按照数组的首位数字大小排序:" + str1);
}
//寻找不同的数字组合下,能组合出的最大数字
public String largestNumber(int[] nums) {
String[] strs = new String[nums.length];
for (int i = 0; i < nums.length; i++) {
strs[i] = String.valueOf(nums[i]);
}
//对数组按照指定的规则排序
Arrays.sort(strs,new LargestStringComparator());
String res = "";
//假如字符串数组中的第一个字符串都为“0”,那么全部的字符串肯定都为0,直接返回0即可
if ("0".equals(strs[0])) {
return "0";
}
//将字符串数组转换成字符串
for (String str : strs) {
res += str;
}
return res;
}
//寻找不同数字组合的情况下,整个数组能组合出来的最大数字
static class LargestStringComparator implements Comparator<String> {
@Override
public int compare(String s1, String s2) {
String order1 = s1 + s2;
String order2 = s2 + s1;
return order2.compareTo(order1);
}
}
//字典的比较器1
//长度较长的集合排在后边,短的排在前边,如果两个集合的长度相等,那么集合里边的元素大的排列在后边
static class SizeComparator implements Comparator<List<Integer>> {
@Override
public int compare(List<Integer> l1, List<Integer> l2) {
if (l1.size() > l2.size()) {
return 1;
} else {
if (l1.size() == l2.size()) {
for (int i = 0; i < l1.size(); i++) {
if (!l1.get(i).equals(l2.get(i))) {
return l1.get(i) > l2.get(i) ? 1 : -1;
}
}
}
return -1;
}
}
}
}
输出:
对int[]数组进行排列:
对int[]数组升序排列: [1, 2, 3, 4, 5]
对int[]数组降序排列: [5, 4, 3, 2, 1]
对Integer[]数组进行排列:
对Integer[]数组进行升序排列: [1, 2, 3, 4, 5]
对Integer[]数组进行降序排列: [5, 4, 3, 2, 1]
对list集合中的数字排序
对list集合进行升序排列: [1, 2, 3, 4, 5]
对list集合进行降序排列: [5, 4, 3, 2, 1]
对字符串的list集合排序
字符串集合排序前的样子:[cap, to, cat, card, two, too, up, boat, boot]
字符串集合按照字典序排序后的样子(自定义):[boat, boot, cap, card, cat, to, too, two, up]
字符串集合按照字典序排序后的样子(Collections):[boat, boot, cap, card, cat, to, too, two, up]
字符串集合按照字典序反排序后的样子(Collections):[up, two, too, to, cat, card, cap, boot, boat]
二维数组的排序
没有排序之前的数组样子:[1, 3] , [2, 6] , [15, 18] , [8, 10] ,
按照数组的首位数字大小排序:[1, 3] , [2, 6] , [8, 10] , [15, 18] ,