标签: autoboxing

根据as运营商的文档,as"用于在兼容的参考类型之间执行某些类型的转换".由于Nullable 实际上是一个值类型,我希望as不会使用它.但是,此代码编译并运行:

object o = 7;
int i = o as int? ?? -1;
Console.WriteLine(i); // output: 7

这是正确的行为吗？文件是as错的吗？我错过了什么吗？

我们的Java项目中有一个类LogManager,如下所示:

public class LogManager {

    public void log(Level logLevel, Object... args) {
        // do something
    }

    public void log(Level logLevel, int value, Object... args) {
        // do something else
    }
}

在Debian下用OpenJDK 6编译项目时,每个工作都很好.使用OpenJDK 7时,构建(使用ant完成)会产生以下错误,并且构建失败:

[javac] /…/LogManager.java:123: error: reference to log is ambiguous,
                      both method log(Level,Object...) in LogManager
                      and method log(Level,int,Object...) in LogManager match
[javac]       log(logLevel, 1, logMessage);
[javac]       ^
[javac] /…/SomeOtherClass.java:123: error: reference to log is ambiguous,
                      both method log(Level,Object...) in LogManager
                      and method log(Level,int,Object...) in …

只花了几个小时调试这段代码:

    LinkedHashMap<String, Integer> rsrqs = new LinkedHashMap<String, Integer>();
    Integer boxedPci = 52;
    Integer boxedRsrq = boxedPci != null ? rsrqs.get(boxedPci.toString()) : -1;

以上产生了NullPointerException.以下代码不:

    LinkedHashMap<String, Integer> rsrqs = new LinkedHashMap<String, Integer>();
    Integer boxedPci = 52;
    Integer boxedRsrq = boxedPci != null ? rsrqs.get(boxedPci.toString()) : Integer.valueOf(-1);

唯一的区别是用Integer.valueOf()包装-1.一旦有人解释了为什么这个代码的行为方式,我肯定我会打破我的前额..但有人可以向我解释为什么这个代码的行为方式:)

- 编辑

第二个想法,我怀疑NPE来自rsrqs.get()返回null,我认为java在尝试解包成int之前,然后再回到整数.Integer.valueOf()强制Java执行unbox-box步骤.故事的道德启示; 不要只忽略Eclipse中的那些拳击警告;)

据我所知,下面的代码应该打印"true",但是当我运行它时会打印出来"false".

public class Test {
    public static boolean testTrue() {
        return true;
    }

    public static void main(String[] args) throws Exception {
        Object trueResult = Test.class.getMethod("testTrue").invoke(null);
        System.out.println(trueResult == Boolean.TRUE);
    }
}

根据JLS§5.1.7.拳击转换:

如果该值p被装箱是true,false,一个byte,或一个char在所述范围内\u0000对\u007f或int或short之间号-128和127(含),然后让和是任何两个装箱转换的结果.情况总是如此.r1r2pr1 == r2

但是,如果通过反射调用方法,则始终通过框创建值new PrimitiveWrapper().

请帮我理解这个.

我只是想知道让java autobox说一个整数有什么区别:

Integer myInteger = 3; // This will call Integer.valueOf()

或者你的代码是

Integer myInteger = Integer.valueOf(3);

这有什么微优化吗？我知道第二个更明确,但它也更不必要打字,除此之外有什么区别吗？

请考虑以下代码行:

public static void main(String[] args)  {
    foo(1,2,3);
    System.out.println("-------------------------------------");
    foo(new Integer(1), new Integer(2), new Integer(3));
    System.out.println("-------------------------------------");
    foo(new Integer[]{1,2,3});
    System.out.println("-------------------------------------");
    foo(new Integer[] {new Integer(1), new Integer(2), new Integer(3)});
}

public static void foo(Object... bar) {
    System.out.println("bar instanceof Integer[]:\t" + (bar instanceof Integer[]));
    System.out.println("bar[0] instanceof Integer:\t" + (bar[0] instanceof Integer));
    System.out.println("bar.getClass().isArray():\t" + bar.getClass().isArray());
}

此代码段的输出是:

bar instanceof Integer[]:   false
bar[0] instanceof Integer:  true
bar.getClass().isArray():   true
-------------------------------------
bar instanceof Integer[]:   false
bar[0] instanceof Integer:  true
bar.getClass().isArray():   true
-------------------------------------
bar instanceof Integer[]:   true
bar[0] …

可能重复:
Arrays.asList()不能正常工作？

显然返回类型Arrays.asList(new int[] { 1, 2, 3 });是List<int[]>.这似乎完全打破了我.这是否与Java有关,而不是原始类型的自动装箱阵列？

我找到了一段代码,从Java 7切换到Java 8后停止编译.它没有任何新的Java 8内容,如lambda或流.

我将有问题的代码缩小到以下情况:

GenericData<Double> g = new GenericData<>(1d);
Double d = g == null ? 0 : g.getData(); // type error!!!

您可能猜测GenericData构造函数有一个泛型类型的参数,该getData()方法只返回该泛型类型.(有关完整的源代码,请参阅下文.)

现在困扰我的是,在Java 7中,代码编译得很好,而使用Java 8,我得到以下错误:

CompileMe.java:20: error: incompatible types: bad type in conditional expression
Double d = g == null ? 0 : g.getData();
                       ^
int cannot be converted to Double

似乎Java 7能够从int - > double - > Double进行转换,但Java 8因尝试立即从int - > Double而失败.

我觉得特别有趣的是Java 8 确实接受代码时,我改变它getData()到data,即访问GenericData通过变量本身而不是消气方法的价值:

Double …

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真实的？

从JDK 5.0开始,自动装箱/拆箱是在java中引入的,技巧简单而有用,但是当我开始测试包装类和原始类型之间的不同转换时,我真的很困惑自动装箱的概念如何在java中工作,例如:

拳击

int intValue = 0;
Integer intObject = intValue;
byte byteValue = 0;
intObject = byteValue; // ==> Error

尝试不同的情况下(后short,long,float,double),这是由编译器所接受的唯一情况是,当值的上做作运算符右侧的类型是int.当我查看我的源代码时Integer.class发现它只实现了一个带int参数的构造函数.

所以我的结论是自动装箱的概念是基于包装类中实现的构造函数.我想知道这个结论是否属实,还是有自动拳击使用的另一个概念？

拆箱

Integer intObject = new Integer(0);
byte byteValue = intObject; // ==> Error (the same Error with short)
int intValue = intObject; 
double doubleValue = intObject;

关于拆箱的结论是包装类给出了对应的类型(Integer==> int)包装的值,然后编译器使用通常的转换基元类型的规则(byte=> short=> int=> long=> float=> double).我想知道这个结论是否属实,还是自动拆箱使用了另一个概念？ …