Java排序的那些事之sort方法的使用详解

目录
  • 引言
  • 升序
  • 数组
  • 集合
  • 降序
    • 声明一个类实现接口
    • 匿名内部类实现接口
    • Lambda表达式实现接口
  • 自定义数据类型的排序
  • 总结:

引言

在学习Java过程中,排序sort是我们常用的功能;在Java里,数组有Arrays.sort()可以排序,集合则是Collections.sort()方法排序;默认情况下是升序排列,但是降序又该怎么排?又可以通过哪几种方法呢?自定义类型又该怎么做?

下面就来介绍一下sort方法的使用;

升序

升序是默认情况下的,所以这里就简单展示一下使用的方法;

数组

数组的sort方法位于Arrays工具类下
代码如下:

import java.util.Arrays;

public class SortTest01 {
    public static void main(String[] args) {
        int[] array = {2, 4, 8, 9, 78, 1, 3, 66}; // 整型数组
        Arrays.sort(array); // 升序排序
        for (int i : array) {
            System.out.print(i + " ");
        }
    }
}

结果如下:

1 2 3 4 8 9 66 78

集合

集合的sort方法位于Collections类下
代码如下:

import java.util.Collections;
import java.util.LinkedList;
import java.util.List;

public class SortTest02 {
    public static void main(String[] args) {
        List<Integer> list = new LinkedList<>(); // 定义一个链表
        // 降序放入list
        for (int i = 10; i >= 0; --i) {
            list.add(i);
        }
        Collections.sort(list); // 升序排序
        for (var i : list) {
            System.out.print(i + " ");
        }
    }
}

结果如下:

0 1 2 3 4 5 6 7 8 9 10

降序

降序就需要一点额外的步骤;这里就需要用到一个接口:Comparator<T>

其实实际上我们用到的只是Comparator<T> 接口中的一个方法,也是这个接口唯一的方法:int compare(T o1, T o2)
sort方法默认情况下是升序,但是它的一个重载版本可以额外放一个Comparator<T>的参数,作为一个比较器
可以看看Collections的sort方法:

还有Arrays里的sort方法

可以看到它们都Comparator<T>参数,所以我们只需要在这里制定指定的规则,就可以按照我们的方式进行排序;

所以接下来的问题就是如何实现Comparator<T> 接口并重写int compare(T o1, T o2)方法了,这里我提供三种方法:

下面就只用集合来作为例子;

声明一个类实现接口

代码如下:

import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;

public class SortTest03 {
    public static void main(String[] args) {
        List<Integer> list = new LinkedList<>(); // 定义一个链表
        // 升序放入list
        for (int i = 0; i <= 10; ++i) {
            list.add(i);
        }
        Collections.sort(list, new MyCompare()); // 降序排序
        for (var i : list) {
            System.out.print(i + " ");
        }
    }
}
class MyCompare implements Comparator<Integer> {
    // 制定排序规则:降序
    @Override
    public int compare(Integer o1, Integer o2) {
        return o2 - o1;
    }
}

结果如下:

10 9 8 7 6 5 4 3 2 1 0

匿名内部类实现接口

代码如下:

import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;

public class SortTest04 {
    public static void main(String[] args) {
        List<Integer> list = new LinkedList<>(); // 定义一个链表
        // 升序放入list
        for (int i = 0; i <= 10; ++i) {
            list.add(i);
        }
        // 匿名内部类降序排序
        Collections.sort(list, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        for (var i : list) {
            System.out.print(i + " ");
        }
    }
}

结果如下:

10 9 8 7 6 5 4 3 2 1 0

Lambda表达式实现接口

代码如下:

import java.util.Collections;
import java.util.LinkedList;
import java.util.List;

public class SortTest04 {
    public static void main(String[] args) {
        List<Integer> list = new LinkedList<>(); // 定义一个链表
        // 升序放入list
        for (int i = 0; i <= 10; ++i) {
            list.add(i);
        }
        // Lambda表达式降序排序
        Collections.sort(list, (o1, o2) -> o2 - o1);
        for (var i : list) {
            System.out.print(i + " ");
        }
    }
}

结果如下:

10 9 8 7 6 5 4 3 2 1 0

这三种方法还是需要根据实际情况使用的,假如这个排序规则需要多次使用,还是单独创建一个类实现比较好;
如果只是使用一次,那么就用匿名内部类或者Lambda表达式,相对而言Lambda表达式更简单;

自定义数据类型的排序

如果想要对自己定义的类实例化的对象进行排序,那么同样需要Comparator<T> 去指定排序的规则;
下面例子通过创建一个类的方式来实现接口;

代码如下:

import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;

public class SortTest05 {
    public static void main(String[] args) {
        List<Student> list = new LinkedList<>(); // 创建一个链表
        list.add(new Student(18, "202101", "张三"));
        list.add(new Student(28, "202180", "李四"));
        list.add(new Student(11, "202135", "王五"));
        list.add(new Student(18, "202169", "赵六"));
        list.add(new Student(11, "202122", "小七"));
        list.add(new Student(48, "202156", "碧萝"));
        // 排序前
        for (var i : list) {
            System.out.println("name:" + i.getName() + " age:" + i.getAge() + " ID:" + i.getID());
        }
        Collections.sort(list, new StuCompare()); // 自定义排序规则排序
        // 排序后
        System.out.println("=======================");
        for (var i : list) {
            System.out.println("name:" + i.getName() + " age:" + i.getAge() + " ID:" + i.getID());
        }
    }
}
// 学生类
class Student {
    private int age; // 年龄
    private String ID; // 学号
    private String name; // 姓名

