Java关于Arrays、Collections和List的排序方法

概述

常见的排序方法根据不同的需要，可用静态类Arrays、静态类Collections、接口List中的sort方法，主要的区别在于Arrays只能对数组排序，而Collections和List接口中的sort方法可对ArrayList、LinkedList进行排序

详细内容

1. Arrays静态类中的sort方法

此方法用于对数组进行排序，数组元素类型可以是基本数据，如int、floar、double，也可以是一个类如String或自定义的类，参数fromIndex和toIndex指定排序范围

static void sort(int[] a)

基本数据类型的排序

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

指定范围进行排序

static <T> void sort(T[] a, Comparator<? super T> c)

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

static <T> void sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c)

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

static void sort(Object[] a)

对指定数组对象按默认大小排序

static void sort(Object[] a, int fromIndex, int toIndex)
对指定数组对象按默认大小在指定范围内排序

在Java8中新增以parallel开头的parallelSort方法，该方法与sortf方法功能相同，在底层上充分利用了CPU并行处理能力提高了排序算法的性能

		String []arr = {"abg","hij","abb","xyz","ABC"};
//		正序
		Arrays.parallelSort(arr);
//		Arrays.sort(arr);		
		for(String ss:arr) {
			System.out.print(ss+" ");
		}
		System.out.println();
//		ABC abb abg hij xyz 
		
//		逆序，如果是基本数据类型，不能使用Collections.reverseOrder()
		Arrays.sort(arr,Collections.reverseOrder());
		for(String ss:arr) {
			System.out.print(ss+" ");
		}
		System.out.println();
//		xyz hij abg abb ABC 

2. Collections静态类的sort方法

• ** static <T extends Comparable<? super T>> void sort(List<T> list)**

  根据其元素的natural ordering对指定的列表进行排序

• static <T> void sort(List<T> list, Comparator<? super T> c)

  根据指定的比较器引起的顺序对指定的列表进行排序

• 对于Integer、String、Double等已经实现了Comparable接口的类的对象，不指定比较规则时使用默认的排序方式，例如：

		List<Integer> p = Arrays.asList(20,1,3,29,-1,8,30,21,899,400,2);
//		默认规则从小到大
		Collections.sort(p);
		p.forEach(o->System.out.print(o+" "));
//		-1 1 2 3 8 20 21 29 30 400 899 

3. List接口中的sort方法

• void sort(Comparator<? super E> c)

  使用Comparator比较器对此列表中的元素进行排序

  LinkedList、ArrayList方法均实现了List接口，要进行排序就要实现Comparator接口，可以通过匿名内部类或lambda表达式实现该接口，例如：

		List<Integer> p = Arrays.asList(20,1,3,29,-1,8,30,21,899,400,2);
//		lambda实现Comparator<Integer>()		
		p.sort((o1,o2)->{return o2-o1;});
		p.forEach(o->System.out.print(o+" "));
		System.out.println();
//		899 400 30 29 21 20 8 3 2 1 -1 

4. List与Collections中sort使用案例

4.1 实现Comparator接口中compare方法排序

int compare(T o1, T o2)

比较其两个参数的顺序，返回负整数，零或正整数

排序规则：对于A与B，在方法中直接返回A-B，会进行从小到大排序；返回B-A，会进行从大到小排序；其中A-B返回值等于0，则A、B的先后顺序由遍历的自然顺序决定

方式1：创建单独的一个类实现Comparator接口中的compare方法

package arrlist;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;

//创建学生类
public class Student1 {
	public int id;
	public String name;
	public int grade;
	public Student1(int number,String name,int grade) {
		this.id=number;
		this.name=name;
		this.grade=grade;
	}

	public static void main(String[] args) {
		ArrayList<Student1> list = new ArrayList<Student1>();
		list.add(new Student1(1008, "李明", 94));
		list.add(new Student1(1002, "张亮", 96));
		list.add(new Student1(1003, "陈晨", 90));
		list.add(new Student1(1004, "刘敏", 100));
		list.add(new Student1(1001, "李明", 94));
		Collections.sort(list,new CompEmp1());
        //或使用以下方法
        //list.sort(new CompEmp1());
		Iterator<Student1> l = list.iterator();
		while(l.hasNext()) {
			Student1 p = l.next();
			System.out.println(p.id+" "+p.name+" "+p.grade);
		}
	}
}
class CompEmp1 implements Comparator<Object>{

	@Override
	public int compare(Object o1, Object o2) {
		// TODO Auto-generated method stub
		Student1 p1 = (Student1) o1;
		Student1 p2 = (Student1) o2;
		return p1.grade-p2.grade;
	}
}
/*
1003 陈晨 90
1008 李明 94
1001 李明 94
1002 张亮 96
1004 刘敏 100
*/

方式2：使用lambda表达式的排序

	Collections.sort(list,(o1,o2)->{return o1.grade-o2.grade;});
	//或使用以下方法
	//list.sort((o1,o2)->{return o1.grade-o2.grade;});

方式3：使用匿名内部类实现Comparator接口的排序

	Collections.sort(list,new Comparator<Student1>(){
		@Override
		public int compare(Student1 o1, Student1 o2) {
			// TODO Auto-generated method stub
			return o1.grade-o2.grade;
		}
	}
	);

4.2 通过排序的对象实现Comparable接口，覆盖compareTo方法进行排序

int compareTo(T o)

Comparable接口中只有这一个方法，此方法将此对象与指定的对象进行比较以进行排序， 返回一个负整数，零或正整数，排序规则与Comparator接口中的compare方法一样

package arrlist;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;

//创建学生类
public class Student2 implements Comparable<Object>{
	public int id;
	public String name;
	public int grade;
	public Student2(int number,String name,int grade) {
		this.id=number;
		this.name=name;
		this.grade=grade;
	}
	@Override
	public int compareTo(Object o) {
		// TODO Auto-generated method stub
		Student2 p = (Student2) o;
        // 成绩相等，按id从小到大
		if(this.grade==p.grade) {
			return this.id-p.id;
		}
        // 按成绩从小到大
		return this.grade-p.grade;
	}
	public static void main(String[] args) {
		ArrayList<Student2> list = new ArrayList<Student2>();
		list.add(new Student2(1008, "李明", 94));
		list.add(new Student2(1002, "张亮", 96));
		list.add(new Student2(1003, "陈晨", 90));
		list.add(new Student2(1004, "刘敏", 100));
		list.add(new Student2(1001, "李明", 94));
		Collections.sort(list);
		list.forEach((p)->{
			System.out.println(p.id+" "+p.name+" "+p.grade);
		});
	}
}
/*
1003 陈晨 90
1001 李明 94
1008 李明 94
1002 张亮 96
1004 刘敏 100
*/