今天使用FindBugs检查项目时，发现有这样一个提示

Boxing/unboxing to parse a primitive
A boxed primitive is created from a String, just to extract the unboxed primitive value. It is more efficient to just call the static parseXXX method.

这句话的意思是说，我们正在讲一个String解析成一个boxed的原生类型，也就是Integer，Long这些等等，但是我们只需要将String解析成unboxed原生类型即可，也就是int，long这种。最后它推荐使用parseXXX()这样的静态方法.

于是很好奇parseXXX()和valueOf()有啥不同呢？打开源码看一看

public static Integer valueOf(String s) throws NumberFormatException {
      return Integer.valueOf(parseInt(s, 10));
  }
public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

我们看到valueOf()内部也是调用了parseInt()方法. 从下面的valueOf()方法可以看出, parseInt()返回的是一个unboxed的原生类型数据. 因此在上面的场景中会有那样的提示.

但是看到这里还不算完, 看到这让我想起了一个以前碰到的面试题

public class TestIntegerValueOf {
    public static void main(String[] args) {
        Integer i1 = 1;
        Integer i2 = 1;
        System.out.println(i1 == i2);

        Integer i3 = 200;
        Integer i4 = 200;
        System.out.println(i3 == i4);

        Integer i5 = Integer.valueOf(100);
        Integer i6 = Integer.valueOf(100);
        System.out.println(i5 == i6);

        Integer i7 = Integer.valueOf(200);
        Integer i8 = Integer.valueOf(200);
        System.out.println(i7 == i8);
    }
}

结果为

true
false
true
false

我们看到在讲int强转为Interger的时候, 也是valueOf()的逻辑

除了Integer之外, 还有哪些基本原生类型是这样子的呢？先看看long

public static Long valueOf(long l) {
    final int offset = 128;
    if (l >= -128 && l <= 127) { // will cache
        return LongCache.cache[(int)l + offset];
    }
    return new Long(l);
}

接下来是Short

public static Short valueOf(short s) {
    final int offset = 128;
    int sAsInt = s;
    if (sAsInt >= -128 && sAsInt <= 127) { // must cache
        return ShortCache.cache[sAsInt + offset];
    }
    return new Short(s);
}

接下来是Byte

public static Byte valueOf(byte b) {
    final int offset = 128;
    return ByteCache.cache[(int)b + offset];
}

接下来是Char

public static Character valueOf(char c) {
    if (c <= 127) { // must cache
        return CharacterCache.cache[(int)c];
    }
    return new Character(c);
}

接下来是Float

public static Float valueOf(float f) {
    return new Float(f);
}

接下来是Double

public static Double valueOf(double d) {
    return new Double(d);
}

我们看到除了浮点型之外，都采用了缓存的原理。虽然我们从源码中看到了结果，可是求个心安，我们还是要写代码测试一下

public class Test {
    public static void main(String[] args) {
        Short s_1 = 100;
        Short s_2 = 100;
        System.out.println(s_1 == s_2);

        Long l_1 = 100l;
        Long l_2 = 100l;
        System.out.println(l_1 == l_2);

        Character c_1 = 100;
        Character c_2 = 100;
        System.out.println(c_1 == c_2);

        Short s1 = 200;
        Short s2 = 200;
        System.out.println(s1 == s2);

        Long l1 = 200l;
        Long l2 = 200l;
        System.out.println(l1 == l2);

        Character c1 = 200;
        Character c2 = 200;
        System.out.println(c1 == c2);
    }
}

结果为

true
true
true
false
false
false

好了，这下世界安静了

后来在项目中发现有使用Gson转换中也会发生这种情况, 写个代码测试一下

public class TestIntegerValueOf {
    public static void main(String[] args) {
        Obj obj = new Obj();
        obj.integer = 200;
        Gson gson = new Gson();
        String str = gson.toJson(obj);
        System.out.println(str);
        Obj newObj1 = gson.fromJson(str, Obj.class);
        Obj newObj2 = gson.fromJson(str, Obj.class);
        System.out.println(newObj1.integer == newObj2.integer);
    }

    private static class Obj {
        public Integer integer;
    }
}

输出结果为

{"integer":200}
false

看来在Gson中不是使用强转就是使用的valueOf()