Java中自定义对象排序方法

在写leetcode题目的时候，经常会想按照自己想的方式对数组或者说是字符串进行排序，就学习了这个方法，这篇文章主要是用来记录 java中自定义对象数组排序Arrays.sort()方法以及Collections.sort()中的Comparator接口用法

Arrays.sort()

Arrays.sort()用于对象数组的排序
Arrays.sort(int[] a , int start , int end)
这是对普通基本类型数组的排序方式，a：数组名称，start：起始位置的下表（能取得到），end：结束位置的下标（取不到）start和end默认是整个数组的长度

例如最基本的排序

int[] arr = new int[]{2,4,1,3,5};
Arrays.sort(arr,0,arr.length);
// Arrays.sort(arr);
for(int a:arr) System.out.print(a+" ");
// 就会输出1 2 3 4 5

最基本数组排序之倒序排序

int[] arr = new int[]{2,1,3};
Arrays.sort(arr,new Comparator<int>(){
      @Override
      public itn compare(int i , int j){
            return j-i;
      }
});
// lambda表达式表述
Arrays.sort(arr , (o1,o2) -> (o2-o1));

观察上述的倒序排序已经用到了Compartor比较器接口。
如果想对自己的自定义的类型进行排序的话，就需要重新定义比较器，Arrays.sort()主要有两个重载方法供使用，也就是Compareable和Compartor比较器接口，通过实现相应的类，重写接口方法以便于对自定义对象进行比较排序。

Arrays.sort()的两个重载方法

• sort(Object[] a)
• sort(T[] a,Comparator<? super T> c)

其中，第一个方法sort(Object[] a)，需要丝线Compareable，然后重写该接口下的compareTo方法，通常用于类的排序中，之后用到再讲述，本篇主要是针对于Compartor展开论述的。

对一个二维数组按照第一列进行排序（注意：二维数组中的每一个一位数组相当于一个对象）

int[][] arr = new int[][]{{2,1},{1,3},{3,2}};
Arrays.sort(arr , new Comparator<int[]>(){
      @Override
      public int compare(int[] arr1 , int[] arr2 ){
            return arr1[0] - arr2[0];
      }
});
// 用lambda
Arrays.sort( arr , (o1,o2) -> (o1[0] - o2[0]));

Collections.sort()

Collections.sort用于集合的排序，

对一维list进行排序

List<Integer> list = new ArrayList<Integer>();
list.add(2);
list.add(1);
list.add(3);
Collections.sort(list , new Comparator<Integer>(){
      @Override
      public int compare(Integer l1 , Integer l2){
            return l1 - l2;
      }
});
// 用lambda
// Collections.sort(list ,(o1,o2) -> (o1-o2));
System.out.println(list);

对二维list按照第一维进行排序

import java.util.*;
class Solution{
	public static void main(String[] args) {
		List<List<Integer>> list = new ArrayList<List<Integer>>();
		List<Integer> l1 = new ArrayList<Integer>();
		l1.add(2);
		l1.add(1);
		List<Integer> l2 = new ArrayList<Integer>();
		l2.add(1);
		l2.add(3);
		List<Integer> l3 = new ArrayList<Integer>();
		l3.add(3);
		l3.add(2);
		list.add(l1);
		list.add(l2);
		list.add(l3);
		System.out.println(list);
		Collections.sort(list,new Comparator<List<Integer>>(){
			@Override
			public int compare(List<Integer> o1,List<Integer> o2){
				return o1.get(0) - o2.get(0);
			}
		});
		System.out.println(list);
		// lambda
		Collections.sort(list,(o1,o2)->(o1.get(0) - o2.get(0)));
		System.out.println(list);

	}	
}

String 中的compareTo

String 中的compareTo方法，按照字典序比较两个字符串
有一个字符串二维list，按照每一维的第一个字符串的字典序进行排序，如果第一个zifuc完全相同再去比较第二个字符串的字典序

import java.util.*;
class Solution{
	public static void main(String[] args) {
		List<List<String>> list = new ArrayList<List<String>>();
		List<String> l1 = new ArrayList<String>();
		l1.add("hml");
		l1.add("tj");
		List<String> l2 = new ArrayList<String>();
		l2.add("ccc");
		l2.add("yzc");
		List<String> l3 = new ArrayList<String>();
		l3.add("ccc");
		l3.add("cxy");
		list.add(l1);
		list.add(l2);
		list.add(l3);
		System.out.println(list);
		Collections.sort(list,new Comparator<List<String>>(){
			@Override
			public int compare(List<String> o1,List<String> o2){
				return o1.get(0).compareTo(o2.get(0));
			}
		});
		System.out.println(list);
		// lambda
		Collections.sort(list,(o1,o2)->(o1.get(0).compareTo(o2.get(0))));
		System.out.println(list);

	}	
}
/**
输出的结果
input ： [[hml, tj], [ccc, yzc], [ccc, cxy]]
output ：[[ccc, yzc], [ccc, cxy], [hml, tj]]
lambda output ：[[ccc, yzc], [ccc, cxy], [hml, tj]]
*/