JAVA中sort函数的使用方法的个人总结

最新推荐文章于 2024-07-13 11:38:15 发布
最新推荐文章于 2024-07-13 11:38:15 发布
阅读量4.8w 收藏 136
点赞数 48
分类专栏： JAVA 文章标签： java 入门知识
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37405320/article/details/72862155
版权

说到排序的话，第一个想到的是sort函数。但是吧，java里的sort函数与c++里的sort函数的使用方法有那么些不同。

在这里，本人将sort函数的使用方法大致罗列出来。


首先：sort函数的基本格式（默认排序为升序排序）

Arrays.sort(数组名,起始下标,终止下标);


我们举个简单的例子

    import java.util.*;  
    import java.util.Arrays;  
    public class Main {  
        public static void main(String[] args) {  
              
            Scanner in=new Scanner(System.in);  
              
            while(in.hasNext())  
            {  
                int num[]=new int[100];  
                  
                int n;///输出n个数  
                n=in.nextInt();  
                  
                for(int i=0;i<n;i++)  
                {  
                    num[i]=in.nextInt();  
                      
                }  
                  
                Arrays.sort(num,0,n);///排序部分  
                  
                for(int i=0;i<n;i++)  
                {  
                    System.out.println(num[i]);  
                      
                }  
            }  
      
        }  
    }

这个代码输入n个数，并把他们从小到大排序，运行结果如下。


大家注意一下，这里的起始下标和终止下标一定要是整形数。不能是浮点型。不然会报


用sort函数对浮点数呢？

    import java.util.*;  
    import java.util.Arrays;  
    public class Main {  
        public static void main(String[] args) {  
              
            Scanner in=new Scanner(System.in);  
              
            while(in.hasNext())  
            {  
                double  num[]=new double[100];  
                  
                int n;///输出n个数  
                n=in.nextInt();  
                  
                for(int i=0;i<n;i++)  
                {  
                    num[i]=in.nextDouble();  
                      
                }  
                  
                Arrays.sort(num,0,n);///排序部分  
                  
                for(int i=0;i<n;i++)  
                {  
                    System.out.println(num[i]);  
                      
                }  
            }  
      
        }  
    }

运行结果如下



如果一个数组初始化时已经赋值。则SORT函数可以另外一种格式

Arrays.sort(数组名);

举个例子 

    import java.util.*;  
    import java.util.Arrays;  
    public class Main {  
        public static void main(String[] args) {  
              
            Scanner in=new Scanner(System.in);  
              
          
                int num[]= {5,4,3,2,1};  
                  
                Arrays.sort(num);  
                  
                for(int i=0;i<5;i++)  
                {  
                    System.out.println(num[i]);  
                      
                }  
          
      
        }  
    }



然而，只是单纯的降序升序排序是满足不了使用需求得。

所以，我们要研究下sort函数中cmp函数的使用方法


我们来看看cmp函数的格式

int compare(Object o1, Object o2);

我们可以看到，传入函数的是java中的类（java中没有结构体）

这时，sort函数的格式变为

    Arrays.sort(数组名, 起始下标, 终止下标, new cmp());

怎么自定义排序呢？

基本方法

int compare(Object o1, Object o2) 返回一个基本类型的整型
如果要按照升序排序，
则o1 小于o2，返回-1（负数），相等返回0，01大于02返回1（正数）
如果要按照降序排序
 则o1 小于o2，返回1（正数），相等返回0，01大于02返回-1（负数）


以上就是在cmp函数中的自定义排序方法。


我们来举个例子。-----输入n个数，然后降序排序。

    import java.util.Arrays;  
    import java.util.Comparator;  
    import java.util.Scanner;  
    import java.util.*;    
      
    class shu ///创建类  
    {  
        int x;  
    }  
      
    class cmp implements Comparator<shu> {  
        /* 
         * 因为上面指定了类型<he>，所以此处可以直接(he A,he B) 否则要写成(Object A,Object 
         * B)，再强制转换成he类型：((he)A).x 
         */  
        public int compare(shu A, shu B) ///降序排序  
        {  
                if(A.x<B.x)  
                {  
                    return 1;  
                }  
                else if(A.x==B.x)  
                {  
                    return 0;  
                }  
                else  
                {  
                    return -1;  
                }  
      
        }  
    }  
      
    public class Main {  
        public static void main(String[] args) {  
              
            Scanner in = new Scanner(System.in);  
      
            while (in.hasNext()) {  
                  
                shu num[] = new shu[100];///创建类数组  
      
                int n;  
                n = in.nextInt();  
      
                for (int i = 0; i < n; i++) {  
                      
                    num[i]=new shu();///这个地方容易漏  
                      
                    num[i].x = in.nextInt();  
                }  
                  
                Arrays.sort(num, 0, n, new cmp());  
                  
                for (int i = 0; i < n; i++) {  
                    System.out.println(num[i].x);  
                }  
      
            }  
        }  
    }


