java的Integer、Double等数字封装类用>、<做比较好，还是用compareTo方法好？

Posted 2023-04-18

当然是用compareTo方法了。比较时就可以用equals方法比较。

原因：
对于Integer在-128到127范围内的数字可以直接比较，因为Integer对象是在IntegerCache.cache产生，会复用已有对象。而在这个范围之外的数字就会在堆在产生。这样就会有个坑是：
Integer val1 = 129
Integer val2 = 129
这时无论val1 == val2，还是val1 > val2 ,还是val1 < val2 都是返回false. 参考技术A ＞底层应该做的是拆箱操作！只要判断不为null就行

Java 常用对象-基本类型的封装类

2017-11-04 20:39:26

基本类型封装类：基本类型的封装类的好处是可以在对象中定义更多的功能方法操作该数据。

常用操作之一：用于基本数据类型与字符串的转换。

基本类型和包装类的对应：

byte  Byte，short  Short，int  Integer，long  Long，float  Float，double  Double，char  Character，boolean  Boolean。

下面以Integer为例：

Integer：Integer 类在对象中包装了一个基本类型 int 的值。Integer 类型的对象包含一个 int 类型的字段。

此外，该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法。

*构造方法

*常用属性

*常用方法

 

• String和int的互转

        //int转String
        String s1 = String.valueOf(100);
        System.out.println(s1);

        //String转int
        int i=Integer.parseInt(s1);
        System.out.println(i);

•  进制转换

        //十进制转二进制，八进制，十六进制
        System.out.println(Integer.toBinaryString(100));
        System.out.println(Integer.toOctalString(100));
        System.out.println(Integer.toHexString(100));

        //十进制转任何进制,进制范围为[2,36],因为0-9，a-z只有36个。
        System.out.println(Integer.toString(100,16));
        
        //其他进制转十进制
        //将二进制100转十进制
        System.out.println(Integer.parseInt("100",2));

•  JDK5新特性：自动拆装箱

        // 自动装箱
        Integer i=100;
        // 自动拆箱
        i+=200;
        System.out.println(i);
        
        // 通过反编译可以得到自动拆装箱的代码
        // Integer i=Integer.valueOf(100);
        // i=Integer.valueOf(i.intValue()+200);
        // System.out.println(String.valueOf(i));

[注意]：Integer对象不能是null。否则会出现NullPointerException。建议先判断是否为null，再使用。

• 数据缓冲池
  

        Integer i1 = new Integer(127);
        Integer i2 = new Integer(127);
        System.out.println(i1==i2);  // false
        System.out.println(i1.equals(i2));  // true

        Integer i3 = new Integer(128);
        Integer i4 = new Integer(128);
        System.out.println(i3==i4);  // false
        System.out.println(i3.equals(i4));  // true

        Integer i5 = 127;
        Integer i6 = 127;
        System.out.println(i5==i6);  //true
        System.out.println(i5.equals(i6));  // true

        Integer i7 = 128;
        Integer i8 = 128;
        System.out.println(i7==i8);  // false
        System.out.println(i7.equals(i8));  //false

在对象的比较中“==”是比较内存地址，而equals（）函数默认也是比较地址，但是这里Integer类重写了该方法，所以是比较的数值大小，因此，所有的equals是一样的。

显然，如果是new出来的对象其地址一定是不同的，所以前面两个在判断“==”的时候都是false。

那么为什么自动装箱后会出现差别呢？

从上面的源码分析我们得知，自动装箱在底层其实是在调用valueof（int i）方法把int类型转成Integer类型。valueof（）的源码如下：

static final int low = -128;
static final int high;

static {
            // high value may be configured by property
            int h = 127;
            String integerCacheHighPropValue =
                VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (integerCacheHighPropValue != null) {
                try {
                    int i = parseInt(integerCacheHighPropValue);
                    i = Math.max(i, 127);
                    // Maximum array size is Integer.MAX_VALUE
                    h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                } catch( NumberFormatException nfe) {
                    // If the property cannot be parsed into an int, ignore it.
                }
            }
high = h;    

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

也就是说，valueof方法在调用的时候会区别对待，在[-128,127]的数会从缓冲池中直接取，而不在这个范围的数据则会new一个对象进行返回。

• 类型转换的时候，.valueOf()和.parseX()的区别

valueOf：返回的是个包装类
parseInt：返回的就是基本数据类型