相关疑难解决方法(0)

类Integer具有缓存,缓存Integer值.因此,如果我使用方法valueOf或收件箱,新值将不会被实例化,而是从缓存中获取.

我知道默认缓存大小是127因为VM设置而可以扩展.我的问题是:在这些设置中缓存大小的默认值有多大,我可以操纵这个值吗？这个值取决于我使用的是哪个VM(32位还是64位)？

我现在正在调整遗留代码,可能需要从int转换为Integer.

澄清:遵循我在Java源代码中找到的代码

private static class IntegerCache {
    static final int low = -128;
    static final int high;
    static final Integer cache[];

    static {
        // high value may be configured by property
        int h = 127;
        String integerCacheHighPropValue =
            sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
        if (integerCacheHighPropValue != null) {
            int i = parseInt(integerCacheHighPropValue);
            i = Math.max(i, 127);
            // Maximum array size is Integer.MAX_VALUE
            h = Math.min(i, Integer.MAX_VALUE - (-low));
        }
        high = h;

        cache = …

我有这个Java代码：

public class Foo {
    public static void main(String[] args) {
         Integer x = 5;
         Integer y = 5;
         System.out.println(x == y);
    }
}

是否保证可以true在控制台上打印？我的意思是，它是按值（我需要做的）还是按引用标识比较两个装箱的整数？

另外，如果我将它们转换为未装箱的整数，会有所不同吗

public class Foo {
    public static void main(String[] args) {
         Integer x = 5;
         Integer y = 5;
         System.out.println((int) x == (int) y);
    }
}

public static void main(String[] args) {    
    System.out.println((Integer.valueOf("5000") <= Integer.valueOf("5000")));
    System.out.println((Integer.valueOf("5000") == Integer.valueOf("5000")));       
}

上面的代码分别打印true和false。这是可以理解的，但是为什么false当我们使用==.

但是，当使用<=（小于或等于）时，为什么是答案true？

在下面的代码中,该行System.out.println(sumInteger(bigs) == sumInteger(bigs));显示为false.但是当我们再次比较另一个Integer包装类时System.out.println(bc == ab);,它返回true.为什么在第一种情况下包装类的比较为false而在第二种情况下为true？

import java.util.Arrays;
import java.util.List;

public class Arrays {

    public void array1() {

        List<Integer> bigs = Arrays.asList(100,200,300);
        System.out.println(sumInteger(bigs) == sum(bigs)); // 1. Output: true
        System.out.println(sumInteger(bigs) == sumInteger(bigs)); //2. Output: false

        Integer ab = 10;
        System.out.println(ab == 10); //3. Output: true
        Integer bc = 10;
        System.out.println(bc == ab); //4. Output: true
    }

    public static int sum (List<Integer> ints) {
        int s = 0;
        for (int n : ints) { s += n; } …

Java 8 引入了 Lambdas，它允许我们有效地从 List 中删除所有元素。以下内容从 中删除 2 的所有实例myList。

List<Integer> myList;
...
myList.removeIf(x -> x==2);

如果我想删除 N 个元素（在本例中为三个），我将使用for循环。

for (int i = 0; i < 3; i++) {
    myList.remove(Integer.valueOf(2));
}

有没有办法使用 Lambda 从列表中删除指定数量的元素？如果是这样，它是否比for循环代码更有效？

List<Integer> test = List.of(955, 955);
if (test.get(1) == test.get(0))
...

以上条件导致 false

List<Integer> test = List.of(955, 955);
int a = test.get(1);
int b = test.get(0);
if (a == b)
...

上述条件返回true。

为什么会这样？片段之间有什么区别？

分配值而不使用通常的表示法,例如"this.<Double> getAnything(int flag)"

private <T> T getAnything(int flag) {
    Object o = null;
    if (flag==0)
        o=new String("NewString");
    else if (flag==1)
        o=new Double(0D);
    return (T)o;
}


private void someMethod() {
    String s = getAnything(0);
    Double d = getAnything(1);
}

在过去,只有方法上的返回对象和接收类型上的简单强制转换就足够了,因此在接收器对象上缺少通用符号,它更加相似和快速写入,还有其他任何提示吗？

我有以下代码.

public static void doIntCompareProcess() {
    int a = 100;
    int b = 100;

    Integer c = 200;
    Integer d = 200;

    int f = 20000;
    int e = 20000;

    System.out.println(c == d);
    compareInt(e, f);
    compareInt(a, b);
}

public static void compareInt(Integer v1, Integer v2) {
    System.out.println(v1 == v2);
}

这给了我这个输出:

false
false
true

当前输出应为:

false
false
false

为什么我的代码输出错误？

我知道你不能使用==或!=来比较数字对象的值,而是必须使用.equals().但经过大量的搜索后,我无法找到关于是否可以使用其他比较运算符的声明,除了使用.compare()或.compareTo()的建议,因为它们需要两个比较:a到b,然后结果为零.

尽管==和!=比较了对象的地址,但其他比较运算符似乎比较了数值.例如,以下代码段:

Integer a = new Integer(3000);
Integer b = new Integer(3000);
System.out.println("a <  b " + (a < b));
System.out.println("a <= b " + (a <= b));
System.out.println("a == b " + (a == b));
System.out.println("a >= b " + (a >= b));
System.out.println("a >  b " + (a > b));

产生

a <  b false
a <= b true
a == b false
a >= b true
a >  b false

这似乎表示所有运算符,但==比较值,而不是对象的地址.是否接受使用<=运算符类,或只是我的编译器不支持的功能或什么？

我尝试下一步比较整数(对我来说,这很好):

public void compareMayNull(Integer a, Integer b) {
    if ((a == null ? -1 : a.intValue()) == b.intValue())
        System.out.println("true");
}

IntelliJ IDEA给我警告"不必要的拆箱" a.intValue(),b.intValue()并建议我简化代码:

public void compareMayNull(Integer a, Integer b) {
    if ((a == null ? -1 : a) == b)
        System.out.println("true");
}

但我有点困惑,因为如果a != null不是我所知道的最佳实践,将会比较参考文献.我应该使用什么代码？