运行结果




为了更好地理解，我们来举一些关于java结构体排序的题目


例一:HRBUST 1095 最麻烦了   点击打开链接


    import java.util.Arrays;  
    import java.util.Comparator;  
    import java.util.Scanner;  
    import java.util.*;    
      
    class shu ///创建类  
    {  
        int acm;  
        int mon;  
        int rp;  
    }  
      
    class cmp implements Comparator<shu> {  
        public int compare(shu A, shu B) ///降序排序  
        {  
                if(A.acm==B.acm)  
                {  
                    if(A.mon==B.mon)  
                    {  
                        if(A.rp<B.rp)  
                        {  
                            return 1;  
                        }  
                        else if(A.rp==B.rp)  
                        {  
                            return 0;  
                        }  
                        else  
                        {  
                            return -1;  
                        }  
                    }  
                    else  
                    {  
                        if(A.mon<B.mon)  
                        {  
                            return 1;  
                        }  
                        else if(A.mon==B.mon)  
                        {  
                            return 0;  
                        }  
                        else  
                        {  
                            return -1;  
                        }  
                    }  
                }  
                else  
                {  
                    if(A.acm<B.acm)  
                    {  
                        return 1;  
                    }  
                    else if(A.acm==B.acm)  
                    {  
                        return 0;  
                    }  
                    else  
                    {  
                        return -1;  
                    }  
                }  
      
        }  
    }  
      
    public class Main {  
        public static void main(String[] args) {  
              
            Scanner in = new Scanner(System.in);  
      
            while (in.hasNext()) {  
                  
                shu num[] = new shu[1005];///创建类数组  
      
                int n;  
                n = in.nextInt();  
      
                for (int i = 0; i < n; i++) {  
                      
                    num[i]=new shu();///这个地方容易漏  
                      
                    num[i].acm = in.nextInt();  
                    num[i].mon = in.nextInt();  
                    num[i].rp  = in.nextInt();  
                }  
                  
                Arrays.sort(num, 0, n, new cmp());  
                  
                for (int i = 0; i < n; i++) {  
                    System.out.println(num[i].acm+" "+num[i].mon+" "+num[i].rp);  
                }  
      
            }  
        }  
    }  
    //int compare(Object o1, Object o2) 返回一个基本类型的整型  
    //如果要按照升序排序，  
    //则o1 小于o2，返回-1（负数），相等返回0，01大于02返回1（正数）  
    //如果要按照降序排序  
    // 则o1 小于o2，返回1（正数），相等返回0，01大于02返回-1（负数）  
    //
这题还有另外一种写法。（借用的） 

import java.util.*;

class mans
{
	long acm,money,rp;
}
class cmp implements Comparator<mans>
{
	public int compare(mans a,mans b)
	{
		if(a.acm==b.acm)
		{
			if(a.money==b.money)
			{
				return (int)(a.rp-b.rp);
			}
			return (int)(a.money-b.money);	
		}
		return (int)(a.acm-b.acm);
	}
}
public class Main
{

	public static void main(String[] args)
	{
		// TODO Auto-generated method stub
		Scanner scanf=new Scanner(System.in);
		mans a[]=new mans[1009];
		while(scanf.hasNext())
		{
			int n=scanf.nextInt();
			for(int i=0;i<n;i++)
			{
				a[i] = new mans();
				a[i].acm=scanf.nextLong();
				a[i].money=scanf.nextLong();
				a[i].rp=scanf.nextLong();
			}
			Arrays.sort(a,0,n,new cmp());
			for(int i=n-1;i>=0;i--)
			{
				System.out.println(a[i].acm+" "+a[i].money+" "+a[i].rp);
			}
		}
	}
}



但是更多的题目中，我们会遇到字典序排序的情况

这里，我们再举一个例子

例2：HRBUST 1023 JiaoZhu and C  点击打开链接

