integer 订阅
integer,整数 / 整型数,与小数 / 浮点数相对,是编程语言的基本数据类型之一,用以指示变量的数据类型,有时也用于常量(变量、表达式)的强制数据类型转换。整型数据的长度及其取值范围并不固定,受编译环境影响。在不同的编程语言中做此类型声明时,具体实现方式也可能会有所区别。 展开全文
integer,整数 / 整型数,与小数 / 浮点数相对,是编程语言的基本数据类型之一,用以指示变量的数据类型,有时也用于常量(变量、表达式)的强制数据类型转换。整型数据的长度及其取值范围并不固定,受编译环境影响。在不同的编程语言中做此类型声明时,具体实现方式也可能会有所区别。
信息
外文名
integer
相对应概念
小数 / 浮点数
中文名
整数 / 整型数
范    畴
编程语言
integer含义
Integer 数据类型Integer 一个整型数据用来存储整数,整数包括正整数,负整数和零。整型常量采用十进制整数表示。如 1991,0,-123等等都是整型常量。而52.0或131.4都不是整型常量。Integer 变量存储为最接近编译环境的长度,例如在32位的编译环境下,Integer为32位,其范围为 -2^15 到 2^15-1 之间。VB中Integer 的类型声明字符是百分比符号 (%)。Pascal中就是integer。在C语言中被缩写成为int。
收起全文
精华内容
下载资源
问答
  • Integer

    2018-09-28 17:48:02
    Integer类实现了Comparable接口,所以可以用compareTo进行比较并且Integer对象只能和Integer类型的对象进行比较,不能和其他类型比较 Integer继承了Number类,所以该类可以调用longValue、floatValue、doubleValue...

    ①特性

    • Integer类不能被继承
    • Integer类实现了Comparable接口,所以可以用compareTo进行比较并且Integer对象只能和Integer类型的对象进行比较,不能和其他类型比较
    • Integer继承了Number类,所以该类可以调用longValue、floatValue、doubleValue等系列方法返回对应的类型的值

    ②方法

    • compareTo(Integer anotherInteger)
    • equals(Object obj)
    • byteValue()
    • doubleValue()
    • floatValue()
    • intValue()
    • shortValue()
    • longValue()
    • toString()

    ③示例

     @Test
        public void test1() {
            Integer integer = 12;
            System.out.println(integer.equals(12));
            System.out.println(integer.compareTo(11));
            System.out.println(integer.toString());
            System.out.println(integer.byteValue());
            System.out.println(integer.floatValue());
            System.out.println(integer.intValue());
            System.out.println(integer.longValue());
            System.out.println(integer.shortValue());
        }

     

    展开全文
  • IntegerCache

    万次阅读 2020-09-11 12:09:32
    Integer CacheIntegerCache源码Integer 使用Cache源码瞎搞 IntegerCache源码 java.lang.Integer.IntegerCache { static final int low = -128; static final int high; static final Integer cache[]; ... } ...

    IntegerCache源码


    java.lang.Integer.IntegerCache {
            static final int low = -128;
            static final int high;
            static final Integer cache[];
            ...
    }
    
    • Cache会缓存 [low, high-low] 范围内的整数
    • high默认127 范围 [127, Integer.MAX_VALUE - (-low) -1] , 可由 java.lang.Integer.IntegerCache.high 设置

    Integer 使用Cache源码


    public final class Integer extends Number implements Comparable<Integer> {
    	...
    	private final int value;
    	...
    	public static Integer valueOf(int i) {
    		if (i >= IntegerCache.low && i <= IntegerCache.high)
    			return IntegerCache.cache[i + (-IntegerCache.low)];
    		return new Integer(i);
    	}
    	...
    }
    
    • 可以看出非new的Integer如果值在[low, high]内, 则复用同一个对象
    • 注意java.lang.Integer#value为final

    瞎搞


    实现一段任何数字与Integer a = 2相乘为0的功能

    /**
     * Integer常量池
     */
    @Log4j2
    public class ModifyInteger {
    
        static {
            try {
                modify();
            } catch (NoSuchFieldException | IllegalAccessException e) {
                e.printStackTrace();
            }
        }
    
        private static void modify() throws NoSuchFieldException, IllegalAccessException {
            // 1. 获取 IntegerCache 类
            Class<?> IntegerCache = Integer.class.getDeclaredClasses()[0];
    
            // 2. 获取 value 字段
            Field integerCacheValue = IntegerCache.getDeclaredField("cache");
            Field integerCacheLow = IntegerCache.getDeclaredField("low");
    
            // 3. 获取缓存数组
            integerCacheValue.setAccessible(true);
            Integer[] sourceCache = (Integer[]) integerCacheValue.get(Integer.class);
    
            // 4. 获取缓存最小值
            integerCacheLow.setAccessible(true);
            int low = integerCacheLow.getInt(Integer.class);
    
            // 5. 将缓存中的 2 修改为 0 (偷梁换柱)
            sourceCache[(low < 0 ? -low : low) + 2] = 0;
        }
    
        public static void check(Integer n) {
            Random random = new Random(System.currentTimeMillis());
            for (int idx = 0; idx < 10; idx++) {
            	// 14:48:53.775 [main] INFO org.example.codeTest.ModifyInteger - random * 2 = 0
                log.info("random * 2 = {}", random.nextInt(100) * n);
            }
        }
        
        public static void main(String[] args) {
            check(2);
        }
    }
    
    展开全文
  • 简化 java.lang.Integer 类的源码

    万次阅读 2020-09-25 19:03:06
    public final class Integer extends Number implements Comparable<Integer>, Constable, ConstantDesc { private final int value; // 真正存储int类型的值 @java.io.Serial @Native private static ...

    Interger在面试中也会经常遇到,关于面试题中遇到的问题在下面注释中有说明

    public final class Integer extends Number implements Comparable<Integer>, Constable, ConstantDesc {
    
        private final int value;        // 真正存储int类型的值
        @java.io.Serial
        @Native
        private static final long serialVersionUID = 1360826667806852920L; // 序列化版本号
        @Native
        public static final int MIN_VALUE = 0x80000000;
        @Native
        public static final int MAX_VALUE = 0x7fffffff;
        @Native
        public static final int SIZE = 32;
        public static final int BYTES = SIZE / Byte.SIZE;
        public static final Class<Integer> TYPE = (Class<Integer>) Class.getPrimitiveClass("int");
        static final int[] sizeTable = {9, 99, 999, 9999, 99999, 999999, 9999999, 99999999, 999999999, Integer.MAX_VALUE};
        static final char[] digits = {
                '0', '1', '2', '3', '4', '5',
                '6', '7', '8', '9', 'a', 'b',
                'c', 'd', 'e', 'f', 'g', 'h',
                'i', 'j', 'k', 'l', 'm', 'n',
                'o', 'p', 'q', 'r', 's', 't',
                'u', 'v', 'w', 'x', 'y', 'z'
        };
        static final byte[] DigitTens = {
                '0', '0', '0', '0', '0', '0', '0', '0', '0', '0',
                '1', '1', '1', '1', '1', '1', '1', '1', '1', '1',
                '2', '2', '2', '2', '2', '2', '2', '2', '2', '2',
                '3', '3', '3', '3', '3', '3', '3', '3', '3', '3',
                '4', '4', '4', '4', '4', '4', '4', '4', '4', '4',
                '5', '5', '5', '5', '5', '5', '5', '5', '5', '5',
                '6', '6', '6', '6', '6', '6', '6', '6', '6', '6',
                '7', '7', '7', '7', '7', '7', '7', '7', '7', '7',
                '8', '8', '8', '8', '8', '8', '8', '8', '8', '8',
                '9', '9', '9', '9', '9', '9', '9', '9', '9', '9',
        };
    
        static final byte[] DigitOnes = {
                '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
                '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
                '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
                '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
                '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
                '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
                '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
                '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
                '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
                '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
        };
    
        /**
         * 重点掌握内容,面试题可能会出现
         * 对于-128 ~ 127 以内得数做了缓存,因此-128 ~ 127 内Integer类型得对象是同一个对象
         * 例如:   Integer i1 = 12;
         *         Integer i2 = 12;
         *         System.out.println(i1 == i2);// true
         *
         *         Integer i3 = 128;
         *         Integer i4 = 128;
         *         System.out.println(i3==i4);// false
         * 之所以产生区别就在于-128 ~ 127 内得数做了缓存
         * 拆包:   Integer i5 = 128;
         *         int i6 = 128;
         *         System.out.println(i5 == i6);// true 进行拆包比较所以为true
         * 直接new Integer();比较的是地址,肯定是false
         */
        private static class IntegerCache {
            static final int low = -128; // 缓存最小值-128
            static final int high;// 缓存最大值,后面被赋值为127,在类的初始化过程中静态代码块被执行
            static final Integer[] cache; // 缓存值,缓存的数据都存在这个对象数组中
            static Integer[] archivedCache;
            static {
                int h = 127; // 127以内的值做了缓存,
                String integerCacheHighPropValue = VM.getSavedProperty("java.lang.Integer.IntegerCache.high");// 获取jvm启动参数中的最大值
                if (integerCacheHighPropValue != null) {
                    try {
                        h = Math.max(parseInt(integerCacheHighPropValue), 127); // 将手动从jvm启动参数值和127进行比较,得到最大值
                        h = Math.min(h, Integer.MAX_VALUE - (-low) - 1);//
                    } catch (NumberFormatException nfe) {}
                }
                high = h;   // high=127,low=-128
                VM.initializeFromArchive(IntegerCache.class);
                int size = (high - low) + 1;
                if (archivedCache == null || size > archivedCache.length) {
                    Integer[] c = new Integer[size];
                    int j = low;
                    for (int i = 0; i < c.length; i++) {
                        c[i] = new Integer(j++);
                    }
                    archivedCache = c;
                }
                cache = archivedCache;
                assert IntegerCache.high >= 127;
            }
            private IntegerCache() {}
        }
    
        /**
         * 构造方法
         */
        @Deprecated(since = "9")
        public Integer(int value) {}
        @Deprecated(since = "9")
        public Integer(String s) throws NumberFormatException {}
    
        public byte byteValue() {}      // 转换成byte类型的值
        public short shortValue() {}    // 转换成short类型的值
        public int intValue() {}        // 得到int值  该方法加了注解:@HotSpotIntrinsicCandidate
        public float floatValue() {}    // 转换成float类型的值
        public long longValue() {}      // 转换成long类型的值
        public double doubleValue() {}  // 转换成double类型的值
        @Override
        public int hashCode() {}        // int类型的hash值就是它本身
        public String toString() {}     // 转换成字符串
        public int compareTo(Integer anotherInteger) {} // Integer比较大小
        public boolean equals(Object obj) {}    // 对象是否是Integer子类,比较其中的int值是否相等
    
    
        /**
         * 静态方法
         */
        public static int sum(int a, int b) {}      // 两数之和
        public static int max(int a, int b) {}      // 两数中最大值
        public static int min(int a, int b) {}      // 两数中最小值
        public static Integer getInteger(String nm) {}              // 得到值
        public static Integer getInteger(String nm, int val) {}     // 得到值
        public static Integer getInteger(String nm, Integer val) {} // 得到值
        public static int hashCode(int value) {}            // 得到value代表的整数的hash值
        public static int compare(int x, int y) {}          // 比较两数大小
        public static int compareUnsigned(int x, int y) {}  // 比较无符号两数大小
        public static long toUnsignedLong(int x) {}         // x转换为无符号long类型数据
        /**
         * 字符串转int
         * 如果传入的字符串不是数字,以下方法都可能会 throws NumberFormatException
         */
        public static int parseInt(String s) {}                // 字符串转换成int,默认10进制
        public static int parseInt(String s, int radix) {}     // 字符串转成radix值所代表的进制
        public static int parseInt(CharSequence s, int beginIndex, int endIndex, int radix) {}          //
        public static int parseUnsignedInt(String s) {}       // 解析字符串代表的无符号整数,默认10进制
        public static int parseUnsignedInt(String s,int radix){} // 解析字符串代表的无符号整数,radix代表进制
        public static int parseUnsignedInt(CharSequence s, int beginIndex, int endIndex, int radix) {}  //
        @HotSpotIntrinsicCandidate
        public static Integer valueOf(int i) {}             // 得到i的包装对象
        public static Integer valueOf(String s) {}          // 得到s转换后的包装对象
        public static Integer valueOf(String s, int radix){}// 得到s转换后,经过radix进制转换的包装对象
        public static Integer decode(String nm) {}          // 根据nm表示的意思(各进制例如:0xAF、正负数:-100)转换为Integer包装类型的数据
    
        /**
         * 转换为各种类型的字符串
         */
        @HotSpotIntrinsicCandidate
        public static String toString(int i) {}                     // 转换为字符串
        public static String toString(int i, int radix) {}          // 按照radix进制转换为字符串
        private static String toStringUTF16(int i, int radix) {}    // 转换为UTF16编码的字符串
        public static String toUnsignedString(int i) {}             // 转换为无符号整数的字符串,默认10进制
        public static String toUnsignedString(int i, int radix) {}  // 按照radix进制转换为无符号整数的字符串
        public static String toHexString(int i) {}                  // 转换为16进制的字符串
        public static String toOctalString(int i) {}                // 转换为10进制的字符串
        public static String toBinaryString(int i) {}               // 转换为2进制的字符串
    
        /**
         * 不常用方法
         */
        public static int divideUnsigned(int dividend, int divisor) {}      // 得到无符号dividend 除于 divisor
        public static int remainderUnsigned(int dividend, int divisor) {}   // 返回余数
        public static int highestOneBit(int i) {}           // 得到最高位的值(十进制)
        public static int lowestOneBit(int i) {}			// 得到最低位的值
        public static int rotateLeft(int i, int distance) {}// 将i的二进制左移distance位
        public static int rotateRight(int i, int distance){}// 将i的二进制右移distance位
        public static int reverse(int i) {}					// 将
        public static int signum(int i) {}					// 得到i的符号位,负数返回-1,正数返回1,0返回0
        @HotSpotIntrinsicCandidate
        public static int numberOfLeadingZeros(int i) {} // 返回二进制中左边0的个数(int类型数据总共32位所以不会超过64)
        @HotSpotIntrinsicCandidate
        public static int numberOfTrailingZeros(int i) {}// 返回二进制中右边0的个数(int类型数据总共32位所以不会超过64)
        @HotSpotIntrinsicCandidate
        public static int bitCount(int i) {}             // 返回i的二进制表示,1的个数
        @HotSpotIntrinsicCandidate
        public static int reverseBytes(int i) {}		 // 将i二进制表示的位按照字节逆序排序(每8位一个byte像数组一样逆序)
    
        @Override
        public Optional<Integer> describeConstable() {}
    
        @Override
        public Integer resolveConstantDesc(MethodHandles.Lookup lookup) {}
    
        /**
         * 外部使用不到的方法
         */
        static int getChars(int i, int index, byte[] buf) {}
        static int stringSize(int x) {}
        private static String toUnsignedString0(int val, int shift) {}
        private static void formatUnsignedInt(int val, int shift, byte[] buf, int len) {}
        private static void formatUnsignedIntUTF16(int val, int shift, byte[] buf, int len) {}
    
    
    }
    
    展开全文
  • 发现做项目的过程中,在数值类型的比较上容易犯错,特别是IntegerInteger的比较,Integer和int的比较。虽然这些都是些基础语法,但稍不留意就容易犯错,在实际开发过程中如果出现这类失误,很容易失之毫厘谬以千里...

    发现做项目的过程中,在数值类型的比较上容易犯错,特别是Integer和Integer的比较,Integer和int的比较。虽然这些都是些基础语法,但稍不留意就容易犯错,在实际开发过程中如果出现这类失误,很容易失之毫厘谬以千里。在这里,总结下这些基础知识点。

    java虽然宣称一切都是对象,但原始数据类型是例外。int是整形数字,是java的9个原始数据类型(Primitive Types)(boolean、byte、short、char、int、float、double、long、void)之一。Integer是int对应的包装类,它有一个int类型的字段存储数据,并且提供了基本操作,比如数学运算、int和字符串之间转换等。在java 5中引入了自动装箱和自动拆箱功能(boxing/unboxing),java可以根据上下文,自动进行转换,极大地简化了相关编程。javac自动把装箱转换为Integer.valueOf(),把拆箱替换为Integer.intValue()

    自动装箱实际上算是一种语法糖。什么是语法糖?可以简单理解为java平台为我们自动进行了一些转换,保证不同的写法在运行时等价,他们发生在编译阶段,也就是生产的字节码是一致的。(此句摘自极客时间专栏)

    原始数据类型的变量,需要使用并发相关手段才能保证线程安全。如果有线程安全的计算需要,建议考虑使用类似AtomicInteger、AtomicLong这样的线程安全类。

    原始数据类型和java泛型并不能配合使用。因为java的泛型某种程度上可以算作伪泛型,它完全是一种编译期的技巧,java编译期会自动将类型转换为对应的特定类型。这就决定了使用泛型,必须保证相应类型可以转换为Object。

    废话不多说,直接来demo,这样效果更直接。

    public class Test {
    
    	public static void main(String[] args) {
    		
    		Integer a1 = 6;
    		Integer a2 = 6;
    		int a11 = 6;
    		
    		System.out.println(a1 == a2); //true
    		System.out.println(a1 == a11); //true
    		
    		System.out.println("----------------");
    		
    		Integer a3 = 128;
    		Integer a4 = 128;
    		int a33 = 128;
    		
    		System.out.println(a3 == a4); //false
    		//Integer会自动拆箱为int,所以为true
    		System.out.println(a3 == a33); //true
    		System.out.println(a3.equals(a4)); //true
    		
    		System.out.println("----------------");
    		
    		Integer a5 = new Integer(6);
    		Integer a6 = new Integer(6);
    		
    		System.out.println(a5 == a6); //false
    		System.out.println(a5.equals(a6)); //true
    
    	}
    

    需要明确的一点是,包装型(Integer)和基本型(int)比较会自动拆箱(jdk1.5以上)。

    在这里很多人比较容易迷惑的是如下情况:

    		Integer a1 = 6;
    		Integer a2 = 6;
    		System.out.println(a1 == a2); //true
    		
    		Integer a3 = 128;
    		Integer a4 = 128;
    		System.out.println(a3 == a4); //false
    

    如果研究过jdk源码,你就会发现Integer a3 = 128;在java编译时会被翻译成 Integer a3 = Integer.valueOf(128); 我们再来看看valueOf()的源码就更清晰了。

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

    由以上源码就会发现,对于-128到127之间的数,会进行缓存,Integer a1 = 6时,会将6进行缓存,下次再写Integer a2 = 6;时,就会直接从缓存中取,也就不用new一个对象了,所以a1和a2比较时就为true。但a3和a4是超过范围,会new一个对象,==是进行地址和值比较,是比较两个对象在JVM中的地址,这时a3和a4虽然值相同但地址是不一样的,所以比较就为false了。

    通过上面的分析可知:

    • 两个都不是new出来的Integer,且数值在-128~127之间,用==比较时,基本值相等时为true,否则为false;
    • 两个都是new出来的Integer,为false
    • int和Integer比较,数值相同,用==比较时为true。(因为Integer会自动拆箱为int去比较)

    所有包装类对象之间值的比较,建议使用equals方法比较

    ==判断对象是否同一个。

    Integer var = ?在缓存区间的赋值,会复用已有对象,因此这个区间内的Integer使用==进行判断可通过,但是区间之外的所有数据,则会在上新产生,不会通过。

    因此如果用== 来比较数值,很可能在小的测试数据中通过,而到了生产环境才出问题。

    为了节省内容,对与下列包装对象的两个实例,当他们的基本值相同时,用==判断会为true:

     Boolean  
     Byte  
     Character, \u0000 - \u007f(7f是十进制的127)  
     Integer, -128 — 127  
    

    我们也可以看看其它包装型的缓存情况:

    Boolean:(全部缓存)
    Byte:(全部缓存)
    
    Character(缓存范围'\u0000''\u007F')
    Short(-128127缓存)
    Long(-128127缓存)
    
    Float(没有缓存)
    Doulbe(没有缓存)
    

    如果要比较两个Integer对象的值(均为new的对象),可以通过.intValue()进行转换后来比较,如下:

    		Integer a3 = 128;
    		Integer a4 = 128;
    		System.out.println(a3.intValue() == a4.intValue());
    

    也可以使用equal()来进行比较,如下:

    		Integer a3 = 128;
    		Integer a4 = 128;
    		System.out.println(a3.equals(a4)); //true
    
    展开全文
  • Java进阶(三十五)java int与integer的区别

    万次阅读 多人点赞 2016-07-19 19:26:08
    java int与integer的区别前言 int与integer的区别从大的方面来说就是基本数据类型与其包装类的区别: int 是基本类型,直接存数值,而integer是对象,用一个引用指向这个对象。 1.Java 中的数据类型分为基本数据类型...
  • Java的IntegerInteger比较相等

    千次阅读 2019-07-04 14:34:06
    Integer是包装类(引用数据类型),int是基本数据类型, Integer a=12; Integer b=12; //a==b为true; Integer c=1200; Integer d=1200; //c==d为false; 引用数据类型对比需要用equals()方法对比相等 因Integer...
  • Integer a=1与Integer a=new Integer(1)的区别

    千次阅读 2020-06-25 09:45:57
    Integer a=1; Integer变量指向的是 java 常量池中的对象 new Integer(1); new Integer() 的变量指向堆中新建的对象,两者在内存中的地址不同。 int 变量与 Integer、 int 变量与new Integer() 比较时,只要两个的值是...
  • IntegerIntegerCache使用及分析

    千次阅读 2019-03-27 22:39:55
    IntegerCache为Integer类的缓存类,默认缓存了-128~127的Integer值,如遇到[-128,127]范围的值需要转换为Integer时会直接从IntegerCache中获取,具体如以下源码: public static Integer valueOf(int i) { if (i &...
  • Integer解析

    千次阅读 2018-10-24 23:15:32
    作为一名Java开发,相信大家对于Integer都不会陌生,接下来就其分析下 开箱与装箱   开箱装箱主要针对于Java中出现的几种包装类,比如int与之对应的Integer。通俗一点的理解就是,Integer可以与int自动的相互...
  • 本文将介绍一下Java中关于Integer的缓存知识,首先看一下下面的代码,猜测一下会输出什么结果。 [java] view plain copy /**   * Created by lanxing on 16-3-13.   */  public class ...
  • Integer

    2018-04-18 17:59:17
    Integer类:基本数据类型和对应的包装类类型、Integer包装类的构造方法、int类型和String类型之间的转换、Integer包装类的其他成员方法、Integer包装类的进制转换、Integer包装类的自动拆装箱原理、Integer包装类的...
  • Integer类型值相等判断

    万次阅读 2021-02-01 10:31:45
    本周开发中遇到一个很低级的问题,Integer包装类的相等判断,包装类与基本数据类型的区别,应该大多数人在面试中经常被问到,但是有的时候大家都会烦这些看起来没啥用的东西,面试前还需要去熟悉,博主之前也是这样...
  • 先看一代代码: public static void main(String[] args) { long test = 012; float f = -412; double d = 0x12345678; Integer io1 = 59;... Integer io3 = Integer.valueOf(59); In
  • Object类型转换为Integer类型

    万次阅读 2018-05-25 10:31:40
    有两种写法:Integer.parseInt(obj.toString()); Integer.parseInte(String.valueof(obj));
  • 基本概念的区分: ...3、Integer 实际是对象的引用,当new一个 Integer时,实际上是生成一个指针指向此对象;而 int 则是直接存储数据值 4、Integer的默认值是null,int的默认值是0 Integer、new In...
  • Java基础之int和Integer有什么区别

    万次阅读 多人点赞 2016-12-26 17:47:03
    1 int与Integer的基本使用对比 (1)Integer是int的包装类;int是基本数据类型; (2)Integer变量必须实例化后才能使用;int变量不需要; (3)Integer实际是对象的引用,指向此new的Integer对象;int是直接...
  • Reverse Integer

    千次阅读 2018-06-21 23:44:33
    Reverse Integer Description Reverse Integer Example 1: Input: 123 Output: 321 Example 2: Input: -123 Output: -321 Example 3: Input: 120 Output: 21 note Assume we are dealing with an ...
  • Integer比较

    千次阅读 2014-06-25 13:11:32
    Integer,IntegerCache
  • Java进阶(三十四)Integer与int的种种比较你知道多少?

    万次阅读 多人点赞 2016-07-19 19:17:29
    Integer与int的种种比较你知道多少?前言 如果面试官问Integer与int的区别:估计大多数人只会说到两点:Ingeter是int的包装类,注意是一个类;int的初值为0,Ingeter的初值为null。但是如果面试官再问一下Integer i ...
  • Java中(Integer)127 == (Integer)127和(Integer)129 == (Integer)129表达式 哲理有个大家容易忽视的问题 127就是true 129就是false java堆堆integer做了缓存,范围是-128~127 129越界,需要去重新分配 我的问题是...
  • PLS_INTEGER PLS_INTEGER数据类型保存范围-2147483648到2147483647的有符整数。这种类型的值是通过底层硬件平台的原生整数格式来表示的。 设计PLS_INTEGER数据类型是为了运算速度。在oracle数据库...
  • Java 的Integer、int与new Integer到底怎么回事?

    万次阅读 多人点赞 2016-09-22 16:27:41
    1. int 和Integer在进行比较的时候,Integer会进行拆箱,转为int值与int进行比较。 2. IntegerInteger比较的时候,由于直接赋值的时候会进行自动的装箱,那么这里就需要注意两个问题,一个是-128 3. new Integer(1...
  • Integer a = 1; Integer b = 1; Integer c = 500; Integer d = 500; System.out.println(a == b); System.out.println(c == d); Integer aa=new Integer(10); Integer bb=new Integer(10); int cc=10; System.out.p....
  • Integer与Int

    万次阅读 2019-06-15 19:55:00
    在进行描述之前先给出下面代码,观测结果: package ... /** * created by LMR on 2019/6/15 */ public class IntegetTest { ... public static void main(String[] args) { Integer i = 10; Inte...
  • 一直觉得自己Java基础还不错,但是第一眼看到(Integer)129 == (Integer)129表达式时竟然无法立刻反映过来结果到底是true还是false,不妨先来看一下下面简单的Java程序:package com.csdn.test;public class Main { ...
  • int的默认值为0, * 而Integer的默认值为null * ,即Integer可以区分出未赋值和值为0的区别,int则无法表达出未赋值的情况,例如,要想表达出没有参加考试和考试成绩为0的区别 * ,则只能使用Integer * 。...
  • Integer 16 can have minimum value of -32,768 to 32,767 Integer 32 can have minimum value of -2,147,483,648 to 2,147,483,647 Integer 64 can have minimum value of -very large to very large
  • 1、给Integer赋值时,例如:Integer a = 127;Integer会初始化一个IntegerCache.cache的数组,数组里面存储-128 到 127之间的数字。初始化源码:2、调用valueOf(int i)方法,如果i在-128 到 127之间,就会从Integer...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 243,762
精华内容 97,504
关键字:

integer