Java排序专题

已于 2023-01-14 12:35:46 修改
阅读量268 收藏 1
点赞数
分类专栏： # Java专题 文章标签： java
于 2023-01-03 23:52:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/littleNerd/article/details/128540804
版权

Java排序专题

1 compare()方法&compareTo()方法

1.1 包装类的compare()方法

  • 包装类都有compare()方法，是静态方法，用包装类名.compare(参数1，参数2)调用

1.1.1 Integer的compare()方法

  • Integer类的compare(int x，int y)方法的源码实现如下
public static int compare(int x, int y) {
   
	return (x < y) ? -1 : ((x == y) ? 0 : 1);
}
  • 使用示例
    • 参数1>参数2，返回1
    • 参数1<参数2，返回-1
    • 参数1=参数2，返回0
System.out.println(Integer.compare(1, 3)); // -1
System.out.println(Integer.compare(3, 3)); // 0
System.out.println(Integer.compare(5, 3)); // 1

1.1.2 Long的compare()方法

  • Long类的compare(long x，long y)方法的源码实现如下
public static int compare(long x, long y) {
   
	return (x < y) ? -1 : ((x == y) ? 0 : 1);
}
  • 使用示例
System.out.println(Long.compare(23L, 34L)); // -1
System.out.println(Long.compare(69L, 34L)); // 1
System.out.println(Long.compare(34L, 34L)); // 0

1.1.3 Double的compare()方法

  • Double类型也有compare(double x, double y)方法
  • 使用示例
System.out.println(Double.compare(110.2d, 23.3d)); // 1
System.out.println(Double.compare(6.3d, 23.4d)); // -1
System.out.println(Double.compare(23.4d, 23.4d)); // 0

1.1.4 Float的compare()方法

  • Float类型也有compare(float x, float y)方法
  • 使用示例
System.out.println(Float.compare(18.2f, 9.3f)); // 1
System.out.println(Float.compare(4.8f, 9.3f)); // -1
System.out.println(Float.compare(9.3f, 9.3f)); // 0

1.2 包装类的compareTo()方法

  • 包装类的compareTo()方法是非静态方法，要用包装类对象.compareTo(参数)

1.2.1 Integer的compareTo()方法

  • Integer的compareTo()方法在实现的时候，调用了Integer的静态方法compare()，源码如下
public int compareTo(Integer anotherInteger) {
   
	return compare(this.value, anotherInteger.value);
}
  • 使用示例
Integer a = 50;
System.out.println(a.compareTo(10)); // 1
System.out.println(a.compareTo(50)); // 0
System.out.println(a.compareTo(70)); // -1

1.2.2 Long的compareTo()方法

  • Long类型的compareTo()方法的实现，调用了Long类的静态方法compare()，源码如下
public int compareTo(Long anotherLong) {
   
	return compare(this.value, anotherLong.value);
}
  • 使用示例
Integer b = 1500L;
System.out.println(b.compareTo(1000L)); // 1
System.out.println(a.compareTo(1500L)); // 0
System.out.println(a.compareTo(7000L)); // -1

1.2.3 Double的compareTo()方法

  • Double类型的compareTo()方法的实现，调用了Double类的静态方法compare(),源码如下
public int compareTo(Double anotherDouble) {
   
	return Double.compare(this.value, anotherDouble.value);
}
  • 使用示例
Integer c = 66.8d;
System.out.println(c.compareTo(36.5d)); // 1
System.out.println(c.compareTo(66.8d)); // 0
System.out.println(a.compareTo(93.2d)); // -1

1.2.4 Float的compareTo()方法

  • Float的compareTo()方法的实现，调用了Float的静态方法compare(),源码如下
public int compareTo(Float anotherFloat) {
   
	return Float.compare(this.value, anotherFloat.value);
}
  • 使用示例
Float d = 187.2f;
System.out.println(d.compareTo(187.2f)); // 0
System.out.println(d.compareTo(96.2f)); // 1
System.out.println(d.compareTo(231.6f)); // -1

