相关疑难解决方法(0)

我知道,如果你将盒装原始Integer与常量进行比较,例如:

Integer a = 4;
if (a < 5)

a 将自动取消装箱,比较将起作用.

但是,当您比较两个盒装Integers并希望比较相等或小于/大于？时会发生什么？

Integer a = 4;
Integer b = 5;

if (a == b)

以上代码是否会导致检查它们是否是同一个对象,还是会在这种情况下自动取消装箱？

关于什么:

Integer a = 4;
Integer b = 5;

if (a < b)

？

以下代码编译(使用Java 8):

Integer i1 = 1000;
int i2 = 1000;
boolean compared = (i1 == i2);

但是它做了什么？

取消框i1:

boolean compared = (i1.intvalue() == i2);

或盒子i2:

boolean compared = (i1 == new Integer(i2));

那么它是按比例比较两个Integer对象(通过引用)还是两个int变量？

请注意,对于某些数字,因为Integer类维护值之间的内部缓存中的基准比较将产生正确的结果-128来127(见也TheLostMind注释).这就是我1000在我的例子中使用的原因以及为什么我特别询问拆箱/装箱而不是比较的结果.

可能重复:
奇怪的Java拳击

最近我看到了一个演示文稿,其中有以下Java代码示例:

Integer a = 1000, b = 1000;  
System.out.println(a == b); // false  
Integer c = 100, d = 100;  
System.out.println(c == d); // true

现在我有点困惑.我理解为什么在第一种情况下结果是"假" - 这是因为Integer是一个引用类型,而"a"和"b"的引用是不同的.

但为什么在第二种情况下结果是"真实的"？

我听说过一个观点,即JVM将对象的int值从-128缓存到127以进行某些优化.以这种方式,"c"和"d"的引用是相同的.

有人可以给我更多关于这种行为的信息吗？我想了解这种优化的目的.在什么情况下性能提高等等.参考这个问题的一些研究将是伟大的.

在下面的类中，我试图将包装器类与原始类进行比较，但结果不同。

我检查了以下链接链接：

更为有趣的问题是，为什么new Object();每次都需要创建一个唯一实例？即为什么new Object();不允许缓存？答案是wait(...)和notify(...)。缓存new Object()会错误地导致线程在不应该同步时彼此同步。

如果有一个新的对象，然后是如何a和c平等的吗？

如果b等于c且c等于a，a则应等于b。但在以下情况下，我得到了a != c。

请解释。

class WrapperCompare {

    public static void main (String args[]) {
        Integer a = new Integer(10);    
        Integer b = 10; 
        int c=10;
        System.out.println(b==c);       //true
        System.out.println(a==b);       //false
        System.out.println(a==c);       //true
    }
}

更新：通过引用此链接Integer caching。

基本上，Integer类会将Integer实例的缓存保留在-128到127的范围内，并且所有自动装箱，文字和Integer.valueOf（）的使用都会从该缓存返回其覆盖范围内的实例。

因此，在这种情况下，所有语句都应为真。

public class Main { 
    /** 
      * @param args the command line arguments */ 
    public static void main(String[] args) { 
        // TODO code application logic here
        int a1 = 1000, a2 = 1000; 
        System.out.println(a1==a2);//=>true 
        Integer b1 = 1000, b2 = 1000;
        System.out.println(b1 == b2);//=>false 
        Integer c1 = 100, c2 = 100; 
        System.out.println(c1 == c2);//=>true 
    }

}

为什么是b1 == b2虚假和c1 == c2真实的？

我知道这Double是一个包装类,它包装了double数字.今天,我看到了另一个主要区别:

double a = 1.0;
double b = 1.0;
Double c = 1.0;
Double d = 1.0;
System.out.println(a == b);  // true
System.out.println(c == d);  // false

对我这么奇怪!!!

所以,如果我们Double每次使用,我们必须做这样的事情:

private static final double delta = 0.0001;
System.out.println(Math.abs(c-d) < delta); 

我无法解释为什么Double直接比较错误.请解释一下.

谢谢 :)

请考虑以下Java代码:

    Object a = new Integer(2);
    Object b = new Integer(2);
    System.out.println(a.equals(b));

    Object x = new Object();
    Object y = new Object();
    System.out.println(x.equals(y));

第一个打印语句打印true,第二个打印false.

如果这是故意的行为,这有助于如何用Java编程？

如果这不是故意行为,这是Java中的缺陷吗？

可能重复:
奇怪的Java拳击

嗨,

有人可以解释为什么最后一个打印返回false吗？

int a = 100;
int b = 100;

System.out.println(a == b); // prints true

Integer aa = 100;
Integer bb = 100;

System.out.println(aa == bb); // prints true

Integer aaa = 1000;
Integer bbb = 1000;

System.out.println(aaa == bbb); // prints false

谢谢迈克尔

我只是在探索java反射API,我遇到了以下代码片段

public class Main {
    public static void main(String[] args) throws IllegalAccessException, NoSuchFieldException{
            Field value=Integer.class.getDeclaredField("value");
            value.setAccessible(true);
            value.set(42, 43);

            System.out.printf("six times seven %d%n",6*7);
            System.out.printf("six times seven %d%n",42);
            System.out.println(42);
        }
    }

输出:

six times seven 43
six times seven 43
42

我阅读了set方法的文档,该方法声明它为给定对象设置字段的值.但我无法理解代码的输出,因为它应该在所有情况下打印42.

任何人都可以深入了解代码中发生的事情吗？

我正在比较2段代码.第一

Integer i=3;
Integer j=3;
if(i==j)
   System.out.println("i==j");  //prints i==j              

第二,

Integer i=3;
Integer j=new Integer(3);
if(i==j)
   System.out.println("i==j"); // does not print

我怀疑在第一个片段中为什么i==j要打印？引用不应该不同吗？