标签: comparable

在的Java 1.4.2,类java.math.BigInteger实现接口Comparable,Serializable.

在的Java 1.5.0,类java.math.BigInteger实现接口Serializable,Comparable<BigInteger>.

这只是一个例子,可以帮助我询问<和>.什么我真的想知道是<和>东西.

我的问题有三个:

• 声明中的<BigInteger>部分implements是什么意思？
• 这个语法叫什么？
• 它做了什么？

PS:这真的很难给谷歌<和>也不可能这么搜索<和>摆在首位.

谢谢!

四元数比较可能吗？我正在编写一个Java类的Quaternions,我想实现Comparable接口来使用该Collections.sort(List<Quaternion>)工具.我不是数学专家,我真的不明白我读到的关于四元数的事情.那么,任何人都可以告诉我,我可以覆盖compareToQuaternions 的方法以及如何？

我的班级宣誓:

public class Quaternion implements Serializable, Comparable<Quaternion> {

    private double s; // scalar part
    private double i, j, k; // vectorel part


    public Quaternion() {
        super();
    }

    public Quaternion(double s, double i, double j, double k) {
        super();
        this.s = s;
        this.i = i;
        this.j = j;
        this.k = k;
    }

我想得到每个月的计数,但即使有多次出现,计数也应该每天最多只有一次.我有正确的SQL查询,但无法将其转换为LINQ -

select 
    count(DISTINCT DAY(date)) as Monthly_Count,
    MONTH(date) as Month,
    YEAR(date)
from 
    activity
where 
    id=@id
group by
    YEAR(date),
    MONTH(date) 

任何人都可以帮我翻译上面的查询到LINQ.谢谢!

我在网站上看到过处理具有多个参数的泛型的示例,但没有一个适用于我的情况.

所以这是交易:我正在尝试学习Java泛型,并决定创建一个简单的二进制数组搜索实用程序函数.我正在使用自定义对象和整数进行测试.要获得有关错误和警告的反馈,我正在使用Eclipse.这是我有的:

public static int binarySearch(Comparable[] array, Comparable item, int start, int end) {
    if(end < start) {
        return -1;
    }
    int mid = (start + end) / 2;
    if(item.compareTo(array[mid]) > 0) {
        return binarySearch(array, item, mid + 1, end);
    } else if(item.compareTo(array[mid]) < 0) {
        return binarySearch(array, item, start, mid - 1);
    } else {
        return mid;
    }
}

所以很明显我得到Raw类型的警告,说泛型应该参数化.如果我有多个参数需要是同一类型,我怎么能正确地做到这一点？

解

以下是使用泛型和正确参数检查的工作解决方案:

public static <T extends Comparable<? super T>> int binarySearch(T[] array, T item, int start, int end) { …

我正在使用一个示例,它使用ArrayList包含新实例,并使用Collections.sort()方法使用类似的接口.我不知道为什么它在排序时打印出哈希码以及我的代码中的错误.任何人都可以找出错误并详细解释我.

SortFruitObject.java

import java.util.*;
public class SortFruitObject{
    public static void main(String[] args){
        ArrayList<Fruit> frui   =   new ArrayList<Fruit>();

        frui.add(new Fruit("Pine", "PineDesc", 500));
        frui.add(new Fruit("Apple", "AppleDesc", 400));
        frui.add(new Fruit("Banana", "BananaDesc", 450));
        frui.add(new Fruit("JackFruit", "JackFruitDesc", 300));

        Collections.sort(frui);
        System.out.println(frui);
    }
}

Fruit.java

import java.io.*;
import java.util.*;
public class Fruit implements Comparable<Fruit>{
    private String fruitName;
    private String fruitDesc;
    private int fruitQuantity;

    public int compareTo(Fruit f){
        return fruitName.compareTo(f.getFruitName());
    }

    public Fruit(String fruitName, String fruitDesc, int fruitQuantity){
        this.fruitName = fruitName;
        this.fruitDesc = fruitDesc;
        this.fruitQuantity = fruitQuantity;
    } …

我发现这个注释可以将StringBuffer对象作为Java中TreeSet中的键吗？

"在Java中使用地图有两种识别策略(或多或少).

散列:输入"Foo"被转换为尽可能最好的尝试,以生成唯一访问数组索引的数字.(纯粹主义者,请不要虐待我,我故意简化).此索引是存储值的位置."Foo"和"Bar"实际上可能生成相同的索引值,这意味着它们都将映射到相同的数组位置.显然这不起作用,所以这就是"equals()"方法的用武之地; 它用于消除歧义

比较:通过使用比较方法,您不需要这个额外的消歧步骤,因为比较首先不会产生这种碰撞."Foo"等于的唯一关键是"Foo".一个非常好的想法是,如果你可以将"equals()"定义为compareTo()== 0; 为了一致的缘故.不是要求."

我的问题如下:如果我的类实现了可比性,那么它是否意味着我不必重写equals和hashcode方法来将我的对象用作Hash集合中的键.例如

class Person implements Comparable<Person> {
     int id;
     String name;

     public Person(int id, String name) {
        this.id=id;
        this.name=name;
     }

    public int compareTo(Person other) {
      return this.id-other.id;
    }
}

现在,我可以在Hashable集合中使用我的Person对象吗？

我正在运行一个示例来了解 Java 中 Comparator 的行为。

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;


    class HDTV {
    private int size;
    private String brand;

    public HDTV(int size, String brand) {
        this.size = size;
        this.brand = brand;
    }

    public int getSize() {
        return size;
    }

    public void setSize(int size) {
        this.size = size;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }
}

class SizeComparator implements Comparator<HDTV> {
    @Override
    public int compare(HDTV tv1, HDTV tv2) {
        int …

对于实现 Comparable 接口的对象 a 和 b，我想避免使用类似的代码

if (a.compareTo(b) > 0) {
    ...
}

相反，我正在寻找类似的辅助方法

if (a.isGreaterThan(b)) {
    ...
}

这对我有很大帮助，因为我不必总是查找 compareTo(T o) 的返回值的定义：

当此对象小于、等于或大于指定对象时，返回一个负整数、零或正整数。

真正有用的是5种不同的方法：

Instead of                  use potential helper method:

a.compareTo(b) < 0          a.isLessThan(b)
a.compareTo(b) <= 0         a.isLessOrEqualTo(b)
a.compareTo(b) == 0         a.isEqualTo(b)
a.compareTo(b) >= 0         a.isGreaterOrEqualTo(b)
a.compareTo(b) > 0          a.isGreaterThan(b)

JDK 或其他提供此类功能的库中是否有类似的辅助方法？

我是编程的初学者,我有两节课.头等舱是:

public class User implements Comparable<User>

with field int age,constructor和overrided interface of interface Comparable:

 @Override
    public int compareTo(User user) {
        return user.age >= age ? -1 : 0;
    }

第二类是 public class SortUser使用从List创建Set集合的方法:

public Set<User> sort(List<User> list) {
        Set<User> result = new TreeSet<>();
        for (User user : list) {
            result.add(user);
        }
        return result;
    }

在我看来,UserSet 中的所有对象都应该排序,但是当我创建一个包含3个User对象的List时......

 User a = new User(1);
 User b = new User(2);
 User c = new User(3);
 List<User> list = …

我有一个由某种“状态机”（“流程图”）定义的分布式系统

每个系统都将状态写入共享“日志”中

我将每个州表示为密封特征的一部分以及该州的给定“状态”

我想“合并/减少”到代表当前进度的单一状态。

（有一些放宽措施，因为并非所有项目都必须成功才能成功完成最终状态）

有 2 个密封特征代表流程：

sealed trait System
case object A extends System
case object B extends System
case object C extends System
...

sealed trait Status
case object Pending extends Status
case object InProgress extends Status
case object Success extends Status
case object Fail extends Status

日志：

A, Success
B, Fail
C, Pending
...
...

现在我用一组规则来定义单个状态降低

基本上它优先

A < B < C, ... < Z

和

Pending < InProgress < Success < Fail

因此，如果存在以下状态：

(A, Success) …