标签: comparable

我想按BSSID级别对android wifi ScanResult对象进行排序.最有效的方法是什么？我是否必须创建自己的Comparable ScanResult并编写代码以转换为ScanResult或从ScanResult转换？

我一直在尝试学习类似的课程,我知道正确的语法以及它在大多数情况下的使用方式.如:

int result = ObjectA.compareTo(ObjectB); 

如果两个对象相同,则返回值0; 如果对象A小于对象B则为负值,如果A大于对象B则为正值.

但是当我真正编写一个使用compareTo方法的程序时,编译器说它无法找到compareTo方法.

我的问题是:我是否必须直接从Comparable类继承才能使用compareTo方法？我问的唯一原因是因为你不必显式继承像toString或equals这样的方法...因为所有东西都是从对象继承的.CompareTo在哪里？

我已经为可比较数组,插入,合并和选择编写了排序方法,我通过改变我之前从排序int数组中获得的代码来完成此操作,而我只是将事物从int更改为Comparable.但是,当我为int数组做这个时,我非常清楚如何实际使用该方法,例如这是我对int的选择排序:

 public void selectionSort(int[] list){
    for (int i=0;i<list.length;i++){
        for (int si=i;si<list.length;si++){
            if (list[si]<list[i]){
                int temp=list[i];
                list[i]=list[si];
                list[si]=temp;
            }
        }
    }        
}

这是最终使用此方法的代码:

