Arrays.sort()与Collections.sort()的用法以及区别

标签：sort name Comparator Arrays age int Collections public

Arrays.sort()与Collections.sort()的区别

Arrays.sort 针对任意对象，排序的类型就为传入的对象类
如：Arrays.sort(a)//这里a为数组，可以是 int/String /类数组，排序类型依次为int ,String ，类

Collections.sort 针对集合（List）,排序类型为List对应的类型
如：Collections.sort (l)//这里l为List 对象，可以为List< Integer>/List< String>/List<类> ，排序类型依次为Integer,String ,类

对象数组的排序方式

要实现对对象数组的排序，要先实现Comparable或者Comparator接口。他们的区别如下：

Comparable 用作默认的比较方式

Comparator 用作自定义的比较方式，当默认的比较方式不适用时或者没有提供默认的比较方式，使用Comparator就非常有用。

sort(Object[]) 所有的对象都必须实现Comparable接口，它用来确定对象之间的大小关系
sort(Object[], Comparator) 对象不必实现Comparable接口，由Comparator来确定对象之间的大小关系

Arrays.sort()的方法

1. Arrays.sort(int[] a)

对数组的所有元素进行排序，从小到大排序

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

对数组部分排序，对数组a的下标从fromIndex到toIdex-1进行排序
注意：下标为toIndex的元素不参与排序

3.Arrays.sort(Integer[] a,Comparator cmp)

Arrays.sort()只能由小到大排序，那么如何由大到小排序呢？

最简单的方法是，使用定义好的方法Arrays.sort(Integer[] a, Collections.reverseOrder())，其中，Collections.reverseOrder()会返回一个Comparator，可以直接使用。

也可以自定义Comparator

import java.util.Arrays;
import java.util.Comparator;
 
public class Main{
 
//利用 Arrays.sort(Integer[] a,Comparator cmp) 进行由大到小排序
	public static void main(String[] args) {
		Integer[] a={4,9,1,3,5,8};//注意 Integer
		Comparator cmp=new MyComparator();
		Arrays.sort(a,cmp);
		for(int i=0;i<a.length;i++)
		{
			System.out.print(a[i]+" ");
		}
	}
	public static class MyComparator implements Comparator<Integer>
	{
		public int compare(Integer arg0, Integer arg1) {
			if(arg0<arg1)
				return 1;
			else if(arg0>arg1)
				return -1;
			else
				return 0;
		}
	}
}

Collections.sort()的方法

1.sort(List list)

功能：此方法根据元素的自然顺序对指定列表按升序进行排序。
要求：此方法要求集合元素有自己的排序规则，即要求元素必须实现了comparable接口，且重写了compareTo方法。也就是说对于集合中的任意两个元素e1，e2，e1.compareTo（e2）不能抛出异常。
参数：list集合的实例对象（ArrayList对象或者linledlist），不可以是set集合对象。
实例：自定义一个person类，包含name和age，要求根据age排序。

Person类

public class person implements Comparable<person> { //实现comparable接口
    private String name;
    private int age;

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

    public person() {
    }

    public String getName() {
        return name;
    }

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

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

    public int getAge() {
        return age;
    }

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

    @Override
    public int compareTo(person o) {  //重写compareTo方法
        return this.getAge()-o.getAge();  //  根据age进行升序排序，若反过来则是降序
    }
}

主函数

import java.util.ArrayList;
import java.util.Collections;

public class Demo01Stringcomp {
    public static void main(String[] args) {
        ArrayList<person> list1=new ArrayList<>();
        list1.add(new person("张三",25));
        list1.add(new person("李四",20));
        list1.add(new person("王五",20));
        Collections.sort(list1);
        System.out.println(list1);
    }

}

2.sort(List list, Comparator<? super T> c)

功能：根据指定比较器Comparator产生的排序规则对list集合对象进行排序；
参数：List list — list集合的实例对象（ArrayList对象或者linledlist）；
Comparator<? super T> c—Comparator接口产生的对象（可以使用匿名内部类）；
要求：不再要求集合元素具有自己的排序规则，即不再需要实现comparable接口；
实例：自定义一个student类，包含name和age属性，根据age排序；

Student类

public class students {
    private String name;
    private int age;

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

    public students() {
    }

    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 "students{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}