Integer.valueOf、 Integer.parseInt 、 new Integer

First look at the results below

1.System.out.println(127==127); //true , int type compare2.System.out.println(128==128); //true , int type compare3.System.out.println(new Integer(127) == new Integer(127)); //false, object compare4.System.out.println(Integer.parseInt("128")==Integer.parseInt("128")); //true, int type compare5.System.out.println(Integer.valueOf("127")==Integer.valueOf("127")); //true ,object compare, because IntegerCache return a same object6.System.out.println(Integer.valueOf("128")==Integer.valueOf("128")); //false ,object compare, because number beyond the IntegerCache7.System.out.println(Integer.parseInt("128")==Integer.valueOf("128")); //true , int type compare

Explanation

When comparing int integer constants, == is a value comparison, so 1 ,2 returns true. 1,2 are value comparisons.

new Integer() constructs a new Integer object each time, so 3 returns false. 3 is object comparison.

Integer.parseInt constructs an int constant each time, so 4 returns true. 4 is a value comparison.

Integer.valueOf returns an Integer object. By default, it returns an existing object in the cache (if it exists) between -128 and 127, so 5 returns true and 6 returns false. 5 and 6 are object comparisons.

The seventh one is special. It is a comparison between int and Integer. The result is a value comparison and returns true.

Summary

For integer comparison, first determine whether it is a value comparison or an object comparison. The value comparison will definitely return true. If one of them is a value, it is a value comparison. Object comparison depends on how the object is constructed. If the new Integer method is used, a new object will be generated every time. Comparing two new Integer will definitely return false. If it is the Integer.valueOf method, pay attention to whether the value range is Between -128 and 127, if it is, the constructed objects with the same value are the same object. == returns true after comparison, otherwise it returns false.

So, for value comparison ==, there is no problem. For Integer comparison, it is best to use the equals method to compare the object content. Of course, be sure to first determine whether the Integer is not null.

Knowledge expansion

Analyze the Integer.valueOf source code

1. When we call the Integer.valueOf method, it first calls parseInt to convert it to int type value, and then call its own overloaded method

public static Integer valueOf(String s) throws NumberFormatException {return Integer.valueOf(parseInt(s, 10));
    }

2.Integer.valueOf overloaded method, based on the size of the value i, determines whether to fetch an Integer object from the cache

 public static Integer valueOf(int i) {if (i >= IntegerCache.low && i <= IntegerCache.high)return IntegerCache.cache[i + (-IntegerCache.low)];return new Integer(i);
    }

3. The constructor of Integer is very simple

  public Integer(int value) {this.value = value;
    }

4. IntegerCache static class is the internal class of Integer, with three attributes (one Cached Integer array + a set of cache range)

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"); //读取VM参数if (integerCacheHighPropValue != null) {try {int i = parseInt(integerCacheHighPropValue); //配置值转换成int数值i = Math.max(i, 127);  //和127比较，取较大者// Maximum array size is Integer.MAX_VALUE(控制缓存数组的大小，最大为整型的最大值，这样一来，h值就必须小于整型最大值，因为要存 -128～0这129个数嘛)h = Math.min(i, Integer.MAX_VALUE - (-low) -1); //实际就是 h=Math.min(i,Integer.MAX_VALUE-129),正整数能缓存的个数} catch( NumberFormatException nfe) {// If the property cannot be parsed into an int, ignore it.                }
            }
            high = h;

            cache = new Integer[(high - low) + 1]; //构造缓存数组int j = low;for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);  //将一些int常量缓存进Integer对象数组缓存中去// range [-128, 127] must be interned (JLS7 5.1.7)assert IntegerCache.high >= 127; //如果小于127，抛异常}private IntegerCache() {}
    }

After reading the above Integer.valueOf source code, you will find that the default Integer cache int constant pool can be configured. The configuration method is to add VM parameters, add: -Djava.lang.Integer.IntegerCache.high=200

Intellij IDEA. Just add parameters to the VM Options of the run configuration.

The above is the detailed content of Integer.valueOf、 Integer.parseInt 、 new Integer. For more information, please follow other related articles on the PHP Chinese website!