Java排序专题

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
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
好的,我可以为您提供一些 Java 接口练习题,供您练习和巩固相关知识。以下是一些题目: 1. 定义一个接口 Animal,包含方法 eat() 和 sleep(),同时定义一个实现该接口的类 Dog 和 Cat。要求 Dog 和 Cat 实现 eat() 和 sleep() 方法,其中 eat() 方法输出 "I am a dog/cat, and I am eating",sleep() 方法输出 "I am a dog/cat, and I am sleeping"。 2. 定义一个接口 Shape,包含方法 getArea() 和 getPerimeter(),同时定义一个实现该接口的类 Rectangle 和 Circle。要求 Rectangle 和 Circle 实现 getArea() 和 getPerimeter() 方法,其中 getArea() 方法返回形状的面积,getPerimeter() 方法返回形状的周长。 3. 定义一个接口 Calculator,包含方法 add()、subtract()、multiply() 和 divide(),同时定义一个实现该接口的类 BasicCalculator 和 ScientificCalculator。要求 BasicCalculator 和 ScientificCalculator 实现 add()、subtract()、multiply() 和 divide() 方法,其中 BasicCalculator 实现的方法为简单的四则运算,ScientificCalculator 实现的方法为科学计算器常用的函数,例如 sin、cos、tan 等。 4. 定义一个接口 Sortable,包含方法 sort(),同时定义一个实现该接口的类 BubbleSort 和 QuickSort。要求 BubbleSort 和 QuickSort 实现 sort() 方法,其中 BubbleSort 实现冒泡排序,QuickSort 实现快速排序。 希望这些题目能够帮助您巩固 Java 接口的相关知识。如果您有任何问题或需要更多帮助,请随时告诉我。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值