这个代码提交会超时！！！！！！！！！！！！！


    import java.util.Arrays;  
    import java.util.Comparator;  
    import java.util.Scanner;  
    import java.util.*;    
      
    class shu ///创建类  
    {  
        String name;///比较时用String  
        int mon;  
        int hunt;  
    }  
      
    class cmp implements Comparator<shu> {  
        public int compare(shu A, shu B)   
        {  
                if(A.hunt==B.hunt)  
                {  
                    if(A.mon==B.mon)  
                    {  
                        int flag=(A.name).compareTo(B.name);///按字典序排序  
                        if(flag==0)  
                        {  
                            return 0;  
                        }  
                        else if(flag<0)  
                        {  
                            return -1;  
                        }  
                        else  
                        {  
                            return 1;  
                        }  
                    }  
                    else  
                    {  
                        if(A.mon==B.mon)  
                        {  
                            return 0;  
      
                        }  
                        else if(A.mon<B.mon)  
                        {  
                            return -1;  
                        }  
                        else  
                        {  
                            return 1;  
                        }  
                              
                    }  
                }  
                else  
                {  
      
                    if(A.hunt==B.hunt)  
                    {  
                        return 0;  
      
                    }  
                    else if(A.hunt<B.hunt)  
                    {  
                        return 1;  
                    }  
                    else  
                    {  
                        return -1;  
                    }  
                }  
      
                  
        }  
      
      
    }  
      
    public class Main {  
        public static void main(String[] args) {  
              
            Scanner in = new Scanner(System.in);  
      
            while (in.hasNext()) {  
                  
                shu num[] = new shu[100005];///创建类数组  
      
                int n;  
                n = in.nextInt();  
      
                for (int i = 0; i < n; i++) {  
                      
                    num[i]=new shu();///这个地方容易漏  
                      
                    num[i].name=in.next();  
                    num[i].hunt=in.nextInt();  
                    num[i].mon=in.nextInt();  
                }  
                  
                Arrays.sort(num, 0, n, new cmp());  
                  
                for (int i = 0; i < n; i++) {  
                    System.out.println(num[i].name);  
                }  
      
            }  
        }  
    }


大约就是酱紫了




