标签: comparable

我在考虑这样的事情:

public static <T extends Comparable<T>> T minOf(T...ts){        
    SortedSet<T> set = new TreeSet<T>(Arrays.asList(ts));
    return set.first();
}

public static <T extends Comparable<T>> T maxOf(T...ts){
    SortedSet<T> set = new TreeSet<T>(Arrays.asList(ts));
    return set.last();
}

但是不安全,这也是我想要的.

你知道解决这个问题的更好方法吗？

编辑:

评论后我也试过min():

public static <T extends Comparable<T>> T minOf(T...ts){        
    return Collections.min(Arrays.asList(ts), new Comparator<T>(){

        public int compare(T o1, T o2) {
            if(o1!=null && o2!=null){
                return o1.compareTo(o2);
            }else if(o1!=null){
                return 1;
            }else{
                return -1;  
            }
        }});
}

你对那个怎么想的？

无论如何,我可以为JVM中的所有对象定义一个序列/顺序,这样对于任何两个不同的对象o1或o2,有一个明确定义的规则,表示o1> o2或o2> o1和o1 == o2 if和only如果它们是同一个对象？

identityHashCode()比较将是一个很好的候选者,如果有无碰撞保证(没有).

出生时间也会起作用 - 如果我能以某种方式获得它.

有任何想法吗？

谢谢!

选项1:创建一个实现Comparable的列表,并在每次添加值时使用collections.sort(List l)对其进行排序.选项2:创建一个TreeSet(它始终保持自己的排序).

哪一个会更快？我问这个是因为List给了我ListIterator的选项,在我的情况下我需要它,因为它允许我在迭代时添加一个元素.

我对二叉树的外观有一个最小的定义:

type Tree[T] = Option[Node[T]]
case class Node[T](left: Tree[T], entry: T, right: Tree[T])

我现在想要将二叉搜索树定义为:

type BST[T: Ordering] = Tree[T] 

但那不会编译.我究竟做错了什么？

方法

public static int binarySearch(Object[] a, Object key) 

在其实现中的Arrays类导航通过abinarySearch算法之后的数组参数,并将ainto 的元素转换为Comparableinvokes,compareTo(key)直到它找到匹配或耗尽可能性.

然而,我对实现感到困惑,如果是这种情况,方法将始终将元素强制转换为Comparable,并且ClassCastException如果它遇到未实现的元素,则会抛出一个,如果ComparableAPI用户不熟悉该方法将只考虑数组元素的比较器,而不是密钥的比较器,通过防止在数组类型与Comparable不兼容的情况下进行调用的编译更加万无一失,并且如果执行调用也更有效该方法定义为

public static int binarySearch(Comparable[] a, Object key) 

？将第一个参数定义为Object数组有什么好处？

编辑我在发布问题之后才看到这个问题并且已经回答但是这里有一个相关的帖子:为什么Arrays.sort采用Object []而不是Comparable []？他们声明,如果方法采用参数(Comparable [],Object),就不可能将Object []类型的数组传递给该方法,而不需要"重新分配",这也很昂贵.

我希望一个对象可以比较(在这种情况下在TreeSet中使用它).

我的对象有一个名称字段,我希望按字母顺序排序.

我首先想到我可以使用字符串的unicode值并简单地做一个减法,但是然后AA会在Ab之后...例如...

这是我开始的方式:

public final class MyObject implements Comparable<MyObject> {

 private String name;

 public MyObject(String name) {
  this.name = name;
 }

 public String name() {
  return name;
 }

 @Override
 public int compareTo(MyObject otherObject) {
  return WHAT DO I PUT HERE ?;
 }
}

感谢那些愿意帮助的人,祝你有个美好的一天!

我试图通过特定的属性("程序"的"学生"对象和"教师"的"教授"对象)对对象的两个不同的数组列表进行排序.这两个类都扩展了我的抽象'Person'类.

public abstract class Person implements Comparable<Person>{
    private String name;
    private String adress;

    //getters, setters, etc., all works properly

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone(); 
    }

    public int compareTo(String string) {
        return name.compareTo(string);
    }
}

然后,当我创建一个1000000个随机"人物"对象的数组而不是学生或教授时,我决定按照它们的名字(按字母顺序)按字母顺序排序(它可以正常工作).

Person personByName[] = arrayPersonas.clone();
Arrays.sort(personByName);

然后,我将原始Person数组分成两个ArrayLists,一个用于Student对象,另一个用于Professor对象:

    ArrayList<Student> studentsByProgram = new ArrayList();
    ArrayList<Professor> professorsByFaculty = new ArrayList();
    for (int i = 0; i < 1000000; i++) { 
        if (arrayPersonas[i] instanceof Student) {
            studentsByProgram.add((Student)arrayPersonas[i]);
        } else {
            professorsByFaculty.add((Professor)arrayPersonas[i]);
        }
    }

当我尝试按照我想要的属性按字母顺序对每个ArrayList进行排序时会出现问题,因为它会按Person的名称对它们进行排序:

Collections.sort(studentsByProgram);
Collections.sort(professorsByFaculty); …

想象一下包括类似这样的类:

class Element
  include Comparable
  attr_accessor :name, :pos_x, :pos_y

  def initialize(name, pos_x, pos_y)
    @name = name
    @pos_x = pos_x
    @pos_y = pos_y
  end

  def <=>(other)
    if (@pos_x == other.pos_x) and (@pos_y == other.pos_y)
      return 0
    else 
      return @name <=> other.name
    end
  end

  def eql?(other)
    self == other
  end
end

在这种情况下hash,你将如何实现这个功能a.hash == b.hash？一般来说,我会这样做:

def hash
  @name.hash
end

但这不包括pos_x和pos_y.

据我所知，Java Bean 应该始终：

1. 只有一个空的构造函数
2. 只有字段，以及这些字段的 getter/setter 方法。

但是，我想知道 Java bean 实现接口的约定是什么 Comparable？我可以保留 java bean 纯，这意味着绝对没有行为，只有数据，并编写自定义比较器类。不过，实现可比较更容易。

在实现 Comparable to Java Beans 之类的简单通用接口时，是否有任何约定？我自己找不到任何后果，但感觉我可能会违反一些规则，并且可能有一些我没有想到的事情。

我不明白为什么 List.sort() 没有没有比较器的版本的逻辑。

特别是我看到可以使用 null: 调用 List.sort
list.sort(null)，并且它似乎使用自然顺序进行排序。

我注意到在我的 IDE Collections.sort() 调用 List.sort(null)，所以我想知道为什么 List.sort 似乎是最近在 Java 8 中引入的没有没有比较器的简单版本，在许多病例是不需要的。

此外，我不确定在这种情况下是否最好调用 List.sort(null) 以避免额外调用，或者是否仍然首选调用 Collections.sort() 并避免丑陋的 null 参数。