1.3 String的compareTo()方法

  • String类有compareTo()方法，没有compare()方法
  • String类的compareTo()方法，按照字典序比较字符串，是非静态方法，调用str1.compareTo(str2)
  • 比较规则
    • 比较规则1:如果两个字符串不一样长，但是对应位置的字符是一样的，返回str1长度-str2长度的差，示例如下
String str = "TomJerry";
System.out.println(str.compareTo("Tom")); // 5
System.out.println(str.compareTo("TomJerry")); // 0
System.out.println(str.compareTo("TomJerryDog")); // -3
    • 比较规则2:如果str1与str2在某个位置有不同的字符，则返回这两个字符ASCII码值的差，示例如下
String str = "gdwes";
System.out.println(str.compareTo("acs")); // 6, 比较第一个字符，发现g与a不相同,所以用g的ASCII码值 - a的ASCII码值，得到6
System.out.println(str.compareTo("gfs")); // -2, 比较第一个字符，相同，然后比较第二个字符，发现d与f不同，所以用d的ASCII码值 - f的ASCII码值,得到-2

2 对象的单属性排序

对象的单属性排序，常见的方式有这几种

  • 使用list.sort()方法排序
  • 使用list.stream().sorted()方法排序
  • 使用Collections.sort()方法排序
  • 使用Arrays.sort()方法排序

下面要使用的Person类

class Person{
   
	private String name;
	private int age;
	private long score;
	public Person(String name, int age, long score){
   
		this.name = name;
		this.age = age;
		this.score = score;
	}
	// 这里重写了toString()方法
	@Override
	public String toString() {
   	
		return "Person{" + "name='" + name + '\'' + ",age=" + age + ", score=" + score + '}';
	}	
}

2.1 排序方式1:使用list.sort()方法排序

2.1.1 list.sort()里使用lambda表达式

2.1.1.1 比较对象的int属性

方式1.使用Integer的compareTo()方法

  • 错误示例
    • 这样写有问题，因为compareTo(Integer anotherInteger)方法要用Integer类调用，但是o1.getAge()是int，所以会报错
public static void main(String[] args) {
   
	Person p1 = new Person("Tom", 10, 90L);
	Person p2 = new Person("Jerry", 9, 95L);
	Person p3 = new Person("Dog", 11, 80L);
	Person p4 = new Person("Cat", 7, 85L);
	Person p5 = new Person("Bird", 8, 100L);
	List<Person> list = Arrays.asList(p1,p2,p3,p4,p5);

	list.sort((o1,o2) -> o1.getAge().compareTo(o2.getAge()));	// 这里的compareTo()会报错
	System.out.println(list);
}
  • 正确示例
    • 把o1.getAge()转成Integer，然后再调用compareTo()方法
    • 按照age属性（int类型）进行排序
public static void main(String[] args) {
   
	Person p1 = new Person("Tom", 10, 90L);
	Person p2 = new Person("Jerry", 9, 95L);
	Person p3 = new Person("Dog", 11, 80L);
	Person p4 = new Person("Cat", 7, 85L);
	Person p5 = new Person("Bird", 8, 100L);
	List<Person> list = Arrays.asList(p1,p2,p3,p4,p5);

	list.sort((o1,o2) -> Integer.valueOf(o1.getAge()).compareTo(o2.getAge()));
	System.out.println(list);
}

打印出来如下，是按照age属性(int类型)进行排序的
Person{name=‘Cat’，age=7，score=85}，Person{name=‘Bird’，age=8，score=100}，Person{name=‘Jerry’，age=9，score=95}，Person{name=‘Tom’，age=10，score=90}，
Person{name=‘Dog’，age=11，score=80}

方式2.使用Integer的compare()方法

