Java中的sort()

最新推荐文章于 2024-05-15 04:33:20 发布
最新推荐文章于 2024-05-15 04:33:20 发布
阅读量1.1k 收藏 11
点赞数 1
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39216184/article/details/79751352
版权

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]);    

            }    
        }    

    }    
}

注意：这里的起始下标和终止下标一定要是整形数。不能是浮点型。
亦可以给浮点型排序
例：

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()的第二种格式

如果一个数组初始化时已经赋值。则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) 返回一个基本类型的整型

(1)如果要按照升序排序，
则o1 小于o2，返回-1（负数），相等返回0，01大于02返回1（正数）

(2)如果要按照降序排序
则o1 小于o2，返回1（正数），相等返回0，01大于02返回-1（负数）

例：（降序）

import java.util.Arrays;    
import java.util.Comparator;    
import java.util.Scanner;    
import java.util.*;      

class shu ///创建类    
{    
    int x;    
}    

class cmp implements Comparator<shu> {    
    /*  
     * 因为上面指定了类型<shu>，所以此处可以直接(shu A,shu B) 否则要写成(Object A,Object  
     * B)，再强制转换成shu类型：((shu)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);    
            }    

        }    
    }    
}    
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.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);    
            }    

        }    
    }    
}
QingxinCyrilLee
关注
  • 1
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java Arrays.sort()方法整理
Liu每天学一点
04-16 322
排序算法实现说明：排序算法是Vladimir Yaroslavskiy，Jon Bentley和Joshua Bloch编写的Dual-Pivot Quicksort（双轴快速排序）。 该算法可在许多数据集上提供O(n log(n))性能，并且通常比传统的（单轴）Quicksort实现要快。 1.Arrays.sort(int[ ] a) 将指定的数组按升序排序。 // byte[ ] a, ch...
Java中 Collections.sort()方法
正直 的博客
10-10 1149
本着简单的原则，我们来实现用Collection的静态方法sort()的讲解，其中，只需要将实现Collection的集合（LinkedList,ArrayList,HashSet,TreeSet）等直接写入sort()方法中就可以自动按照升序排序，那么如果想要降序怎么办，或者有是有是自定义的类型，想按照自己的想法排序怎么办？ 代码如下 class Student{ public int ...
笔记--java sort() 方法排序
Vibugs的博客
04-16 7680
能掌握到的知识 1. 了解compaer(O1 ，O2) 中 返回1 -1 0 这三个什么意思 并且如何使用这三个值达到自己想要的排序 2. 如何实现组合排序 即满足排序1情况下进行排序2
详述Java中sort排序函数
热门推荐
秋名山码民的技术小屋
06-04 4万+
手写一个排序算法的效率是很慢的，当然这也不利于我们在比赛或者工程中的实战，如今几乎每个语言的标准库中都有排序算法，今天让我来给大家讲解一下Java语言中的sort排序Collections类中的sort方法可以实现List接口的集合进行排序 降序排序 Java中降序排序有俩种方法（和c++很类似，可以看我这篇博客）： c++sort排序 实现 Comparator 接口的复写 compare() 方法 排序原理 通常，在看有关算法书籍的时候，会发现都说有关数组的排序算法，而且使用的都是随机访问，但是
java中sort函数的使用
最新发布
2401_84831774的博客
05-15 881
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
JAVA里sort()方法的使用与原理解析
陈三千的博客
03-09 7903
Arrays.sort和Collections.sort实现原理解析 1、使用 排序 sort()是Java中用来排序的一个方法,在我们专心学习各种经典排序算法的时候,其实在代码中一个sort()就可以解决,并且时间复杂度和空间复杂度相对都不会过高。 其实sort()不光可以对数组进行排序,基本数据类型的数组都可以,并且可以实现对对象数组的排序.接下来介绍一下用法. 1. 基本数据类型 (1)数字类型: int[] a = {1, 3, 4, 67, 78, 9, 90, 6, 3, 2}; Array
Java 中使用 sort() 方法排序：从基本原理到多种用法全面总结；sort()函数的使用
weixin_72499901的博客
03-09 9798
Java 中使用 sort() 方法排序：从基本原理到用法详解，sort()函数怎么使用,sort()使用方法总结，包含升序，降序逆序，部分排序，自定义排序，lambda表达式，多级排序，cmp等等......蓝桥杯备赛，蓝桥杯java组，leetcode，java；Arrays.sort；Collections.sort；Comparator
java sort方法详解
PoisonKiller的博客
12-16 9280
详解JDK中的sort函数
sort strategy for java
04-11
在Java编程语言中，排序策略是处理数据结构和算法的重要组成部分。本文将深入探讨Java实现的几种主要排序算法，包括冒泡排序、插入排序、合并排序、快速排序和堆排序，以及如何通过分析器对这些排序算法进行性能比较...
java中Collections.sort排序详解
08-25
Java中Collections.sort排序详解 Java中的Collections.sort排序是Java.util.Collections类中的一个静态方法，用于对列表进行排序。下面将详细介绍Collections.sort排序的使用和实现机制。 Collections.sort()方法...
Java1.8中文API
09-25
Java 1.8中文API是Java开发者的重要参考资料，它提供了详尽的类库文档，使得开发者可以更加方便地理解和使用Java 1.8版本中的各种功能。这份API文档以中文呈现，极大地降低了语言障碍，方便了中国开发者进行学习和...
详解Java中Collections.sort排序
08-30
在Java编程语言中，`Collections.sort()`方法是一个非常重要的工具，它用于对集合中的元素进行排序。这个方法主要应用于`List`接口的实现类，如`ArrayList`和`LinkedList`等。`Collections.sort()`有两种主要的排序...
java sort面试题目
03-10
java sort面试题目
Java排序方法sort的使用详解
weixin_39552097的博客
11-02 1万+
对数组的排序： //对数组排序 public void arraySort(){ int[] arr = {1,4,6,333,8,2}; Arrays.sort(arr);//使用java.util.Arrays对象的sort方法 for(int i=0;i<arr.length;i++){ System.out.println(arr[i]); } } 需要用到降序排列，首先想到了Arrays.sort方法，但是Arrays.sort默认是升序排列， 可以使用一下方式来达到降序的需求。 Array
Java排序的那些事之sort方法的使用详解
muzitian的博客
10-09 4634
java sort 使用
JAVA中sort()排序解析
分享+记录
01-08 8628
前言 我们经常使用java中的sort排序，确实好用，但是其中原理大多数人都是不了解的。 面试中也经常会问到各种排序算法，但是java中用的到底是哪种排序呢？ 本文就带你通过源码解析，了解其中的原理，如果只想知道结果，可以直接跳转到第四章-总结。 PS：Collections.sort调用的其实也是Arrays.sort()方法，所以本文只针对Arrays.sort()方法进行解读，且基于JDK1.8进行。 第一章：根据数组长度分类 我们查看源码，可以看到sort最终调用的是DualPivo
总结——Java中sort函数的使用方法
weixin_42956047的博客
03-01 3052
JAVA中sort函数的使用方法 在编程练习中，我们会经常用到排序，相比C和C++，使用Java提供的排序方法会更快捷，Java的Arrays类中有一个sort()方法，该方法是Arrays类的静态方法，在需要对数组进行排序时，非常的好用。 1、Arrays.sort(int[] a) 作用：对一个数组的所有元素进行排序，并且是按从小到大的顺序（默认升序）。 Leedcode题目：977.有序数组...
java中sort()方法的用法
月下犀牛
05-09 4841
在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
05-26
Java中的sort方法是用来对数组进行排序的。 语法如下： ``` public static void sort(int[] arr) ``` 其中，arr是要排序的数组。 示例代码： ```java int[] arr = {13, 7, 6, 45, 21, 9, 101, 102}; Arrays.sort(arr); System.out.print("排序后的数组为："); for (int i = 0; i < arr.length; ++i) { System.out.print(arr[i] + " "); } ``` 输出结果： ``` 排序后的数组为：6 7 9 13 21 45 101 102 ``` sort方法默认使用快速排序算法进行排序。如果需要按照指定的比较器Comparator进行排序，可以使用以下语法： ``` public static <T> void sort(T[] arr, Comparator<? super T> c) ``` 其中，arr是要排序的数组，c是要使用的比较器。 示例代码： ```java String[] arr = {"apple", "banana", "pear", "orange", "grape"}; Arrays.sort(arr, new Comparator<String>() { @Override public int compare(String o1, String o2) { return o1.compareTo(o2); } }); System.out.println(Arrays.toString(arr)); ``` 输出结果： ``` [apple, banana, grape, orange, pear] ``` 该示例中，使用了匿名内部类实现了一个字符串比较器，将数组按照字典序进行排序。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值