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