java中排序函数sort（）使⽤，Arrays.sort（）和
Collections.s。。。
Java中常⽤的数组或集合排序的⽅法有两个，⼀个是java.util.Arrays中的静态⽅法Arrays.sort（），还有⼀个是java.util.Collections中的静态⽅法的Collections.sort()⽅法，下⾯分别介绍两种⽤法。
⼀.java.util.Arrays中的静态⽅法
Arrays中的sort()⽅法主要是针对各种数据类型（基本数据类型和引⽤对象类型）的数组元素排序。
.......
关于引⽤对象类型数组的排序sort()⽅法要⽤到接⼝Comparator<T>，对其排序内部的⽐较函数compare()进⾏重写，以便于我们按照我们的排序要求对引⽤对象数组极性排序，默认是升序排序，但可以⾃⼰⾃定义成降序排序。关于Comparator<T>的介绍见
sort
public static <T> void sort(T[] a,
<? super T> c)
根据指定⽐较器产⽣的顺序对指定对象数组进⾏排序。数组中的所有元素都必须是通过指定⽐较器可相互⽐较的（也就是说，对于数组中的任何e1和e2元素⽽⾔，cpare(e1, e2)不得抛出ClassCastException）。
保证此排序是稳定的：不会因调⽤ sort ⽅法⽽对相等的元素进⾏重新排序。
该排序算法是⼀个经过修改的合并排序算法（其中，如果低⼦列表中的最⾼元素⼩于⾼⼦列表中的最低元素，则忽略合并）。此算法提供可保证的 n*log(n) 性能。
参数：
a - 要排序的数组
c - 确定数组顺序的⽐较器。null值指⽰应该使⽤元素的。
抛出：
- 如果数组包含使⽤指定的⽐较器不可相互⽐较的的元素。
sort
public static <T> void sort(T[] a,
int fromIndex,
int toIndex,
<? super T> c)
根据指定⽐较器产⽣的顺序对指定对象数组的指定范围进⾏排序。排序的范围从索引fromIndex（包括）⼀直到索引toIndex（不包括）。（如果fromIndex==toIndex，则排序范围为空。）此范围内的所有元素都必须是通过指定⽐较器可相互⽐较的（也就是说，对于该范围中的任何e1和e2元素⽽⾔，cpare(e1, e2)不得抛出ClassCastException）。
保证此排序是稳定的：不会因调⽤ sort ⽅法⽽对相等的元素进⾏重新排序。
该排序算法是⼀个经过修改的合并排序算法（其中，如果低⼦列表中的最⾼元素⼩于⾼⼦列表中的最低元素，则忽略合并）。此算法提供可保证的 n*log(n) 性能。
参数：
a - 要排序的数组
fromIndex - 要排序的第⼀个元素的索引（包括）
toIndex - 要排序的最后⼀个元素的索引（不包括）
c - 确定数组顺序的⽐较器。null值指⽰应该使⽤元素的。
抛出：
- 如果数组包含使⽤指定的⽐较器不可相互⽐较的的元素。
- 如果fromIndex > toIndex
- 如果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()&Age())
return 1;
else if (p1.getAge()&Age())
return -1;
else
return 0;
}
};
//成绩⽐较器
Comparator<student> comparatorGrade =new Comparator <student>(){
public int compare(student p1,student p2){
if (p1.getGrade()&Grade())
return 1;
else if (p1.getGrade()&Grade())
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) {
}
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。
*/
java arraylist用法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 s1pareTo(s2);//变成-s1pareTo(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
　最后，上⾯的两个实例只要改变相应的待排序数据的形式（数组，集合），都可以替换使⽤。

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。