public static void main(String[] args) {
    Scanner in=new Scanner(System.in);
    int numItems,searchNum,location;
    Sorts sort=new Sorts();        
    int[]test;        
    System.out.print("Enter the number of elements: ");
    numItems=in.nextInt();
    test=new int[numItems];

    for (int i=0;i<test.length;i++){
        test[i]=(int)(100*Math.random());
    }

    System.out.println("Unsorted: ");
    displayArray(test);
    sort.selectionSort(test);
    System.out.println("Sorted: ");        
    displayArray(test);    

一切正常,但对于我的可比选择排序,我有这个代码:

public static void selectionSort(Comparable[] list){   
for (int i=0;i<list.length;i++){
        for (int si=i;si<list.length;si++){
            if (list[si].compareTo(list[i])<0){
                Comparable temp=list[i];
                list[i]=list[si];
                list[si]=temp;
            }
        }
       }
    } …

我正在尝试实现一个简单的插入排序算法,并使其通用于Comparable接口的所有实例.

public static <E extends Comparable<E>> void InsertionSort( E [] array)
{
    for(int i = 1; i < array.length; i++)
    {
        E current = array[i];

        int k;
        for(k = i-1; k >= 0 && current.compareTo(array[k]) < 0 ; k--)
        {
            array[k+1] = array[k];

        }

        array[k+1]=current;

    }

    for(int l = 0; l < array.length; l++)
    {
        System.out.print(array[l]+" ");

    }

    System.out.println();
}

我遇到的问题是我不知道它们之间的区别

 <E extends Comparable<E>>

和

 <E extends Comparable>

他们都工作,但我不知道第一个的原因.

是否可以首先按员工对象的工资对员工对象进行排序，如果两个对象的工资相等，然后使用比较器和比较器接口按名称对它们进行比较？

例如，我有一个 Employee 类，如下所示

public class Employee{
    private int salary;
    private int name;
    public Employee(salary,name){
        this.salary = salary;
        this.name = name;
    }
    //...........getter methods...........
}

现在假设我们有一个 Employee 对象列表，其中包含一些工资金额和姓名。我想使用比较器或类似的接口，并以这样的方式对列表进行排序：列表根据薪水排序，如果薪水相同，那么在这种情况下，这两个 Employee 对象必须按其名称排序。有人可以告诉我是否可能吗？代码片段将不胜感激。

我的项目中有一个称为NewsItem的类。我想按照用户想要的方式以降序和升序对NewsItem的ArrayList进行排序。问题是我正在使用Comparable接口，并且我返回一个带有升序条件或降序条件的int值，而另一个则被注释。我如何告诉Collections.sort（）方法给我升序或降序的排序列表。这是我的代码。

@Override
public int compareTo(NewsItem compNews) {
    int compTime=((NewsItem )compNews).getNewsTime();
    /* For Ascending order*/
    return this.NewsTime-compTime;

    /* For Descending order do like this */
    //return compTime-this.NewsTime;
}

现在在这里对降序进行注释，以便我可以使用其中之一。我可以在此类中使用静态布尔值来使用以下条件之一。但是，由于我正在序列化此类，因此我在此类中未使用任何静态变量，因此请勿这样做。任何帮助表示赞赏。

我有一个基本的BusinessObject抽象类，它通过比较它们的长 id字段来实现 Comparable 。现在想象我用Person扩展它，然后我用Worker扩展 Person 。所以我们有：

业务对象 < 人员 < 工人

所以现在我覆盖了 Person（比较名称）和 Worker（比较工作名称，然后是人员名称）中业务对象中的 compareTo(BusinessObject)。

现在我做这样的事情：

List<BusinessObject> collection = new ArrayList<>();
collection.add(new Worker(1L, "Steve", "janitor"));
collection.add(new Worker(2L, "Mark", "plumber"));
collection.add(new Person(3L, "Dave"));

Collections.sort(collection);
System.out.println(collection);

通过记录，我可以看到进行的调用：

1. Worker.compareTo()
2. Person.compareTo()

所以，这意味着排序方法是混合的，这显然是不好的。那么什么是使用继承实现 Comparable 的正确方法，以便调用的方法取决于集合的泛型类型：

1. 如果集合是一个列表，那么总是使用 BusinessObject.compareTo()
2. 如果集合是一个列表，那么总是使用 Person.compareTo()
3. 如果集合是一个列表，那么总是使用 Worker.compareTo()

这是我的代码：

public abstract class BusinessObject implements HasId, HasText, Comparable<BusinessObject> {
    protected @Nullable Long id;

    public BusinessObject(@Nullable Long id) {
        this.id = id;
    }

    @Override
    public @Nullable …

我的应用程序中有一个抽象类（我们称之为BaseRule）。 BaseRule实现Comparable接口，并包含抽象方法签名public abstract int getExecOrder()。

在类中方法BaseRule的实现中， 的返回值用于比较对象。compareTo()BaseRulegetExecOrder()

目前，我有该类的3个具体实现BaseRule，每个实现该getExecOrder()方法

BaseRule让类实现接口的最终目的Comparable是将对象集合BaseRule传递给需要对这些对象进行排序的实用程序，以确保它们以正确的顺序执行。

在这种情况下，执行顺序仅在类级别重要，这意味着每个对象必须在执行BaseRuleA任何对象之前执行，但每个对象实际上“等于”其他对象，因此处理这些对象的顺序并不重要BaseRuleBBaseRuleBBaseRuleBBaseRuleB

我的问题是，与使用（我想出的）getExecOrder()方法相比，是否有更好的方法来处理比较这些对象？

现在，我只有 3 个具体实现BaseRule，因此很容易将返回值 1,2,3 分配给这些getExecOrder()方法调用，但如果另一个开发人员添加新的BaseRule实现，他们将不得不扫描所有现有的实现，并（可能）更新所有类中的这些返回值以适应新的BaseRule.

关于更好的实施有什么想法吗？

我有以下代码块：

public static void main(String[] args) {
    Integer[] test = new Integer[100];
    comparableTest(test);
    genericsTest(test);
}

private static void comparableTest(Comparable[] c) {

}

private static <E extends Comparable<E>> void genericsTest(E[] e) { }

我使用泛型到底要完成什么？这些都没有编译错误。我仍然可以使用 compareTo 方法。那么我得到的是什么E extends Comparable<E>而不是仅仅使用Comparable？

这个问题的上下文是我让排序算法使用E extends Comparable<E>而不是Comparable.

我知道 compareTo() 是如何工作的(即 0,+1,-1)。下面的代码有效但我想知道它是如何比较对象的，它比较三个对象的顺序。

注意：搜索了以前的问题，但没有找到任何答案。

插入列表的值是[a,c,b,d]

任何人都可以请解释一下它采用上述输入进行比较的顺序。

当我调试时，我看到下面的行值组合 this.name.compareTo(employeeName.name);

package packageOne;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class W {
    public static void main(String[] args) {
        
        Employee employee1 = new Employee("a");
        Employee employee2 = new Employee("c");
        Employee employee3 = new Employee("b");
        Employee employee4 = new Employee("d");
        
        
        List<Employee> al = new ArrayList<>();
        al.add(employee1);
        al.add(employee2);
        al.add(employee3);
        al.add(employee4);
        
        Collections.sort(al);
        
        System.out.println("after sorting");
        
        System.out.println(al);

        
    }

} …