public static void main(String[] args) {
   
	Person p1 = new Person("Tom", 10, 90L);
	Person p2 = new Person("Jerry", 9, 95L);
	Person p3 = new Person("Dog", 11, 80L);
	Person p4 = new Person("Cat", 7, 85L);
	Person p5 = new Person("Bird", 8, 100L);
	List<Person> list = Arrays.asList(p1,p2,p3,p4,p5);

	list.sort((o1,o2) -> Integer.compare(o1.getAge(), o2.getAge()));
	System.out.println(list);
}

打印出来如下，此时是按照age属性（int类型）进行排序的
Person{name=‘Cat’，age=7，score=85}，Person{name=‘Bird’，age=8，score=100}，Person{name=‘Jerry’，age=9，score=95}，Person{name=‘Tom’，age=10，score=90}，
Person{name=‘Dog’，age=11，score=80}

2.1.1.2 比较对象的long属性

方式1.使用Long类的compareTo()方法
错误示例

  • 使用o1.getScore()调用compareTo()会报错，因为o1.getScore()是long基本类型，不是Long包装类型，所以要把o1.getScore()转成Long类型
public static void main(String[] args) {
   
	Person p1 = new Person("Tom", 10, 90L);
	Person p2 = new Person("Jerry", 9, 95L);
	Person p3 = new Person("Dog", 11, 80L);
	Person p4 = new Person("Cat", 7, 85L);
	Person p5 = new Person("Bird", 8, 100L);
	List<Person> list = Arrays.asList(p1,p2,p3,p4,p5);

	list.sort((o1,o2) -> o1.getScore().compareTo(o2.getScore())); // compareTo()会报错
	System.out.println(list);
}

正确示例

  • 将o1.getScore()转成Long包装类，再调用compareTo()方法
  • 按照score属性（long类型）进行排序
public static void main(String[] args) {
   
	Person p1 = new Person("Tom", 10, 90L);
	Person p2 = new Person("Jerry", 9, 95L);
	Person p3 = new Person("Dog", 11, 80L);
	Person p4 = new Person("Cat", 7, 85L);
	Person p5 = new Person("Bird", 8, 100L);
	List<Person> list = Arrays.asList(p1,p2,p3,p4,p5);

	list.sort((o1,o2) -> Long.valueOf(o1.getScore()).compareTo(o2.getScore()));
	System.out.println(list);
}

打印结果如下，按照score属性(long类型)进行的排序
Person{name=‘Dog’，age=11，score=80}，Person{name=‘Cat’，age=7，score=85}，
Person{name=‘Tom’，age=10，score=90}，Person{name=‘Jerry’，age=9，score=95}，Person{name=‘Bird’，age=8，score=100}

方式2.使用Long包装类的compare()方法

public static void main(String[] args) {
   
	Person p1 = new Person("Tom", 10, 90L);
	Person p2 = new Person("Jerry", 9, 95L);
	Person p3 = new Person("Dog", 11, 80L);
	Person p4 = new Person("Cat", 7, 85L);
	Person p5 = new Person("Bird", 8, 100L);
	List<Person> list = Arrays.asList(p1,p2,p3,p4,p5);

	list.sort((o1,o2) -> Long.compare(o1.getScore(), o2.getScore()));
	System.out.println(list);
}

打印结果如下，此时按照score属性（long类型）进行排序的
Person{name=‘Dog’，age=11，score=80}，Person{name=‘Cat’，age=7，score=85}，
Person{name=‘Tom’，age=10，score=90}，Person{name=‘Jerry’，age=9，score=95}，Person{name=‘Bird’，age=8，score=100}

2.1.1.3 比较对象的String属性
  • 使用String类的compareTo()方法进行排序
public static void main(String[] args) {
   
	Person p1 = new Person("Tom", 10, 90L);
	Person p2 = new Person("Jerry", 9, 95L);
	Person p3 = new Person("Dog", 11, 80L);
	Person p4 = new Person("Cat", 7, 85L);
	Person p5 = new Person("Bird", 8, 100L);
	List<Person> list = Arrays.asList(p1,p2,p3,p4,p5);

	list.sort((o1,o2) -> o1.getName().compareTo(o2.getName()));
	System.out.println(list);
}

