相关疑难解决方法(0)

为什么第二段代码更快？

Map<Integer, Double> map = new HashMap<Integer, Double>();
for (int i = 0; i < 50000; i++) {
    for (double j = 0.0; j < 10000; j++) {
        map.put(i, j);
    }
}

Map<Integer, Double> map=new HashMap<Integer, Double>();
for (int i = 0; i < 50000; i++) {
    for (double j = 0.0; j < 10000; j++) {            
        map.put(new Integer(i), new Double(j));
    }
}

Autoboxing相当可怕.虽然我完全理解之间的差异==和.equals我不能不帮助有后续错误的地狱了我:

    final List<Integer> foo = Arrays.asList(1, 1000);
    final List<Integer> bar = Arrays.asList(1, 1000);
    System.out.println(foo.get(0) == bar.get(0));
    System.out.println(foo.get(1) == bar.get(1));

那打印

true
false

他们为什么这样做？它与缓存的整数有关,但如果是这样的话,为什么它们不只是缓存程序使用的所有整数？或者为什么JVM始终不会自动拆箱到原始状态？

打印虚假或真假会更好.

编辑

我不同意旧代码的破坏.通过foo.get(0) == bar.get(0)返回true,您已经破坏了代码.

通过在字节代码中将int替换为int(只要从未赋值为null),就不能在编译器级别解决这个问题.

我是一个java新手,并且对以下示例感到困惑.是否可以认为"=="符号将比较Integers和int中的"autoboxed"整数之间的值,并比较整数之间的参考地址？

双打和0/0怎么样？

import edu.princeton.cs.introcs.*;

public class Autoboxing {

    public static void cmp(Integer first, Integer second) {
        if (first < second)
            StdOut.printf("%d < %d\n", first, second);
        else if (first == second)
            StdOut.printf("%d == %d\n", first, second);
        else if (first > second)
            StdOut.printf("%d > %d\n", first, second);
        else
            StdOut.printf("%d and %d are incomparable\n", first, second);
    }

    public static void main(String[] args) {
        cmp(new Integer(42), 43);
        cmp(new Integer(42), new Integer(42));
        cmp(43, 43);
        cmp(142, 142);

        Integer a0 = 1000;
        int b0 = …

我只是想确保我的代码使用对象作为键是安全的Integer.这是一个简短的例子:

Integer int1 = new Integer(1337);
Integer int2 = new Integer(1337);

if (int1 == int2) {
    System.out.println("true");
} else {
    System.out.println("false");
}

if (int1.equals(int2)) {
    System.out.println("true");
} else {
    System.out.println("false");
}

Map<Integer, Object> map = new HashMap<Integer, Object>();
map.put(int1, null);
map.put(int2, null);

System.out.println(map.size());

代码将输出

false
true
1

这就是我所期待的,参考文献有所不同,但它们彼此相同.现在我对Map的行为很感兴趣.

• 是否可以保证像Map或Set这样的集合会按照内容而不是参考来比较密钥？
• 或者取决于实际的实施,比如HashMap？

请你解释下面的行为.

public class EqAndRef {

    public static void main(String[] args) {
        Integer i = 10;
        Integer j = 10;

        Double a = 10D;
        Double b = 10D;

        System.out.println(i.equals(j));
        System.out.println(i == j);


        System.out.println(a.equals(b));
        System.out.println(a == b);


    }
}

输出jdk 6

true
true
true
false

为什么a == b是假的而我= = j不是假的？

我正在努力理解这个Koan:

@Koan
public void equalsMethodCanBeChangedBySubclassesToTestsIfTwoObjectsAreEqual() {
    Object object = new Integer(1);
    assertEquals(object.equals(object), true);
    assertEquals(object.equals(new Integer(1)), __);
    // Note: This means that for the class 'Object' there is no difference between 'equal' and 'same'
    // but for the class 'Integer' there is difference - see below
}

据我所知,因为object是Object类的一个实例,该.equals()方法尚未被覆盖,因此检查对象是否相等.

如果new Integer(1)创建一个新实例,那么它应该是一个单独的对象object.按照我的思路,正确的答案应该是false,但只有true通过.我逻辑中的缺陷在哪里？

编辑:我知道-128和127之间的整数是缓存的.如果我对该object对象的理解是正确的(如上所述),那么这是无关紧要的.

通常,使用==无法比较Java库中对象的引用,但我刚刚检查过:

Integer x = 5;
Integer y = x + 1;
Integer z = y - 1;
x.equals(z)
true   (boolean)
x == z
true   (boolean)

这只是我的IDE的工件,还是Java Integer对象保证在它们具有相同值时指向相同的Integer？后一种保证会简化我正在编写的一些代码.

main(){

Integer i1 = 500;

Integer i2 = 500;

System.out.println(i1 == i2);  // O/P is "**false**"

String s1 = "Hello";

String s2 = "Hello";

System.out.println(s1 == s2);  // O/P is "**true**"

} // End of main.

我无法弄清楚为什么输出不同.据我所知s1,s2将指向堆上的同一个对象.所以他们的参考地址是一样的.同样地,我认为整数也是一样的.但事实并非如此.它为什么不同？

我有这个问题,

java中的向量只接受对象吗？但这段代码编译得很好

Vector myv=new Vector();
myv.addElement(1);
myv.addElement(1);

它将它封装为Integer的对象吗？如果确实如此,为什么要这样说

System.out.println(myv.elementAt(0)==myv.elementAt(1));

真的吗!!! 他们应该是两个不同的对象......？

同时此语句抛出一个错误,确保该元素是一个对象.

int x=myv.elementAt(0);

有人可以帮我解释一下吗？谢谢.

我有一个例外

java.lang.IllegalArgumentException: Comparison method violates its general contract!
at java.util.TimSort.mergeHi(TimSort.java:868)
at java.util.TimSort.mergeAt(TimSort.java:485)
at java.util.TimSort.mergeCollapse(TimSort.java:408)
at java.util.TimSort.sort(TimSort.java:214)
at java.util.TimSort.sort(TimSort.java:173)
at java.util.Arrays.sort(Arrays.java:659)
at Main.main(Main.java:64)

使用此代码时:

Arrays.sort(arr, new Comparator<Integer[]>(){  //arr is 2D array
        public int compare(Integer[] o1, Integer[] o2){
            return o1[2]==o2[2]?0:o1[2]>o2[2]?1:-1;
        }
    });

我认为这与不满足比较的传递性有关,但当我做了一点这样的改变时:

Arrays.sort(arr, new Comparator<Integer[]>(){  //arr is 2D array
        public int compare(Integer[] o1, Integer[] o2){
            return o1[2].compareTo(o2[2]); // here is the change
        }
    });

不再生成异常.我无法理解这个问题的解释,因为我确信除了compareTo()方法之外,还可以使用关系运算符(>,<,=)来比较Integer实例

Integer x = 1;
Integer y = 2;
System.out.println(x<y);

按预期打印true

任何机构都可以澄清吗？