java中Comparor与Comparable的问题

1.Comparator中compare()与Comparable中compareTo()方法的区别

  Treeset集合创建对象后,

    A:如果是空构造,即TreeSet<Student> ts = new TreeSet<Student>();  ,那么ts.add();,时需要在Student上implements Comparable<Student>接口,在下面重写compareTo()方法,因为此时的add()调用的是compareTo()方法,底层以红黑二叉树,判断之后,排序

    B:如果是带参构造,即TreeSet<Student> ts = new TreeSet<Student>(Comparator<? super E>comparator); ,ts.add()时,需要自己写个MyComparator类implements Comparator<Student>接口,(如果调用的较少的话,可以在创建对象的时候,以内部类的形式重写方法)或者在在MyComparator中重写compare()方法.

  C:未解决的问题:为什么把

int num = s1.getName().length() - s2.getName().length();(二叉树,左中右顺序)s1与s2换个位置之后,就会倒着排序了,二叉树里,不是大的放在右边吗?而且换个位置之后根节点还是第一个数吗?如果是的话,那么判断的时候数是像哪样呢?
 1 import java.util.Comparator;
 2 import java.util.TreeSet;
 3
 4 /*
 5  * 需求:按照姓名的长度排序
 6  *
 7  * public TreeSet(Comparator<? super E> comparator):构造一个新的空 TreeSet,它根据指定比较器进行排序。
 8  */
 9 public class TreeSetDemo {
10     public static void main(String[] args) {
11         // 创建集合对象
12         // TreeSet<Student> ts = new TreeSet<Student>();
13         // 比较器排序
14         // TreeSet<Student> ts = new TreeSet<Student>(new MyComparator());
15         // 内部类的形式
16         TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
17             @Override
18             public int compare(Student s1, Student s2) {
19                 // 按照姓名的长度排序
20                 int num = s1.getName().length() - s2.getName().length();
21                 // 当姓名的长度相同时,判断姓名是否相等
22                 int num2 = num == 0 ? s1.getName().compareTo(s2.getName())
23                         : num;
24                 // 当姓名相同时,判断年龄是否相等
25                 int num3 = num2 == 0 ? s1.getAge() - s2.getAge() : num2;
26                 return num3;
27             }
28         });
29         // 创建学生对象
30         Student s1 = new Student("小fsd名", 12);
31         Student s2 = new Student("小sdf白", 22);
32         Student s3 = new Student("小sf黑", 33);
33         Student s4 = new Student("小菜", 13);
34         Student s5 = new Student("小黑", 33);
35         Student s6 = new Student("小sdfsdfc", 13);
36         Student s7 = new Student("小dsfsd黑黑", 33);
37         Student s8 = new Student("小sfsd菜", 122);
38         Student s9 = new Student("小黑", 33);
39         Student s10 = new Student("小c", 13);
40
41         // 添加元素
42         ts.add(s1);
43         ts.add(s2);
44         ts.add(s3);
45         ts.add(s4);
46         ts.add(s5);
47         ts.add(s6);
48         ts.add(s7);
49         ts.add(s8);
50         ts.add(s9);
51         ts.add(s10);
52
53         // 遍历元素
54         for (Student s : ts) {
55             System.out.println(s);
56         }
57     }
58 }
 1 import java.util.Comparator;
 2
 3 public class MyComparator implements Comparator<Student> {
 4
 5     @Override
 6     public int compare(Student s1, Student s2) {
 7         // 按照姓名的长度排序
 8         int num = s1.getName().length() - s2.getName().length();
 9         // 当姓名的长度相同时,判断姓名是否相等
10         int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
11         // 当姓名相同时,判断年龄是否相等
12         int num3 = num2 == 0 ? s1.getAge() - s2.getAge() : num2;
13         return num3;
14     }
15
16 }
 1 //或者public class Student implements Comparable
 2 public class Student {
 3     // 姓名
 4     private String name;
 5     // 年龄
 6     private int age;
 7
 8     public Student() {
 9         super();
10     }
11
12     public Student(String name, int age) {
13         super();
14         this.name = name;
15         this.age = age;
16     }
17
18     public String getName() {
19         return name;
20     }
21
22     public void setName(String name) {
23         this.name = name;
24     }
25
26     public int getAge() {
27         return age;
28     }
29
30     public void setAge(int age) {
31         this.age = age;
32     }
33
34     @Override
35     public String toString() {
36         return "Student [name=" + name + ", age=" + age + "]";
37     }
38
39     // @Override
40     // public int compareTo(Student s) {
41     // // 按照姓名的长度排序
42     // int num = this.name.length() - s.name.length();
43     // // 当姓名的长度相同时,判断姓名是否相等
44     // int num2 = num == 0 ? this.getName().compareTo(s.getName()) : num;
45     // // 当姓名相同时,判断年龄是否相等
46     // int num3 = num2 == 0 ? this.getAge() - this.getAge() : num2;
47     // return num3;
48     // }
49 }
时间: 2024-10-08 01:35:41