打印出来结果如下，按照name属性(String类型)进行排序的
Person{name=‘Bird’，age=8，score=100}，Person{name=‘Cat’，age=7，score=85}
Person{name=‘Dog’，age=11，score=80}，Person{name=‘Jerry’，age=9，score=95}，
Person{name=‘Tom’，age=10，score=90}

2.1.2 list.sort()里使用Comparator比较器

  • Comparator.comparing()方法可以接收一个参数，也可以接收两个参数，返回一个比较器
    • 只接收一个参数的情况，接收一个函数作为参数，
      Comparator comparatorInstance = Comparator.comparing(Person::getAge) ；
    • 接收两个参数的情况，接收一个函数和一个比较器方法作为参数，
      Comparator comparatorInstance = Comparator.comparing(Person::getAge，(age1,age2) -> Integer.compare(age1, age2))；
2.1.2.1 比较对象的int属性
2.1.2.1.1 比较器中使用方法引用

方式1Comparator.comparing()传入一个参数，按照age的升序排序

public static void main(String[] args) {
   
	Person p1 = new Person("Tom", 10, 90L);
	Person p2 = new Person("Jerry", 9, 95L);
	Person p3 = new Person("Dog", 11, 80L);
	Person p4 = new Person("Cat", 7, 85L);
	Person p5 = new Person("Bird", 8, 100L);
	List<Person> list = Arrays.asList(p1,p2,p3,p4,p5);
	// 用Comparator.comparing()返回一个比较器
	Comparator<Person> comparatorInstance = Comparator.comparing(Person::getAge);
	// 在list.sort()里传入比较器对象
	list.sort(comparatorInstance);
	System.out.println(list);
}

打印出来结果如下，按照age属性(int类型)进行升序排序的
Person{name=‘Cat’，age=7，score=85}，Person{name=‘Bird’，age=8，score=100}，
Person{name=‘Jerry’，age=9，score=95}，Person{name=‘Tom’，age=10，score=90}，Person{name=‘Dog’，age=11，score=80}

方式2

  • Comparator.comparing()传两个参数，第一个参数是函数，第二个参数是比较器方法，按照age属性的升序排序
public static void main(String[] args) {
   
	Person p1 = new Person("Tom", 10, 90L);
	Person p2 = new Person("Jerry", 9, 95L);
	Person p3 = new Person("Dog", 11, 80L);
	Person p4 = new Person("Cat", 7, 85L);
	Person p5 = new Person("Bird", 8, 100L);
	List<Person> list = Arrays.asList(p1,p2,p3,p4,p5);
	// 用Comparator.comparing()返回一个比较器
	Comparator<Person> comparatorInstance = Comparator.comparing(Person::getAge,(age1, age2) -> Integer.compare(age1, age2));
	// 在list.sort()里传入比较器对象
	list.sort(comparatorInstance);
	System.out.println(list);
}

打印出来结果如下，按照age属性(int类型)进行升序排序的
Person{name=‘Cat’，age=7，score=85}，Person{name=‘Bird’，age=8，score=100}，
Person{name=‘Jerry’，age=9，score=95}，Person{name=‘Tom’，age=10，score=90}，Person{name=‘Dog’，age=11，score=80}

  • Comparator.comparing()传两个参数，第一个参数是函数，第二个参数是比较器方法，age1和age2交换了顺序，按照age属性的降序排序