Emiya丶
关注
  • 48
    点赞
  • 踩
  • 136
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
Java中的sort方法总结
m0_46160753的博客
06-28 1684
Java中常用的数组或集合排序的方法有两个，一个是java.util.Arrays中的静态方法Arrays.sort()，还有一个是java.util.Collections中的静态方法的Collections.sort()方法。 1.Arrays.sort() （1）Arrays.sort(int[] a) 对一个数组的所有元素进行排序，按从小到大的顺序。 （2）Arrays.sort(int[] a, int fromIndex, int toIndex) 对数组部分排序，对数组a的下标从fromInd
Java 中使用 sort() 方法排序：从基本原理到多种用法全面总结；sort()函数的使用_java中sort排序函数用法
2401_83704192的博客
04-07 2138
/数组自定义对象排序//注：Person 类中需有getName()方法//按照姓名排序​// 集合自定义对象排序**自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。****深知大多数Python工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！**
JAVA中的排序函数
xqqqiang的博客
09-23 1万+
JAVA中的排序函数包括java.util.Arrays中的Arrays.sort();java.util.Collections中的Collections.sort()
深入理解java中Arrays.sort()的用法
08-19
主要介绍了深入理解java中Arrays.sort()的用法，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
【Java】Array.sort() 方法
最新发布
weixin_44009606的博客
07-13 481
根据指定比较器产生的顺序对指定对象数组的指定对象数组进行排序。场景：给定两个数组，int A[],int B[]。排序按A升序，相同则按B升序。
java中sort函数的使用
乐褀的博客
09-24 8891
java中sort函数的使用写在前面 写在前面 想必大家都知道C++里面的sort用过的都知道这个函数是绝对好用，不开玩笑，什么冒泡，快排，二分啊，讲真的还是sort是真的香。但是java里面也有sort函数只不过使用方式有些不同而已，下面就是我整理的一些笔记啦，可以帮你快速搞定sort，一文在手，sort无忧。 ...
排序之Java的Sort函数
chendong_的博客
11-01 1万+
排序 Sort函数 java Arrays.sort
Java 中使用 sort() 方法排序：从基本原理到多种用法全面总结；sort()函数的使用
weixin_72499901的博客
03-09 1万+
Java 中使用 sort() 方法排序：从基本原理到用法详解，sort()函数怎么使用,sort()使用方法总结，包含升序，降序逆序，部分排序，自定义排序，lambda表达式，多级排序，cmp等等......蓝桥杯备赛，蓝桥杯java组，leetcode，java；Arrays.sort；Collections.sort；Comparator
java sort函数
arcobaleno1996的专栏
02-21 2329
//对数组排序 public void arraySort(){     int[] arr = {1,4,6,333,8,2};     Arrays.sort(arr);//使用java.util.Arrays对象的sort方法 } //对list升序排序     public void listSort1(){         List&lt;Integer&gt; list...
java中sort函数comparator的使用_Java8 Comparator: 列表排序的深入讲解
weixin_36184718的博客
12-31 892
在本文中，我们将看到几个关于如何在Java 8中对List进行排序的示例。1.按字母顺序排序字符串列表List cities = Arrays.asList("Milan","london","San Francisco","Tokyo","New Delhi");System.out.println(cities);//[Milan, london, San Francisco, Tokyo, ...
javascript中sort() 方法使用详解
11-23
JavaScript中的`sort()`方法是数组对象的一个非常重要的成员，它允许我们对数组的元素进行排序。这个方法的核心在于，它可以接受一个可选的`sortby`参数，该参数是一个比较函数，用来定义排序规则。 首先，如果我们...
java中Collections.sort排序函数用法详解
09-01
在Java编程语言中，`Collections.sort()` 是一个非常重要的函数，它用于对集合中的元素进行排序。这个函数是 `java.util.Collections` 类的一个静态方法，适用于列表（List）类型的集合。`Collections.sort()` 可以...
Java 中使用 sort() 方法排序：从基本原理到多种用法全面总结；sort()函数的使用_java中sort排序函数用法(1)
2401_83704159的博客
04-07 553
/数组自定义对象排序//注：Person 类中需有getName()方法//按照姓名排序​// 集合自定义对象排序// 使用 Collections.sort() 对 List 进行排序//匿名内部类//比较的是age0 : 1;//当ab返回1});自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
JAVA中sort函数的简单使用方法 【java】
热门推荐
Emiya丶的博客
05-18 1万+
渣渣学最近做JAVA作业时查了一下JAVA中排序函数sort的使用方法。。故此处列出来。。（针对JAVA初学者）大致的模板是酱紫的Arrays.sort(数组名,起始下标,终止下标);我们来举个栗子import java.util.*; import java.util.Arrays; public class Main { public static void main(String[] ar...
java中sort()方法的用法
月下犀牛
05-09 4854
在java.util.Collections类中有个sort()方法，主要是用来给数组排序，排序的规则可以自己重写。 （一）给数组{2，3，1，5}按自小到大排序 public class Main{ public static void main(String[] args){ ArrayList<Integer> list=new ArrayList<>(); list.add(2); list.add(3);
java中类似sort_java中的Sort函数，你值得看
weixin_39928844的博客
02-13 101
基于C语言中的sort如此这么方便，自然而然，java中也有类似C的sort函数。1.普通数组：Arrays.sort(数组名，开始位置，结束位置)。2.类中属性排序：模板：class A{int n;}class cmp implement Comparator{升序：public int compare(A a,A b){if(a.n < b.n){return 1;}else if(a...
java中sort用法
qq_45700494的博客
04-19 560
java的sort（） 对类中一项进行排序（选择排序） 这是对于整形的比较 process.sort((o1, o2) -> o1.getexe()-(o2.getexe())); Collections.sort(process, (o1, o2) -> o1.getexe()-(o2.getexe())); 下面的也可以 process.sort(Comparator.comparing(work::getexe)); 对于String类型的比较 employees.s
java中sort的使用方法
ForrestGump的专栏
05-08 2306
今天做一个简单的oj题目要用到排序，用C写的话10行左右就AC了，但是手贱了想要java提交，于是乎写了一长串代码，鼓捣了半天才AC了 我就纳闷了，同样是sort，实现起来咋就比STL复杂呢么多呢==    ................ 好了  抱怨到此结束~ 如果是单纯的从小到大排序是很简单的，因为sort默认就是从小到大排序= = 那么如何从大到小排序呢？如何对类进行排序呢（联想C的
总结——Java中sort函数的使用方法
weixin_42956047的博客
03-01 3081
JAVA中sort函数的使用方法 在编程练习中，我们会经常用到排序，相比C和C++，使用Java提供的排序方法会更快捷，Java的Arrays类中有一个sort()方法，该方法是Arrays类的静态方法，在需要对数组进行排序时，非常的好用。 1、Arrays.sort(int[] a) 作用：对一个数组的所有元素进行排序，并且是按从小到大的顺序（默认升序）。 Leedcode题目：977.有序数组...
Java语言sort函数
06-08
Java语言中的sort函数是用来对数组进行排序的，它可以按照升序或者降序排列数组中的元素。sort函数使用的是快速排序算法，因此具有较高的排序效率。 sort函数的使用方法如下： ```java // 对整型数组按照升序排列 int[] arr = {3, 1, 5, 2, 4}; Arrays.sort(arr); // 对字符串数组按照降序排列 String[] strArr = {"apple", "banana", "orange", "peach"}; Arrays.sort(strArr, Collections.reverseOrder()); // 对自定义类的数组按照某个属性排序 Person[] personArr = {new Person("Tom", 20), new Person("Jerry", 18), new Person("Alice", 22)}; Arrays.sort(personArr, Comparator.comparing(Person::getAge)); ``` 其中，第一个参数是要排序的数组，第二个参数可以指定排序方式，如果不指定则默认按照升序排列。如果要按照降序排列，则可以使用`Collections.reverseOrder()`函数。如果要对自定义类的数组进行排序，则需要自定义一个比较器，用`Comparator.comparing()`函数指定排序属性。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值