版权声明：限于博主能力有限，不排除出现错误的地方，希望大佬指出，多多 交流，共同进步。 https://blog.csdn.net/SunPeishuai/article/details/84258237
1. Array.sort(int[]a)
java中的Array类中有一个sort（）方法，给方法为Arrays类的静态方法，下面介绍几种sort（）参数的用法。
对一个数组排序：从小到大的顺序排列
(当然不知局限于整型数组)
import java.util.Arrays;
import java.util.Scanner;
public class Main{
public static void main(String[]args) {
Scanner sc=new Scanner(System.in);
int arr[]= {1,6,8,7,9};
Arrays.sort(arr);
for(int i:arr) {
System.out.println(i+" ");
}
}
}
2.Array.sort(int[]a,int fromIndex,int toIndex)
这种形式是对数组的部分排序，也就是数组a从fromIndex到toIndex-1的元素进行排序。即【）左开右闭区间。也是升序排列。
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
Arrays.sort(a, 0, 3);
for(int i = 0; i < a.length; i ++) {
System.out.print(a[i] + " ");
}
}
}
/*运行结果如下：
7 8 9 2 3 4 1 0 6 5
上例只是把 9 8 7排列成了7 8 9
*/3. public static <T> void sort(T[] a,int fromIndex,int toIndex, Comparator<? super T> c)
上面有一个拘束，就是排列顺序只能是从小到大，如果我们要从大到小，就要使用这种方式
这里牵扯到了Java里面的泛型，如果读者不是很了解，可以暂时不去管它。
读者只需要读懂下面的例子就可以了，其实就是多了一个Comparator类型的参数而已。
扫描二维码关注公众号，回复：
4866698 查看本文章
补充：
package test;
import java.util.Arrays;
import java.util.Comparator;
public class Main {
public static void main(String[] args) {
//注意，要想改变默认的排列顺序，不能使用基本类型（int,double, char）
//而要使用它们对应的类
Integer[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
//定义一个自定义类MyComparator的对象
Comparator cmp = new MyComparator();
Arrays.sort(a, cmp);
for(int i = 0; i < a.length; i ++) {
System.out.print(a[i] + " ");
}
}
}
//Comparator是一个接口，所以这里我们自己定义的类MyComparator要implents该接口
//而不是extends Comparator
class MyComparator implements Comparator<Integer>{
@Override
public int compare(Integer o1, Integer o2) {
//如果n1小于n2，我们就返回正值，如果n1大于n2我们就返回负值，
//这样颠倒一下，就可以实现反向排序了
if(o1 < o2) {
return 1;
}else if(o1 > o2) {
return -1;
}else {
return 0;
}
}
}
/*
运行结果如下：
9 8 7 6 5 4 3 2 1 0
*/4.这是第二次写这篇总结，为了和一个猪聊天，QQ打不开了就重启了下电脑，然后一下午的博客总结就没了，冷静冷静。反正都弄一边 了，再来吧。（可恶的是这次是在草稿箱里写的，没有保存啊）
关于集合类自定义的排序通过一道题实现，参看老师的部分代码。
N只小白鼠(1 < N < 100)，每只鼠头上戴着一顶有颜色的帽子。现在称出每只白鼠的重量，要求按照白鼠重量从小到大的顺序输出它们头上帽子的颜色。帽子的颜色用 “red”，“blue”等字符串来表示。不同的小白鼠可以戴相同颜色的帽子。白鼠的重量用整数表示。
输入
输入第一行为一个整数N，表示小白鼠的数目。
下面有N行，每行是一只白鼠的信息。第一个为正整数，表示白鼠的重量，；第二个为字符串，表示白鼠的帽子颜色，字符串长度不超过10个字符。
注意：白鼠的重量各不相同。
输出
按照白鼠的重量从小到大的顺序输出白鼠的帽子颜色。
样例输入
3
30 red
50 blue
40 green样例输出
red
green
blue①首先通过基本数组Arrays.sort()实现，通过实现Comparable接口
import java.util.Arrays;
import java.util.Scanner;
class Mous implements Comparable<Mous>{///自定义排序
int num;
String color;
public int compareTo(Mous i) {
if(this.num<i.num){
return -1;
}else{
return 1;
}
}
}
public class Main{
static Mous mous[];
static Mous mou;
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while(in.hasNext()){
int n = in.nextInt();
mous = new Mous[n];
for(int i=0;i<n;i++){
mou = new Mous();
mou.num=in.nextInt();
mou.color=in.next();
mous[i]=mou;
}
Arrays.sort(mous);
for(int i=0;i<n;i++){
System.out.println(mous[i].color);
}
}
}
}以下几种方式纯属为了加深对集合类自定义排序的理解敲的
②通过ArrayList（）类的对象类，实现Comparable接口
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
class Mouse implements Comparable<Mouse>{
int weight;
String color;
public Mouse(int weight, String color) {
super();
this.weight = weight;
this.color = color;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
@Override
public int compareTo(Mouse o) {
// TODO Auto-generated method stub
return this.weight-o.weight;///此处若翻转相减则为降序
}
}
public class Main {
public static void main(String[] args) throws Exception {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
List<Mouse> list=new ArrayList<Mouse>();
for(int i=0;i<n;i++){
list.add(new Mouse(sc.nextInt(),sc.next()));
}
Collections.sort(list);
for(Mouse mouse:list){
System.out.println(mouse.getColor());
}
}
}③通过Comparator匿名类实现
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;
class mouse{
int weight;
String color;
public mouse(int a,String b) {
this.weight=a;
this.color=b;
}
public String get_String() {
return this.color;
}
}
public class Main{
public static void main(String[]args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
List<mouse>list=new ArrayList<mouse>();
for(int i=1;i<=n;i++) {
list.add(new mouse(sc.nextInt(),sc.next()));
}
Collections.sort(list,new Comparator<mouse>() {
@Override
public int compare(mouse arg0, mouse arg1) {
// TODO 自动生成的方法存根
return arg0.weight-arg1.weight;///此处升序，若相反相减即为降序
}
});
for(mouse i:list) {
System.out.println(i.color);
}
}
}④ /*单独定义Comparator的对象实现，在上面代码的基础是上可直接改*/
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Scanner;
class mouse{
int weight;
String color;
public mouse(int a,String b) {
this.weight=a;
this.color=b;
}
public String get_String() {
return this.color;
}
}
class myComparator implements Comparator<mouse>{
public int compare(mouse arg0, mouse arg1) {
// TODO 自动生成的方法存根
return arg0.weight-arg1.weight;///此处升序，若相反相减即为降序
}
}
public class Main{
public static void main(String[]args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
List<mouse>list=new ArrayList<mouse>();
for(int i=1;i<=n;i++) {
list.add(new mouse(sc.nextInt(),sc.next()));
}
Collections.sort(list, new myComparator());
for(mouse i:list) {
System.out.println(i.color);
}
}
}
⑤关于用TreeSet实现，TreeSet的底层就是通过树来实现的，TreeSet要求对于输入的元素必须可以比较，默认为升序，也可以通过逆序树实现，就变为降序实现（后面会具体实现），但对于以类作为做元素的对象是不可以的，必须先通过Cpmparabl接口才行。
代码如下：
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;
class Mouse implements Comparable<Mouse>{
int weight;
String color;
public Mouse(int weight, String color) {
super();
this.weight = weight;
this.color = color;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
@Override
public int compareTo(Mouse o) {
// TODO Auto-generated method stub
return this.weight-o.weight;///此处若翻转相减则为降序
}
}
public class Main {
public static void main(String[] args) throws Exception {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
Set<Mouse> list=new TreeSet<Mouse>();
for(int i=0;i<n;i++){
list.add(new Mouse(sc.nextInt(),sc.next()));
}
for(Mouse mouse:list){
System.out.println(mouse.getColor());
}
}
}关于逆序树看下面代码：
画1的地方原本我以为是该升序输出的，结果却降序输出，然后我就去问了老师，然后因为我忘记了2那个地方的逆序树，如果把2处的代码删除就是升序了。over
5.TreeMap实现，此代码以此题举例，不可用于评测。
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.Map;
import java.util.Scanner;
import java.util.TreeMap;
public class Main{
public static void main(String[]args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
Map<Integer,String> map=new TreeMap<Integer,String>();
for(int i=1;i<=n;i++) {
map.put(sc.nextInt(), sc.next());
}
System.out.println("升序排序：");
for(Iterator<Integer>it=map.keySet().iterator();it.hasNext();) {
System.out.println(map.get(it.next()));///默认按可以值得升序排序输出
}
System.out.println("降序排列：");
TreeMap<Integer,String> map2=new TreeMap<Integer,String>(Collections.reverseOrder());///初始化为反转排序
map2.putAll(map);
for(Iterator<Integer>it=map2.keySet().iterator();it.hasNext();) {
System.out.println(map2.get(it.next()));
}
}
}
/*
3
30 red
50 blue
40 green
升序排序：
red
green
blue
降序排列：
blue
green
red
*/代码：TreeMap实现
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.Map;
import java.util.Scanner;
import java.util.TreeMap;
public class Main{
public static void main(String[]args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
Map<Integer,String> map=new TreeMap<Integer,String>();
for(int i=1;i<=n;i++) {
map.put(sc.nextInt(), sc.next());
}
for(Iterator<Integer>it=map.keySet().iterator();it.hasNext();) {
System.out.println(map.get(it.next()));///默认按可以值得升序排序输出
}
}
}结束！！！
若有错误请评论，谢谢。随着知识的加深，会再来丰富。参考董卫老师的部分代码。