相关疑难解决方法(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)

？

我想写一个比较器,让我按值而不是默认的自然顺序对TreeMap进行排序.

我试过这样的东西,却找不到出了什么问题:

import java.util.*;

class treeMap {
    public static void main(String[] args) {
        System.out.println("the main");
        byValue cmp = new byValue();
        Map<String, Integer> map = new TreeMap<String, Integer>(cmp);
        map.put("de",10);
        map.put("ab", 20);
        map.put("a",5);

        for (Map.Entry<String,Integer> pair: map.entrySet()) {
            System.out.println(pair.getKey()+":"+pair.getValue());
        }
    }
}

class byValue implements Comparator<Map.Entry<String,Integer>> {
    public int compare(Map.Entry<String,Integer> e1, Map.Entry<String,Integer> e2) {
        if (e1.getValue() < e2.getValue()){
            return 1;
        } else if (e1.getValue() == e2.getValue()) {
            return 0;
        } else {
            return -1;
        }
    }
}

我想我要问的是:我可以Map.Entry传递给比较器吗？

以下代码抛出NullPointerException:

int num = Integer.getInteger("123");

我的编译器是否getInteger在null上调用,因为它是静态的？这没有任何意义!

发生了什么？

观察这种情况让我非常困惑:

Integer i = null;
String str = null;

if (i == null) {   //Nothing happens
   ...                  
}
if (str == null) { //Nothing happens

}

if (i == 0) {  //NullPointerException
   ...
}
if (str == "0") { //Nothing happens
   ...
}

因此,我认为首先执行装箱操作(即java尝试从中提取int值null),并且比较操作具有较低的优先级,这就是抛出异常的原因.

问题是:为什么在Java中以这种方式实现它？为什么拳击优先于比较参考？或者为什么他们没有null在拳击前实施验证？

目前,当NullPointerException使用包装的基元抛出它时看起来不一致,并且不会抛出真正的对象类型.

我有一段代码需要我理解:

public static void main(String[] args) {
    Character c = new Character('a');
    Character cy = new Character('a');
    char cx = 'a';

    System.out.println(c == cx);
    System.out.println(cx == cy);
    System.out.println(c == cy);
}

输出:

true
true
false

我无法理解为什么只有第三个陈述失败了.

编辑:这个问题.equals与==原始与对象比较的vs 问题不同.

运行以下Java代码:

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

为什么会出现NullPointerException？

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

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

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

我对Java的方式对待有点混乱==,并equals()当它涉及到int,Integer和其他类型的数字.例如:

Integer X = 9000;
int x = 9000;
Short Y = 9000;
short y = 9000;
List<Boolean> results = new ArrayList<Boolean>();
// results.add(X == Y); DOES NOT COMPILE        1)
results.add(Y == 9000);                      // 2)
results.add(X == y);                         // 3)
results.add(X.equals(x));                    // 4)
results.add(X.equals(Y));                    // 5)
results.add(X.equals(y));                    // 6)
System.out.println(results);

输出(也许你应该先猜测):

[true, true, true, false, false]

1. 这X == Y不能编译是可以预料的,是不同的对象.
2. 我有点惊讶的Y == 9是true,鉴于9是默认的int,并且鉴于1)甚至没有编译.请注意,你不能把int一个方法放入期望a的方法中 …

我是Java的新手,并且在整数数组中检查null元素时遇到问题.我正在使用Eclipse进行编辑,并且检查null元素的行显示错误:

抱怨的行:

if(a[i] != null) {

来自Eclipse的错误信息:

The operator != is undefined for the argument type(s) int, null

在PHP中,这没有任何问题,但在Java中,似乎我必须将数组类型从整数更改为Object以使该行不被抱怨(如下所示)

Object[] a = new Object[3];

所以我的问题是,如果我仍然想要声明为整数数组并且仍然想要检查null,它的语法是什么？

码:

public void test() {
        int[] a = new int[3];
        for(int i=0; i<a.length; i++) {
            if(a[i] != null) { //this line complains...
                System.out.println('null!');
            }
        }
    }

Java没有运算符重载的概念.

Still +运算符表现为带数字的加法运算符,并将运算符与字符串连接起来.这类似于运算符重载行为.

那么,Java是否有运算符重载？