public static void main(String[] args) {
   
	Person p1 = new Person("Tom", 10, 90L);
	Person p2 = new Person("Jerry", 9, 95L);
	Person p3 = new Person("Dog", 11, 80L);
	Person p4 = new Person("Cat", 7, 85L);
	Person p5 = new Person("Bird", 8, 100L);
	List<Person> list = Arrays.asList(p1,p2,p3,p4,p5);
	// 用Comparator.comparing()返回一个比较器
	Comparator<Person> comparatorInstance = Comparator.comparing(Person::getAge,(age1, age2) -> Integer.compare(age2, age1));
	// 在list.sort()里传入比较器对象
	list.sort(comparatorInstance
最低0.47元/天 解锁文章
佛之战国
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java comparator 降序排序_【转】java comparator 升序、降序、倒序从源码角度理解
weixin_39733805的博客
02-16 401
原文链接：https://blog.csdn.net/u013066244/article/details/78997869环境jdk:1.7+前言之前我写过关于comparator的理解，但是都理解错了。java 自定义排序【Comparator升序降序的记法】特别是 上面这篇，完全理解错了，排序的真正的意思。最近通过查看源码，打断点的方式，一步步的查看、演算。算是明白了！当时我心里的疑惑是：①...
Java：Integer中的compare与compareTo
超级马里奥 的博客
11-09 2451
Java：Integer中的compare与compareTo 首先我们先来查看一波jgk1.8： 1.compareTo compareTo(Object o)方法是java.lang.Comparable<T>接口的方法； 重写compareTo方法，进行自然排序（aka整体排序、内部排序）：Collections.sort(), Array.sort()；这些排序方法默认的是升序的 实现了这个接口的的对象，就有了排序的功能，所以叫comparable--可排序的； co..
Java比较器排序
刘程云的博客
12-02 1235
在Java中对基本类型进行排序可以通过Array.sort()和Collections.sort()，默认是升序 在Java中对对象进行排序可以通过Compare和CompareTo，并且也可以对基本数据类型进行排序
Long类型比较相等问题
热门推荐
zhsh5395的专栏
06-08 3万+
一、问题描述开发过程中遇到如下问题Long a = 100L; Long b = 100L; System.out.println(a == b); System.out.println(a.equals(b)); System.out.println(a == 100); System.out.println(a.equals(100));输出结果：truetruetruefalse但是当Lon...
javaSE基础全覆盖
小白的进化路
07-26 239
面向对象 概念： 面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做。 面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。 类：对一类事物的描述，是抽象的、概念上的定义 对象：是实际存在的该类事物的每个个体，因而也称为实例(instance) 对象是由类new出来的，派生出来的。 属性 = 成员变量 = field = 域、字段 方法 = 成员方法 = 函数 = method 创建类的对象 = 类的实例化 = 实例化类 如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属
Integer的相关函数
weixin_47655735的博客
11-11 2094
一，int和integer的区别 int是Java的基本类而Integer是Java的包装类； int的声明不需要实例化而Integer的声明需要； int默认值为0，Integer的默认值为null； 二，Integer.valueOf(String s) 返回Integer 将字符串转化为Integer||int； 三，Integer.valueOf（int x）返回Integer public static Integer valueOf(int i) { a.
Java算法练习-双栈排序练习题
10-01
[Java]算法练习-双栈排序练习题
Java 选择排序 算法
07-21
Java选择排序算法是一种简单直观的排序算法，它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。这种算法对列表中的数据进行了一次完整...
Java 条件语句练习题.docx
01-14
这些题目涵盖了Java编程中的基本条件语句，包括if-else语句、三元运算符以及嵌套条件。...以上就是所有练习题的Java代码实现，这些题目可以帮助初学者掌握Java中的条件语句和逻辑控制，对于提高编程技能非常有帮助。
Java排序算法之归并排序简单实现
08-28
"Java排序算法之归并排序简单实现" Java排序算法中的归并排序是一种高效的排序算法，它的平均时间复杂度、最好时间复杂度和最坏时间复杂度均为O(nlogn)，空间复杂度为O(n)，是一种稳定的排序算法。下面是对归并...
Java练习算法代码(排序，数据结构，小算法练习题).zip
最新发布
01-14
Java是一种高性能、跨平台的面向对象编程语言。它由Sun Microsystems（现在是Oracle Corporation）的James Gosling等人在1995年推出，被设计为一种简单、健壮、可移植、多线程、动态的语言。Java的主要特点和优势...
java compareto long_Java long compareTo()用法及代码示例
weixin_35779370的博客
02-23 593
java.lang.Long.compareTo()是java中的内置方法，该方法以数字方式比较两个Long对象。如果此对象等于自变量对象，则此方法返回0；如果此对象在数值上小于自变量对象，则返回小于0；如果此对象在数值上大于自变量对象，则返回大于0的值。用法:public int compareTo(Object obj)Parameter:obj -The object which is to...
Java Long类的compareTo（）方法与示例
cumtb2009的博客
07-13 5830
长类compareTo()方法 (Long class compareTo() method) compareTo() method is available in java.lang package. compareTo()方法在java.lang包中可用。 compareTo() method is used to check equality or inequality for thi...
表格存储数据模型和查询操作
weixin_33726313的博客
05-05 653
摘要 本篇文章主要会详细聊一下表格存储的查询操作，以及如何根据业务的需求来设计表结构以支持特定条件的查询。 在理解查询操作之前，会简单描述一下表格存储的数据模型，以加深对查询操作的理解。 数据模型 表格存储（TableStore）的数据模型可以简化为使用下面这个数据结构来表示： 表格存储数据模型： SortedMap<...
Java常用类库学习总结
qq_51553982的博客
08-02 842
常用类库 包装类 Java中不能定义基本数据类型的对象，为了能将基本数据类型当作对象处理，包装类由此诞生！ 概念： 将基本数据类型封装在包装类中,以便把这些基本数据类型转换为对象进行处理 包装类以及所对应的基本数据类型： 包装类 对应基本数据类型 Byte byte Integer int Float float Character char Short short Long long Double double Boolean boolean 1.Inte
java integer集合排序_Java集合排序
weixin_34222309的博客
02-24 578
Java API针对集合类型排序提供了两种支持：java.util.Collections.sort(java.util.List)java.util.Collections.sort(java.util.List, java.util.Comparator)第一个方法要求所排序的元素类必须实现java.lang.Comparable接口。第二个方法要求实现一个java.util.Comparat...
包装类及常用方法简介
慕白博客
08-24 4688
包装类及常用方法简介 JAVA 是一种面向对象语言，JAVA 中的类把方法与数据连接在一起，构成 了自包含式的处理单元。但在 JAVA 中不能定义基本类型（primitive type)对象， 为了能将基本类型视为对象进行处理，并能连接相关的方法，JAVA 为每个基本 类型都提供了包装类。如 int 型数值的包装类 Integer，boolean 型数值的包装 类 Boolean 等，这样...
包装类都自包含compareTo()方法
weixin_34293246的博客
03-26 352
一、包装类都自包含compareTo(）方法，可以直接使用，例：a.compareTo(b) 如果返回值0，表示相等。如果返回值为1，说明a>b，如果返回值为-1，说明a<b;举例：package code1200_96;/*** @author Administrator* 每一个包装类都有一个comareTo()方法。并且重写了Object的equals(...
compare()方法+使用compare方法
zhou920786312的博客
06-03 2万+
compare()方法 compare(lob1,lob2,amount,offset_1,offset_2) 1用于比较2个lob存储的数据，比较的方式是从指定偏移量开始，对指定数量的字符或者字节进行比较。 2如果比较内容相同，返回0，否则返回-1或1. 3如果参数设置有误或不合理，返回null 4改方法的使用语法如下语法1（BLOB/BFILE） dbms_lob.compare(
JAVA基础编程练习题集锦
Java编程题 本资源摘要信息是关于Java编程题的知识点总结，涵盖了Java基础知识、算法设计、数据结构、面向对象编程等方面的知识点。 **知识点1: 古典问题 - 兔子繁殖问题** 该问题是 Java 编程题中的一道经典题目...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值