基于java语言的Arrays.sort()用法

最新推荐文章于 2025-01-22 23:15:46 发布

原创最新推荐文章于 2025-01-22 23:15:46 发布 · 149 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #数据结构 #快速排序 #编程语言

本文详细介绍了Java中Arrays类的sort()方法的不同用法，包括基本的升序排序、部分排序以及如何通过自定义Comparator实现降序排序。适用于Java初学者及需要掌握高级排序技巧的开发者。

1、简介

Java的Arrays类中有一个sort()方法，该方法是Arrays类的静态方法，在需要对数组进行排序时，非常的好用，但是sort()的参数有好几种。

2、 Arrays.sort(int[] a)

含义：按从小到大的顺序对数组中元素进行排序，实例如下：
代码

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);
         for(int i = 0; i < a.length; i ++) {
              System.out.print(a[i] + " ");
         }
     }
 
 }

运行结果
```
  0 1 2 3 4 5 6 7 8 9
```

2、Arrays.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 void sort(T[] a,int fromIndex,int toIndex, Comparator c)

实质：不难看出，上述排序只能是从小到大而不能实现从大到小的排序。若要实现从大到小的排序，则需要牵扯Java泛型。实际上，无非就是多了一个Comparator类型的参数。
案例1代码

 1 package test;
 2 
 3 import java.util.Arrays;
 4 import java.util.Comparator;
 5 
 6 public class Main {
 7     public static void main(String[] args) {
 8         //注意，要想改变默认的排列顺序，不能使用基本类型（int,double, char）
 9         //而要使用它们对应的类
10         Integer[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
11         //定义一个自定义类MyComparator的对象
12         Comparator cmp = new MyComparator();
13         Arrays.sort(a, cmp);
14         for(int i = 0; i < a.length; i ++) {
15             System.out.print(a[i] + " ");
16         }
17     }
18 }
19 //Comparator是一个接口，所以这里我们自己定义的类MyComparator要implents该接口
20 //而不是extends Comparator
21 class MyComparator implements Comparator<Integer>{
22     @Override
23     public int compare(Integer o1, Integer o2) {
24         //如果n1小于n2，我们就返回正值，如果n1大于n2我们就返回负值，
25         //这样颠倒一下，就可以实现反向排序了
26         if(o1 < o2) { 
27             return 1;
28         }else if(o1 > o2) {
29             return -1;
30         }else {
31             return 0;
32         }
33     }
34     
35 }

案例1运行结果
```
  9 8 7 6 5 4 3 2 1 0
```
案例2代码

package com.ypj.java;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

/**
 *
 * 从大到小排序
 */

public class Sort {
    public static void sort(Integer[] array){
        List<Integer> arraylist=new ArrayList<>();
        List<List<Integer>> arraylist1=new ArrayList<>();
        Comparator cmp=new MyComparator();
        Arrays.sort(array,cmp); // 快速排序法的时间复杂度：O(nlog(n));

        for(int i=0;i<array.length;i++){
            arraylist.add(array[i]);
        }
        arraylist1.add(arraylist);
        System.out.println(arraylist1);
    }


    public static void main(String[] args) {
        Integer[] array1={3,4,0,1,2,5,6,-1,-2};
        sort(array1);
    }
}

class MyComparator implements Comparator<Integer> {
    @Override
    public int compare(Integer o1, Integer o2){
        if(o1<o2){
            return 1;
        }else if(o1>o2){
            return -1;
        }else{
            return 0;
        }
    }
}