java中Comparor与Comparable的问题的相关文章

java中Comparator 和 Comparable的区别

1.Comparable的代码如下: public interface Comparable<T> { public int compareTo(T o); } 2.Comparator的代码如下 public interface Comparator<T> { int compare(T o1, T o2); boolean equals(Object obj); // jdk1.8 后的方法 default Comparator<T> reversed() { re

java中的排序Comparable接口和Comparator接口

普通的类要实现排序,必须实现Comparable接口,并重写CompareTo()方法. package test; public class Field implements Comparable<Field> {     private String name;     private int age;     public Field() {     }     public Field(String name, int age) {         this.name = name;

JAVA中Arrays.sort()使用两种方式(Comparable和Comparator接口)对对象或者引用进行排序

一.描述 自定义的类要按照一定的方式进行排序,比如一个Person类要按照年龄进行从小到大排序,比如一个Student类要按照成绩进行由高到低排序. 这里我们采用两种方式,一种是使用Comparable接口:让待排序对象所在的类实现Comparable接口,并重写Comparable接口中的compareTo()方法,缺点是只能按照一种规则排序. 另一种方式是使用Comparator接口:编写多个排序方式类实现Comparator接口,并重写新Comparator接口中的compare()方法,

Java中Comparable和Comparator实现对象比较

1.通过Comparable实现排序 package Comparable; import java.util.Arrays; public class ComparableUser implements Comparable<ComparableUser> { private String id; private int age; public ComparableUser(String id, int age) { this.id = id; this.age = age; } publi

java中Comparable实现对象的比较

/* class A implements Comaprable<A>{ } 那么 A x = new A(); 类关系图 Object o = A; Object Comparable c = A; | Comparable A 实现了 Comparable 接口嘛 |-----|-----A 所以有 o instanceof A == true; o instanceof Comparable == true; 例如ArrayList添加对象实例时,对象实例添加之后先向上转型为Object

Java中Comparable和Comparator区别小结

一.Comparable简介 Comparable是排序接口.若一个类实现了Comparable接口,就意味着该类支持排序.实现了Comparable接口的类的对象的列表或数组可以通过Collections.sort或Arrays.sort进行自动排序. 此外,实现此接口的对象可以用作有序映射中的键或有序集合中的集合,无需指定比较器.该接口定义如下: package java.lang; import java.util.*; public interface Comparable<T> {

java中Comparable 和Comparator

java中Comparable 和Comparator -Comparable接口 接口定义 public interface Comparable<T> { public int compareTo(T o); } 该接口中仅仅包含了一个compareTO()函数, int compareTo(Object o): 比较当前实例对象与对象o,如果位于对象o之前,返回负值,如果两个对象在排序中位置相同,则返回0,如果位于对象o后面,则返回正值. 实例: x.compareTo(y) 来&quo

Java中Comparable与Comparator的区别

相同 Comparable和Comparator都是用来实现对象的比较.排序 要想对象比较.排序,都需要实现Comparable或Comparator接口 Comparable和Comparator都是Java的接口 区别 Comparator位于java.util包下,而Comparable位于java.lang包下 Comparable接口的实现是在类的内部(如 String.Integer已经实现了Comparable接口,自己就可以完成比较大小操作),Comparator接口的实现是在类

Java 中 Comparable 和 Comparator 比较

本文,先介绍Comparable 和Comparator两个接口,以及它们的差异:接着,通过示例,对它们的使用方法进行说明. Comparable 简介 Comparable 是排序接口. 若一个类实现了Comparable接口,就意味着"该类支持排序".  即然实现Comparable接口的类支持排序,假设现在存在"实现Comparable接口的类的对象的List列表(或数组)",则该List列表(或数组)可以通过 Collections.sort(或 Array