我正在使用Java JungI图形包和Netbeans 7.我从Java得到以下错误:
Exception in thread "main" java.lang.ClassCastException: graphvisualization.MyVertex cannot be cast to java.lang.Comparable
at java.util.TreeMap.put(TreeMap.java:542)
以下是与错误相关的代码:
SortedMap<MyVertex, Double> vMap = new TreeMap<MyVertex, Double>();
double curRank = 0;
for(MyVertex v: g.getVertices()) //g is a SparseGraph<MyVertex, MyEdge>
{
curRank = vertexRank.getVertexScore(v);
vMap.put(v, curRank); //**Here is my Error**
}
MyVertex类是我为图表制作的一个类.以下是MyVertex的代码
public class MyVertex
{
int vID; //id for this vertex
double centrality; //centrality measure for this vertex
int degree; //the degree of this vertex
public MyVertex(int id)
{
this.vID …如果一个对象拥有一个唯一的主键,那么它需要实现哪些接口才能实现集合友好,特别是在高效排序,可清洗等方面...？
如果主键是字符串,那么如何最好地实现这些接口？
谢谢!
我正在寻找C#IComparable的Scala对应物,我找到了可比较的特性.我的意思是 - 提到可比较,但是当我在http://www.scala-lang.org/api/current/scala/搜索它时,我得到0次点击.由于这个名字,使用Google我得到了很多"Scala如何与......相比"的结果.
有什么资源我可以读到这个神秘的可比较的东西吗？在所有Ordered延伸之后,它必须存在.
目前我正在以二进制函数的形式编写compareTo方法:ax ^ 2 + bx + c.
a,b,c是通过构造函数传递给类的整数系数.
在compareTo方法中,我应该首先比较两个函数之间的a系数,但如果它们相等,我比较b系数.如果b是相等的,我比较c.
我为此提出的方法最终变得非常难看:
public int compareTo(QuadraticFunction other)
{
if (a > other.a)
return 1;
else if (a < other.a)
return -1;
else if (b > other.b)
return 1;
else if (b < other.b)
return -1;
else if (c > other.c)
return 1;
else if (c < other.c)
return -1;
else
return 0;
}
所以我想知道,如果你有这些"分层"的比较系统(比如在c之前比较a之前的b),那么实现它们的最佳方法是什么？如果你不得不经历10多个变量,我无法想象会像我一样编写一个方法.
如果我有一个类Person实现Comparable(比较personA.height到personB.height,例如),是有可能使用
personA < personB
作为替代品
personA.compareTo(personB) == -1?
这样做有什么问题,还是我需要重载操作符？
该行return array[index1].compareTo(array[index2]);提供错误"无法在基本类型double上调用compareTo(double)".如何解决这个问题？
/*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::*/
/*:: This function implements a comparator of double values :*/
/*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::*/
private class ArrayIndexComparator implements Comparator<Integer>
{
private final double[] array;
public ArrayIndexComparator(double[] array)
{
this.array = array;
}
public Integer[] createIndexArray()
{
Integer[] indexes = new Integer[array.length];
for (int i = 0; i < array.length; i++)
{
indexes[i] = i; // Autoboxing
}
return indexes;
}
@Override
public int compare(Integer index1, Integer index2)
{
// Autounbox from Integer to int to use …这是一个难以破解的坚果.我在使用varargs和泛型之间发生了冲突.给定代码:
public class MyObject implements Comparable<MyObject>
{
private String name;
private int index;
@Override
public int compareTo(MyObject o)
{
if (name.compareTo(o.name) != 0)
return name.compareTo(o.name);
return ((Integer) index).compareTo(o.index);
}
}
我希望该compareTo方法使用多个比较条件.如果字符串相同,则使用ints代替.通常情况我会说.
我希望创建一个静态方法来处理这个问题.我希望chainedCompare像这样调用新方法:
public int compareTo(MyObject o)
{
return chainedCompare(this, o, myO -> myO.name, myO -> myO.index);
}
lambdas是Java 8接口函数的变量.所以首先我写了这样的方法:
public static <T, C extends Comparable<C>> int chainedCompare(T object1, T object2, Function<T, C>... comparisons)
{
int compareValue = 0;
for (Function<T, C> comparison : comparisons)
{
compareValue …我正在尝试List按名称对员工进行排序,然后使用Java8 Comparator,我在下面创建Comparator但是它给了我一个编译器错误
Type mismatch: cannot convert from Comparator<Object> to <unknown>
Comparator<String> c = Comparator.comparing(s -> s.split("\\s+")[0])
.thenComparingInt(s -> Integer.parseInt(s.split("\\s+")[1])); //compile error
但是如果我明确指定Type,它就可以工作
Comparator<String> c = Comparator.<String, String> comparing(s -> s.split("\\s+")[0])
.thenComparingInt(s -> Integer.parseInt(s.split("\\s+")[1])); //works
或者通过创建两个Compartors和链
Comparator<String> name = Comparator.comparing(s -> s.split("\\s+")[0]);
Comparator<String> age = Comparator.comparingInt(s -> Integer.parseInt(s.split("\\s+")[1]));
Comparator<String> cc = name.thenComparing(age); //works
我已Comparator<String>在左侧指定了类型,但为什么自动类型推断未找到正确的类型并期望明确指定.
有人可以澄清一下吗？
这是代码
String[] arr = { "alan 25", "mario 30", "alan 19", "mario 25" };
Comparator<String> c = …我尝试在 Go 中使用泛型，但我不太明白何时使用anyorcomparable作为类型参数。有人可以帮助理解这些吗？
在 Go 1.18 和 Go 1.19 中，我可以确保在编译时类型是严格可比较的，即它支持==和!=运算符，并且保证它们在运行时不会出现恐慌。
例如，这对于避免无意中向结构添加可能导致不必要的恐慌的字段很有用。
我只是尝试comparable用它实例化：
// supports == and != but comparison could panic at run time
type Foo struct {
SomeField any
}
func ensureComparable[T comparable]() {
// no-op
}
var _ = ensureComparable[Foo] // doesn't compile because Foo comparison may panic
由于约束的定义，这在 Go 1.18 和 1.19 中是可能的comparable：
预先声明的接口类型可比较表示所有可比较的非接口类型的集合
尽管 Go 1.18 和 1.19 规范没有提及不是接口但也不能严格比较的类型，例如[2]fmt.Stringeror struct { foo any }，gc …