标签: autoboxing

当Java编译器将一个原语自动装箱到包装器类时,它会在幕后生成什么代码？我想它叫:

• 包装器上的valueOf()方法
• 包装器的构造函数
• 其他一些魔术？

我有这样的方法:

public static <T> boolean isMemberOf(T item, T[] set)
{
    for (T t : set) {
        if (t.equals(item)) {
            return true;
        }
    }
    return false;
}

现在我尝试使用charfor 调用此方法T:

char ch = 'a';
char[] chars = new char[] { 'a', 'b', 'c' };
boolean member = isMemberOf(ch, chars);

这不起作用.我期望char,并char[]得到autoboxed至Character和Character[],但是这似乎并没有发生.

任何见解？

我在回答另一个问题时看到了这一点,参考了​​Java规范的缺点:

还有更多的缺点,这是一个微妙的话题.看看这个:

public class methodOverloading{
     public static void hello(Integer x){
          System.out.println("Integer");
     }

     public static void hello(long x){
          System.out.println("long");
     }

     public static void main(String[] args){
         int i = 5;
         hello(i);
     }
}

Run Code Online (Sandbox Code Playgroud)

这里将打印"long"(我自己没有检查过),因为编译器会选择加宽自动装箱.使用自动装箱时要小心,或者根本不使用它!

我们是否确定这实际上是扩大而不是自动装箱的一个例子,还是完全不同于其他东西？

在我的初始扫描中,我同意声明输出i在声明为基元而不是对象的基础上"长" .但是,如果你改变了

hello(long x)

至

hello(Long x)

输出将打印"整数"

这里到底发生了什么？我对java的编译器/字节码解释器一无所知...

我是一个新手Java编码器,我只是读取一个整数类的变量,可以在API中描述三种不同的方式.我有以下代码:

if (count.compareTo(0)) { 
            System.out.println(out_table);
            count++;
    }

这是一个循环,只是输出out_table.
我的目标是弄清楚如何查看整数值count > 0.

我意识到这count.compare(0)是正确的方法吗？或者是count.equals(0)吗？

我知道这count == 0是不正确的.这是正确的吗？它的价值比较运算符在哪里count=0？

请考虑以下代码段:

    int i = 99999999;
    byte b = 99;
    short s = 9999;
    Integer ii = Integer.valueOf(9); // should be within cache

    System.out.println(new Integer(i) == i); // "true"
    System.out.println(new Integer(b) == b); // "true"
    System.out.println(new Integer(s) == s); // "true"
    System.out.println(new Integer(ii) == ii); // "false"

很明显为什么最后一行总是打印出来"false":我们正在使用==引用标识比较,而new对象永远不会是==已经存在的对象.

问题是前三行:那些比较保证在原语上int,Integer自动取消装箱？是否存在基元将被自动装箱的情况,并且执行参考标识比较？(那就是全部false!)

我知道这个主题有类似的帖子,但它们并没有完全解决我的问题.当你这样做时:

Integer a = 10;
Integer b = 10;
System.out.println("a == b: " + (a == b));

这将(显然)打印true大部分时间,因为[-128,127]范围内的整数以某种方式被缓存.但:

Integer a = new Integer(10);
Integer b = new Integer(10);
System.out.println("a == b: " + (a == b));

会回来false.我理解我要求整数的新实例,但由于盒装原语在Java中是不可变的,并且机器已经在那里做"正确的事情"(如第一种情况所示),为什么会发生这种情况？

如果具有10的Integer的所有实例在内存中都是相同的对象,那会不会更有意义？换句话说,为什么我们没有"Integer interning",这类似于"String interning"？

更好的是,如果表示同一事物的盒装基元的实例(无论值(和类型)是否是同一个对象),它会更有意义吗？或者至少正确回答==？

有没有办法为我创建的类使用自动装箱？例如,我有这个子类Number.

public class UnsignedInteger extends Number {
    int n;

    public UnsignedInteger(int n) {
        if(n >= 0)
            this.n = n;
        else
            throw new IllegalArgumentException("Only positive integers are supported");
    }
}

现在,UnsignedInteger i = new UnsignedInteger(88);工作得非常好,但有没有办法让这个编译:UnsignedInteger i = 88;？它不适合我.提前致谢!

运行以下Java代码:

boolean b = false;
Double d1 = 0d;
Double d2 = null;
Double d = b ? d1.doubleValue() : d2;

为什么会出现NullPointerException？

这个问题是关于"为什么autoboxing在Java中使一些调用变得模棱两可？"

但通过阅读答案,有许多参考铸造,我不确定我完全理解差异.

有人可以提供简单的解释吗？

为什么第二段代码更快？

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));
    }
}