    public Student() {
    }
    public Student(int age, String ID, String name) {
        this.age = age;
        this.ID = ID;
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getID() {
        return ID;
    }
    public void setID(String ID) {
        this.ID = ID;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
// 学生排序类
class StuCompare implements Comparator<Student> {
    // 升序
    @Override
    public int compare(Student o1, Student o2) {
        int flag;
        // 先通过年龄排序
        flag = o1.getAge() - o2.getAge();
        // 如果年龄相同,则通过学号比较排序
        if (flag == 0) {
            flag = o1.getID().compareTo(o2.getID());
        }
        return flag;
    }
}

结果如下:

name:张三 age:18 ID:202101
name:李四 age:28 ID:202180
name:王五 age:11 ID:202135
name:赵六 age:18 ID:202169
name:小七 age:11 ID:202122
name:碧萝 age:48 ID:202156
=======================
name:小七 age:11 ID:202122
name:王五 age:11 ID:202135
name:张三 age:18 ID:202101
name:赵六 age:18 ID:202169
name:李四 age:28 ID:202180
name:碧萝 age:48 ID:202156

可以看出来我们可以自己定义自定义类型的排序规则,非常简单;
这里我使用一个类实现了Comparator<T> ,匿名内部类和Lambda表达式也可以;但是还是一样,如果经常需要排序还是推荐定义一排序类,这样用起来更方便;

总结:

需要掌握的就是两点:

  • sort基本方法使用
  • Comparator<T> 接口的使用(这里注意一下:不要和Comparable<T>弄混)

sort还是挺实用的,希望这篇文章能够让你真正学会使用sort方法!

到此这篇关于Java排序的那些事之sort方法的使用详解的文章就介绍到这了,更多相关Java sort方法内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • 深入理解java中Arrays.sort()的用法

    Java的Arrays类中有一个sort()方法,该方法是Arrays类的静态方法,在需要对数组进行排序时,非常的好用. 但是sort()的参数有好几种,基本上是大同小异,下面是以int型数组为例的Arrays.sort()的典型用法 import java.util.Arrays; import java.util.Comparator; /** * Arrays.sort()排序 */ public class SortTest { public static void main(Strin

  • JAVA基于Arrays.sort()实现数组升序和降序

    java中对数组进行排序 使用Array.sort() 这个默认是升序 @Test public void index4(){ int scores[] = new int[]{1,2,3,89,4}; Arrays.sort(scores); for (int i:scores ) { System.out.println(i); } } 如果想降序怎么办呢? 使用:Arrays.sort(scores,Collections.reverseOrder()); 需要注意的是 不能使用基本类型(

  • 详解java Collections.sort的两种用法

    Collections是一个工具类,sort是其中的静态方法,是用来对List类型进行排序的,它有两种参数形式: public static <T extends Comparable<? super T>> void sort(List<T> list) { list.sort(null); } public static <T> void sort(List<T> list, Comparator<? super T> c) {

  • Java使用Collections.sort()排序的示例详解

    Java中Collections.sort()排序详解,通过实例代码给大家讲解,具体代码如下所示: public static void main(String[] args) { List<String> list = new ArrayList<String>(); list.add("beijing"); list.add("shanghai"); list.add("hangzhou"); Collections.

  • 详解Java sort()数组排序(升序和降序)

    我们在学习 Java 的过程中肯定会遇到对数组进行升序或降序等排序问题,本节主要介绍如何实现 Java 数组的升序和降序.Java 语言使用 Arrays 类提供的 sort() 方法来对数组进行排序. 升序 使用 java.util.Arrays 类中的 sort() 方法对数组进行升序分为以下两步: 导入 java.util.Arrays 包. 使用 Arrays.sort(数组名) 语法对数组进行排序,排序规则是从小到大,即升序. 假设在数组 scores 中存放了 5 名学生的成绩,现在

  • Java排序的那些事之sort方法的使用详解

    目录 引言 升序 数组 集合 降序 声明一个类实现接口 匿名内部类实现接口 Lambda表达式实现接口 自定义数据类型的排序 总结: 引言 在学习Java过程中,排序sort是我们常用的功能:在Java里,数组有Arrays.sort()可以排序,集合则是Collections.sort()方法排序:默认情况下是升序排列,但是降序又该怎么排?又可以通过哪几种方法呢?自定义类型又该怎么做? 下面就来介绍一下sort方法的使用: 升序 升序是默认情况下的,所以这里就简单展示一下使用的方法: 数组 数

  • 基于js 各种排序方法和sort方法的区别(详解)

    今天突发奇想,想明白sort方法是否比各种排序都有优势,所以就参考别人的代码,做了一个测试,结果令人惊讶啊,上代码. <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width,initial-scale=1.0,max

  • Java 添加Word目录的2种方法示例代码详解

    目录是一种能够快速.有效地帮助读者了解文档或书籍主要内容的方式.在Word中,插入目录首先需要设置相应段落的大纲级别,根据大纲级别来生成目录表.本文中生成目录分2种情况来进行: 1.文档没有设置大纲级别,生成目录前需要手动设置 2.文档已设置大纲级别,通过域代码生成目录 使用工具: •Free Spire.Doc for Java 2.0.0 (免费版) •IntelliJ IDEA 工具获取途径1:通过官网下载jar文件包,解压并导入jar文件到IDEA程序. 工具获取途径2:通过Maven仓

  • PHP排序算法之快速排序(Quick Sort)及其优化算法详解

    本文实例讲述了PHP排序算法之快速排序(Quick Sort)及其优化算法.分享给大家供大家参考,具体如下: 基本思想: 快速排序(Quicksort)是对冒泡排序的一种改进.他的基本思想是:通过一趟排序将待排记录分割成独立的两部分,其中一部分的关键字均比另一部分记录的关键字小,则可分别对这两部分记录继续进行快速排序,整个排序过程可以递归进行,以达到整个序列有序的目的. 基本算法步骤: 举个栗子: 假如现在待排序记录是: 6   2   7   3   8   9 第一步.创建变量 $low 指

  • java数据库开发之JDBC基础使用方法及实例详解

    1.什么是JDBC JDBC是一种用于执行SQL语句的Java API,可以为多种关系数据库提供统一访问,它由一组用Java语言编写的类和接口组成.JDBC提供了一种基准,据此可以构建更高级的工具和接口,使数据库开发人员能够编写数据库应用程序 JDBC 数据库访问规范 应用程序 <-> JDBC <-> MySQL驱动 <-> MySQL                  <-> Oracle驱动 <-> Oracle 导入jar包 加载驱动 C

  • Java实现HashMap排序方法的示例详解

    目录 简介 排序已有数据 按key排序 按value排序 按插入顺序存放 HashMap不按插入顺序存放 LinkedHashMap会按照插入顺序存放 简介 本文用示例介绍HashMap排序的方法. 排序已有数据 按key排序 使用stream进行排序(按key升序/降序) package org.example.a; import java.util.*; public class Demo { public static void main(String[] args) { Map<Stri

  • java 正则,object中两个方法的使用(详解)

    正则: "."和"\" "."点儿,在正则表达式中表示任意一个字符. "\"在正则表达式中是转意字符,当我们需要描述一个已经被正则表达式使用的特殊字符时,我们就可以通过使用"\"将其转变为原本的意思. "\"在正则表达式中也有一些预定义的特殊内容: \d:表示任意一个数字 \w:表示任意一个单词字符(只能是 数字,字母,下划线) \s:表示任意一个空白字符(\t \r \n \f \x0

  • java 中createStatement()方法的实例详解

    java 中createStatement()方法的实例详解 用缺省设置创建时,ResultSet 是一种只能访问一次(one-time-through).只能向前访问(forward-only)和只读的对象.您只能访问数据一次,如果再次需要该 数据,必须重新查询数据库. 然而,并不只有这一种方式.通过设置 Statement 对象上的参数,您可以控制它产生的 ResultSet.例如: ... Class.forName(driverName); db = DriverManager.getC

  • 浅谈java Iterator.remove()方法的用法(详解)

    实例如下: @Test public void tt(){ List<String> list = new ArrayList<String>(); list.add( "0" ); list.add( "1" ); list.add( "2" ); list.add( "3" ); list.add( "4" ); list.add( "5" ); list.a

  • java导出Excel通用方法的实例详解

    java导出Excel通用方法的实例详解 Java导出Excel通用方法,只需要一个list 集合.通用方法改进之处踊跃提出 package oa.common.utils; import java.io.OutputStream; import java.util.List; import javax.servlet.http.HttpServletResponse; import org.apache.struts2.ServletActionContext; import java.lan

随机推荐