当使用具有可比性和比较当使用具有可比性和比较(When to use Comparable and

2019-06-17 10:00发布

站内文章 / 移动开发
45 0 0

我有我需要排序字段对象的列表，说分数。 没有过多考虑我写了一个实现比较，这并不任务和它的作品的新类。

现在回头看这个，我想知道如果我应该有，而不是有我的类实现可比，而不是创建一个实现比较新类。 比分是这些对象将被责令上的唯一领域。

  1. 我所做的可以接受的做法？

  2. 是正确的方法“先有类实现可比（自然排序），如果没有需要其他领域的比较，然后创建一个实现比较新阶级”？

  3. 如果上述（2）是真的，那么岂不是一个应该实现比较后，才类实现可比？ （假设我自己原来的类）。

Answer 1:

我要说的是，一个对象应该实现可比如果是这样排序的类的清晰自然的方式，任何人都需要整理通常会想要做这样的类。

但是，如果排序是一个不寻常的使用之类的，或者排序才有意义，用于特定用途的情况下，则比较是一个更好的选择。

换句话说，给出的类名，是明确如何可比会进行排序，或者你不得不求助于阅读的javadoc？ 如果是后者，赔率是未来每一分拣用例将需要一个比较，在这点可比的实现可能的类的用户放慢，而不是加速它们。



Answer 2:

使用Comparable如果要定义一个默认的 （天然）排序问题的对象的行为，常见的做法是使用的技术或自然（数据库？）的对象标识符这一点。

使用Comparator如果要定义一个外部可控有序的行为，这可以覆盖默认排序行为。



Answer 3:

使用Comparable ：

  • 如果对象是在你的控制。
  • 如果比较的行为是主要的比较行为。

使用Comparator ：

  • 如果对象是你无法控制的，你不能让他们实现Comparable 。
  • 当你想比较的行为从默认的（这是由指定的不同的Comparable行为）。


Answer 4:

可比 - java.lang.Comparable: int compareTo(Object o1)

可比较的对象能够本身与另一个对象比较。 该类本身必须实现，以便在java.lang.Comparable的接口，能够比较它的实例。

  • 能够当前对象与所提供的对象的比较。
  • 利用这一点，我们可以实现only one sort sequence基于实例的属性。 EX： Person.id
  • 一些预定义类如String，包装类，日期，日历已经实现Comparable接口。

比较 - java.util.Comparator: int compare(Object o1, Object o2)

比较器对象能够比较两个不同的对象。 这个类不是比较它的实例，但一些其他类的实例。 这种比较的类必须实现的java.util.Comparator接口。

  • 能够比较相同类型的任意两个对象。
  • 利用这一点，我们可以实现many sort sequence和名称各基础上，实例的属性。 EX： Person.id, Person.name, Person.age
  • 我们可以实现比较接口，我们预先定义的类定制的排序。

例： 

public class Employee implements Comparable<Employee> {

    private int id;
    private String name;
    private int age;
    private long salary;

    // Many sort sequences can be created with different names.
    public static Comparator<Employee> NameComparator = new Comparator<Employee>() {         
        @Override
        public int compare(Employee e1, Employee e2) {
            return e1.getName().compareTo(e2.getName());
        }
    };
    public static Comparator<Employee> idComparator = new Comparator<Employee>() {       
        @Override
        public int compare(Employee e1, Employee e2) {
            return Integer.valueOf(e1.getId()).compareTo(Integer.valueOf(e2.getId()));
        }
    };

    public Employee() { }
    public Employee(int id, String name, int age, long salary){
        this.id = id;
        this.name = name;
        this.age = age;
        this.salary = salary;
    }
    // setters and getters.

    // Only one sort sequence can be created with in the class.
    @Override
    public int compareTo(Employee e) {
    //return Integer.valueOf(this.id).compareTo(Integer.valueOf(e.id));
    //return Character.toString(this.name.charAt(0)).compareToIgnoreCase(Character.toString(e.name.charAt(0)));
        if (this.id > e.id) {
            return 1;
        }else if(this.id < e.id){
            return -1;
        }else {
            return Character.toString(this.name.charAt(0)).compareToIgnoreCase(Character.toString(e.name.charAt(0)));
        }

    }   

    public static void main(String[] args) {

        Employee e1 = new Employee(5, "Yash", 22, 1000);
        Employee e2 = new Employee(8, "Tharun", 24, 25000);

        List<Employee> list = new ArrayList<Employee>();
        list.add(e1);
        list.add(e2);
        Collections.sort(list); // call @compareTo(o1)
        Collections.sort(list, Employee.nameComparator); // call @compare (o1,o2)
        Collections.sort(list, Employee.idComparator); // call @compare (o1,o2)
    }
}
  • 对于定制的排序，我们去比较@compare（O1，O2），因为我们去媲美@compareTo（01）其他情况下，用了更改代码，如果我们想排序多个字段，然后我们用比较。

对于Java的8 LAMBDA：比较参考我的文章。



Answer 5:

当你比较相同类的实例可比应该被使用。

比较器可用于比较不同类的实例。

可比由类需要定义一个自然排序为它的对象实现。 如String实现媲美。

如果一个人想不同的排序顺序，然后他就可以实现比较和定义自己比较两个实例的方式。



Answer 6:

比较的任何事相媲美呢，加上更多。

| | Comparable | Comparator ._______________________________________________________________________________ Is used to allow Collections.sort to work | yes | yes Can compare multiple fields | yes | yes Lives inside the class you’re comparing and serves | | as a “default” way to compare | yes | yes Can live outside the class you’re comparing | no | yes Can have multiple instances with different method names | no | yes Input arguments can be a list of | just Object| Any type Can use enums | no | yes

我发现，使用比较匿名类的最佳方法如下： 

private static void sortAccountsByPriority(List<AccountRecord> accounts) {
    Collections.sort(accounts, new Comparator<AccountRecord>() {

        @Override
        public int compare(AccountRecord a1, AccountRecord a2) {
            return a1.getRank().compareTo(a2.getRank());
        }
    });
}

你可以对你打算排序类中创建这些方法多个版本。 所以，你可以有：

  • sortAccountsByPriority
  • sortAccountsByType

  • sortAccountsByPriorityAndType

    等等...

现在，你可以在任何地方使用这些类型的方法，并得到代码重用。 这给了我一切会相媲美，加上更多...所以我看不出有任何理由使用可比的。



Answer 7:

我会说：

  • 如果比较直观，然后通过各种手段实现可比
  • 如果不清楚你阉比较直观，使用比较，因为它是更加明确，从而更清晰的可怜的人谁也维护代码
  • 如果有不止一个直观的比较可能我宁愿一个比较，可能是在类工厂方法建立进行比较。
  • 如果比较特殊用途，使用比较


Answer 8:

  • 如果在编写类的时刻，你必须使用排序可比的只有一个用例。
  • 只有当你有排序实现一个比较器的一个以上的战略。


Answer 9:

以下几点帮助您决定在哪些情况下应该使用比较的，其中比较：

1）代码房态

2）单与多分类标准

3）Arays.sort（）和Collection.sort（）

4）正如在的SortedMap和SortedSet的键

5）更多的类对战灵活性数

6）类间comparisions

7）自然顺序

如需更详细的文章，你可以参考何时使用可比以及何时使用比较



Answer 10:

如果对象的排序需要基于对自然顺序，然后使用相媲美，而如果你整理需要在不同对象的属性做了，那么在Java中使用比较。

可比和比较的主要区别： 

+------------------------------------------------------------------------------------+
¦               Comparable                ¦                Comparator                ¦
¦-----------------------------------------+------------------------------------------¦
¦ java.lang.Comparable                    ¦ java.util.Comparator                     ¦
¦-----------------------------------------+------------------------------------------¦
¦ int objOne.compareTo(objTwo)            ¦ int compareTo(objOne, objTwo)            ¦
¦-----------------------------------------+------------------------------------------¦
¦ Negative, if objOne < objTwo            ¦ Same as Comparable                       ¦
¦ Zero,  if objOne == objTwo              ¦                                          ¦
¦ Positive,  if objOne > objTwo           ¦                                          ¦
¦-----------------------------------------+------------------------------------------¦
¦ You must modify the clas whose          ¦ You build a class separate from to sort. ¦
¦ instances you want to sort.             ¦ the class whose instances you want       ¦
¦-----------------------------------------+------------------------------------------¦
¦ Only one sort sequemce can be created   ¦ Many sort sequences can be created       ¦
¦-----------------------------------------+------------------------------------------¦
¦ Implemented frequently in the API by:   ¦ Meant to be implemented to sort          ¦
¦ String, Wrapper classes, Date, Calandar ¦ instances of third-party classes.        ¦
+------------------------------------------------------------------------------------+


Answer 11:

曾出现过类似的问题在这里： 一个类时，应与和/或比较？

我下面会说：这样的事情自然排序，例如基于内部ID实现可比

实现一个比较，如果你有更复杂的算法进行比较，如多个字段等等。



Answer 12:

如果您需要的自然顺序排序 - 用户可比如果你需要自定义顺序排序 - 使用比较

例： 

Class Employee{
private int id;
private String name;
private String department;
}

自然顺序排序将基于ID，因为这将是独一无二的，客户订单sortin摹将姓名和部门。

Refrences：
一个类时，应与和/或比较？ http://javarevisited.blogspot.com/2011/06/comparator-and-comparable-in-java.html



Answer 13:

可比：
每当我们想只存储同质元素和默认所需的自然排序顺序，我们可以去实现类comparable接口。

比较：
每当我们想存储同质和异质元素，我们希望在默认定制的排序顺序排序，我们可以去comparator接口。



Answer 14:

我需要为排序依据的日期。

所以，我用比较的，它很容易为我工作。 

public int compareTo(GoogleCalendarBean o) {
    // TODO Auto-generated method stub
    return eventdate.compareTo(o.getEventdate());
}

具有可比性的一个限制是他们不能用于除列表中的其他集合。



Answer 15:

如果你拥有类相媲美最好去。 一般来说，如果你没有自己的类，但你必须使用一个TreeSet或TreeMap的 ，因为比较可以在TreeSet中或树形图conctructor一个参数传递比较使用。 你可以看到如何使用比较器和可比在http://preciselyconcise.com/java/collections/g_comparator.php



Answer 16:

我一直在问数的一定范围内的排序中比在接受采访时的一个nlogn时间更好。 （不使用计数排序）

实施在一个对象可比接口允许隐式排序交易算法使用重写compareTo方法来进行排序的元素，这将是线性时间。



Answer 17:

可比是提供了一种用于数值上升和用于字符串的缺省自然排序顺序字母顺序排列。 对于例如： 

Treeset t=new Treeset();
t.add(2);
t.add(1);
System.out.println(t);//[1,2]

比较器是通过重写用于例如比较方法在自定义myComparator类实现的自定义排序顺序： 

Treeset t=new Treeset(new myComparator());
t.add(55);
t.add(56);
class myComparator implements Comparator{
public int compare(Object o1,Object o2){
//Descending Logic
}
}
System.out.println(t);//[56,55]


Answer 18:

很简单的方法是假设有问题的实体类的数据库来表现，然后在数据库中的表，你会需要由实体类的字段的指数？ 如果答案为是，则执行相媲美，并使用索引字段（个），自然排序顺序。 在其他情况下使用比较。



Answer 19:

我对实现标注LIB Comparable和Comparator ： 

public class Person implements Comparable<Person> {         
    private String firstName;  
    private String lastName;         
    private int age;         
    private char gentle;         

    @Override         
    @CompaProperties({ @CompaProperty(property = "lastName"),              
        @CompaProperty(property = "age",  order = Order.DSC) })           
    public int compareTo(Person person) {                 
        return Compamatic.doComparasion(this, person);         
    }  
}

点击链接查看更多的例子。 http://code.google.com/p/compamatic/wiki/CompamaticByExamples



文章来源: When to use Comparable and Comparator
标签： java comparator comparable
举报

收藏的人(0)

Ta的文章 更多文章
登录 后发表评论
0条评论
还没有人评论过~