java中排序函数sort()使用，Arrays.sort（）和Collections.sort()

Java中常用的数组或集合排序的方法有两个，一个是java.util.Arrays中的静态方法Arrays.sort（），还有一个是java.util.Collections中的静态方法的Collections.sort()方法，下面分别介绍两种用法。

一.java.util.Arrays中的静态方法Arrays.sort（）

Arrays中的sort()方法主要是针对各种数据类型（基本数据类型和引用对象类型）的数组元素排序。

.......

关于引用对象类型数组的排序sort()方法要用到接口Comparator<T>，对其排序内部的比较函数compare()进行重写，以便于我们按照我们的排序要求对引用对象数组极性排序，默认是升序排序，但可以自己自定义成降序排序。关于Comparator<T>的介绍见官方文档

sort

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

根据指定比较器产生的顺序对指定对象数组进行排序。数组中的所有元素都必须是通过指定比较器 可相互比较的（也就是说，对于数组中的任何 e1 和 e2 元素而言， c.compare(e1, e2) 不得抛出 ClassCastException）。

保证此排序是稳定的：不会因调用 sort 方法而对相等的元素进行重新排序。

该排序算法是一个经过修改的合并排序算法（其中，如果低子列表中的最高元素小于高子列表中的最低元素，则忽略合并）。此算法提供可保证的 n*log(n) 性能。

参数：

a - 要排序的数组

c - 确定数组顺序的比较器。 null 值指示应该使用元素的 自然顺序。

抛出：

ClassCastException - 如果数组包含使用指定的比较器不 可相互比较的 的元素。

---

sort

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

根据指定比较器产生的顺序对指定对象数组的指定范围进行排序。排序的范围从索引 fromIndex（包括）一直到索引 toIndex（不包括）。（如果 fromIndex==toIndex，则排序范围为空。）此范围内的所有元素都必须是通过指定比较器 可相互比较的（也就是说，对于该范围中的任何 e1 和 e2 元素而言， c.compare(e1, e2) 不得抛出 ClassCastException）。

保证此排序是稳定的：不会因调用 sort 方法而对相等的元素进行重新排序。

该排序算法是一个经过修改的合并排序算法（其中，如果低子列表中的最高元素小于高子列表中的最低元素，则忽略合并）。此算法提供可保证的 n*log(n) 性能。

参数：

a - 要排序的数组

fromIndex - 要排序的第一个元素的索引（包括）

toIndex - 要排序的最后一个元素的索引（不包括）

c - 确定数组顺序的比较器。 null 值指示应该使用元素的 自然顺序。

抛出：

ClassCastException - 如果数组包含使用指定的比较器不 可相互比较的 的元素。

IllegalArgumentException - 如果 fromIndex > toIndex

ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length

下面上实例：

package test;
import java.util.Arrays;
import java.util.Comparator;
//用Arrays中的sort()对数组进行排序
public class test4 {
	//年龄比较器
	Comparator<student> comparatorAge =new Comparator <student>(){
		public int compare(student p1,student p2){
			if (p1.getAge()>p2.getAge())
				return 1;
			else if (p1.getAge()<p2.getAge())
				return -1;
			else
				return 0;
		}
	};

	//成绩比较器
	Comparator<student> comparatorGrade =new Comparator <student>(){
		public int compare(student p1,student p2){
			if (p1.getGrade()>p2.getGrade())
				return 1;
			else if (p1.getGrade()<p2.getGrade())
				return -1;
			else
				return 0;
		}
	};

	public student [] ageSort(student[] s){
		Arrays.sort(s,comparatorAge);
		return s;
	}

	public student [] gradeSort(student[] s){
		Arrays.sort(s,comparatorGrade);
		return s;
	}

	public static void main(String[] args) {
		 test4 tt=new test4();
		 student p1 = new student() ;
		         p1.setAge( 10 );
		         p1.setName( "p1" );
		         p1.setGrade( 98 );

		         student p2 = new student() ;
		         p2.setAge( 30 );
		         p2.setName( "p2" );
		         p2.setGrade( 70 );

		         student p3 = new student() ;
		         p3.setAge( 20 );
		         p3.setName( "p3" );
		         p3.setGrade( 83 );

		         student p4 = new student() ;
		         p4.setAge( 15 );
		         p4.setName( "p4" );
		         p4.setGrade( 80 );

		student [] list = {p1,p2,p3,p4} ;		 

		student []agePrint=  tt.ageSort(list);
		for (student ss : agePrint) {
			 System.out.println("student age sort ," + ss.getName() + "  " + ss.getAge() +" " +ss.getGrade());
		 }//按年龄排序

		student []gradePrint=  tt.gradeSort(list);
		for (student ss : gradePrint) {
			 System.out.println("student grade sort ," + ss.getName() + "  " + ss.getAge() +" " +ss.getGrade());
		 }//按成绩排序

	}

}

//创建一个类型，用于比较的引用对象类型
class student{
	private String name;
	private int age;
	private float grade;

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

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

    public void setGrade(float grade) {
        this.grade = grade;
    }

    public String getName() {
        return name;
    }

	public int getAge() {
        return age;
    }

    public float getGrade() {
        return grade;
    }
 }

结果如下：

student age sort ,p1  10 98.0
student age sort ,p4  15 80.0
student age sort ,p3  20 83.0
student age sort ,p2  30 70.0
student grade sort ,p2  30 70.0
student grade sort ,p4  15 80.0
student grade sort ,p3  20 83.0
student grade sort ,p1  10 98.0

　　

二.　java.util.Collections中的静态方法的Collections.sort()

　　java.util.Collections中的静态方法的Collection.sort()主要是针对集合框架中的动态数组，链表，树，哈希表等（ ArrayList、LinkedList、HashSet、LinkedHashSet、HashMap、LinkedHashMap ）进行排序。

关于Comporator 的介绍和上面相同，主要是针对里面compare()的重写

下面上实例：

package test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
//用Collections的sort()方法对集合进行排序。
/*
 * 题目：
 * 输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。
 * 例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。
 */

public class test3 {

    public String PrintMinNumber(Integer [] s) {
        if(s==null) return null;
        String s1="";
        ArrayList<Integer> list=new ArrayList<Integer>(Arrays.asList(s));
//        for(int i=0;i<s.length;i++){
//             list.add(s[i]);
//        }
        Collections.sort(list,new Comparator<Integer>(){//数组里的数两两组合比较，按照比较值更得的顺序升序排序
            public int compare(Integer str1,Integer str2){
                String s1=str1+""+str2;
                String s2=str2+""+str1;
                return s1.compareTo(s2);//变成-s1.compareTo(s2)就是降序排序了
            }
        });
         for(int j:list){
        	 System.out.println("输出为:"+j);
                s1+=j;
             }
        return s1;
    }

	public static void main(String[] args) {

		Integer [] list={3,32,321};
		test3 demo=new test3();
		 System.out.println(demo.PrintMinNumber(list));
	}

}

　结果如下：

输出为:321
输出为:32
输出为:3
321323

　最后，上面的两个实例只要改变相应的待排序数据的形式（数组，集合），都可以替换使用。