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。
收起全文
精华内容
参与话题
问答
  • Java为每个原始类型提供了封装类,Integer是java为int提供的封装类。int的默认值为0,  * 而Integer的默认值为null  * ,即Integer可以区分出未赋值和值为0的区别,int则无法表达出未赋值的情况,例如,要想表达...
    /*
     * int是java提供的8种原始数据类型之一。Java为每个原始类型提供了封装类,Integer是java为int提供的封装类。int的默认值为0,
     * 而Integer的默认值为null
     * ,即Integer可以区分出未赋值和值为0的区别,int则无法表达出未赋值的情况,例如,要想表达出没有参加考试和考试成绩为0的区别
     * ,则只能使用Integer
     * 。在JSP开发中,Integer的默认为null,所以用el表达式在文本框中显示时,值为空白字符串,而int默认的默认值为0,所以用el表达式在文本框中显示时
     * ,结果为0,所以,int不适合作为web层的表单数据的类型。
     * 在Hibernate中,如果将OID定义为Integer类型,那么Hibernate就可以根据其值是否为null而判断一个对象是否是临时的
     * ,如果将OID定义为了int类型,还需要在hbm映射文件中设置其unsaved-value属性为0。
     * 另外,Integer提供了多个与整数相关的操作方法,例如,将一个字符串转换成整数,Integer中还定义了表示整数的最大值和最小值的常量。

     */

    package java基础题目;
    
    /**
     * 问题:要想表达出没有参加考试和考试成绩为0的区别?我们应该用Integer表示还是用int表示?
     */
    public class A2015年6月4日_Integer和int {
    	private static int score;
    	private static Integer score2;
    //	private static boolean ss;
    	public static void main(String[] args) {
    
    		System.out.println("int类型的默认值score2:" + score);// 0
    
    		System.out.println("Integer类型的默认值score:" + score2);// null
    
    		/*
    		 * if(score==null){//报错因为score是int类型的不能和null比较
    		 * 
    		 * }
    		 */
    //		if(ss==true)
    //		score2 = 0;
    		if (score2 == null) {
    			System.out.println("没有参加考试!!!");
    		} else if (score2 == 0) {
    			System.out.println("考试成绩为0分!!!");
    		} else {
    			System.out.println("考试成绩为" + score2);
    		}
    		
    		integer();
    	}
    
    	public static void integer() {
    		String string = "12345";
    		Integer i = Integer.parseInt(string);// 把字符串解析为Integer类型
    		Integer max = Integer.MAX_VALUE;
    		Integer min = Integer.MIN_VALUE;
    		System.out.println("Integer.parseInt(string)=" + i);
    		System.out.println("integer的最大值:"+max+",最小值:"+min);
    	}
    }
    
    
    


    展开全文
  • Integer解析

    千次阅读 2018-10-24 23:15:32
    作为一名Java开发,相信大家对于Integer都不会陌生,接下来就其分析下 开箱与装箱   开箱装箱主要针对于Java中出现的几种包装类,比如int与之对应的Integer。通俗一点的理解就是,Integer可以与int自动的相互...

    作为一名Java开发,相信大家对于Integer都不会陌生,接下来就其分析下

    开箱与装箱

      开箱装箱主要针对于Java中出现的几种包装类,比如int与之对应的Integer。通俗一点的理解就是,Integer可以与int自动的相互转换,这个转换过程对于开发人员来说是透明的,JVM在底层帮我们进行了转化。

    装箱:
    举个栗子:

    Integer i = 10; //Integer i = new Integer(10)
    

    上面的代码实质生成的Integer对象,怎么生成的呢?,在JVM底层,它帮我们调用了Integer.valueOf(int x),这就是所谓的装箱过程。

    拆箱:
    举个栗子:

    int b = i; //int i = Integer.intValue(i)
    

    上面的代码是将Integer i转换为int i,怎么生成的呢?,在JVM底层,它帮我们调用了Integer.intValue(int x),这就是所谓的拆箱过程过程。

    在这里插入图片描述
    在这里插入图片描述

    自动装箱存在的缓存

      相信备战面试的小伙伴,都会知道Integer在一段区域中会进行缓存,这个区间默认是[-127,128]之间。注意奥:缓存只能在自动装箱或者是调用Integer.valueOf(int x)才会有用。

    举个?:

    Integer a = new Integer(11)
    Integer b = new Integer(11)
    a == b ?  // false
    

    为什么为false?,因为ab是两个对象,两个对象用==,当然不相等啊,这比较的是内存地址,hashcode。用equals才是值(value)的比较。

    Integer a = 11
    Integer b = 11
    a == b ?  // true
    

    这里为什么又是true?,因为ab实质是同一个对象,只是引用不同,两者都指向的同一内存地址。前面说到[-127,128]区间,就是当调用Integer.valueOf(int x)(ps:装箱实质就是调用这个方法)时,在这个区间调用都是从缓存中直接拿值,超过这个区间才会创造新的对象。

    下面看下源码:

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

    考虑下如下场景:

      Integer c = Integer.valueOf(100);
      Integer b = new Integer(100);
      b == c ? // false
    

    你怎么讲?第一次调用Integer.valueOf,对象从何而来?是不是觉得很奇怪,low<100<highcache里面的值应该从哪里来?
    思路一:
    当我们每次创建对象的时候,通过值判断如果在区间[low ,high ],我们就将其缓存到cache中,方便下次调用。
    很明显,这样我们第一次调用值从那哪里来?这是一个问题,我想JDK的开发者不会这个蠢吧,hah。
    思路二:
    JVM启动时,在装载类的时候就将其给初始化,依次给[low ,high ]创建对应的对象。这样就解决了第一次调用的问题了。

    看下源码:

      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) {
                    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;
    
                cache = new Integer[(high - low) + 1];
                int j = low;
                for(int k = 0; k < cache.length; k++)
                    cache[k] = new Integer(j++);
    
                // range [-128, 127] must be interned (JLS7 5.1.7)
                assert IntegerCache.high >= 127;
            }
    

    确实是这样处理的,大家有没有注意到一点high写死,而是在静态代码块中才初始化的值,还可以赋值进行变动,这说明了一个问题我们的缓存块是可以调整的,所以说Integer仅仅在区间[-127,128]进行缓存是不准确的,-127是固定边界,high边界是可以调整的。

    注意: -XX:AutoBoxCacheMax=<size>可以调整这个high值的大小。

    举个?:

    
          Integer b = 200;
          Integer c = 200;
          System.out.println(c == b);
         
         Integer a = 400;
         Integer d = 400;
         System.out.println(a == d);
    

    在这里插入图片描述

    进制转换

    Integer中支持多种的进制转换,比如说十进制转换成二进制八进制十六进制。在Integer的进制转换是设计得十分巧妙的,不是像我们所说的那种辗转相除法。下面我们分析一下源码:

    toUnsignedString0函数

    private static String toUnsignedString0(int val, int shift) {
    	 // assert shift > 0 && shift <=5 : "Illegal shift value";
        int mag = Integer.SIZE - Integer.numberOfLeadingZeros(val);
        int chars = Math.max(((mag + (shift - 1)) / shift), 1);
        char[] buf = new char[chars];
    
        formatUnsignedInt(val, shift, buf, 0, chars);
    
        // Use special constructor which takes over "buf".
        return new String(buf, true);
    }
    

    几乎所有的进制转换都离不开这个函数,这个函数通过一个shift来区分二进制、八进制、十六机制,分别由1,3,4表示,你说为啥没有2,当然也是有的只不过内部不提供,需要你自己去调用相关API来自己实现,实现起来也比较方便,直接调用API.

    观察重点:numberOfLeadingZeros与formatUnsignedInt的作用
    numberOfLeadingZeros看函数意思,大概就是寻找0吧,
    贴下源码:

    public static int numberOfLeadingZeros(int i) {
        // HD, Figure 5-6
          if (i == 0)
              return 32;
          int n = 1;
          if (i >>> 16 == 0) { n += 16; i <<= 16; } 
          if (i >>> 24 == 0) { n +=  8; i <<=  8; }
          if (i >>> 28 == 0) { n +=  4; i <<=  4; }
          if (i >>> 30 == 0) { n +=  2; i <<=  2; }
          n -= i >>> 31;
          return n;
    }
    

    这段代码设计的十分巧妙,起初看的时候一脸懵逼,后来慢慢才发现一些蛛丝马迹。这是一个二分搜索:
    用来寻找i最高非0位左边存在的0的个数。
    大概逻辑就是:

    1. 先对i进行无符号右移16位判断(移走低16位,剩下高16位),如果这个i全部包含在低16位中,那么我们需要加上16。然后才是真正的移位。如果不包含,那么我们直接考虑高16位。
    2. 第一步舍去一半了,剩下的我们继续进行二分,与步骤1一样。
    3. 一直重复到还剩下两位,二分情况就是:(16,8,4,2)
    4. n -= i >>> 31; 通过对最后两位判断,如果首位为1那么我们需要减去初始的n=1,如果首位为0那么我们什么都不错,这个0在初始的时候就已经加上了。

    chars 代表的是char的个数,mag代表的是除去前面0的个数

    int chars = Math.max(((mag + (shift - 1)) / shift), 1);
    

    为什么是(mag + (shift - 1)) / shift,这是防止chars为0,我们需要chars至少为1,当mag=1时,((mag + (shift - 1)) / shift)是为1的。我们使用shift - 1

    formatUnsignedInt解析

    static int formatUnsignedInt(int val, int shift, char[] buf, int offset, int len) {
        int charPos = len;
          int radix = 1 << shift;
          int mask = radix - 1;
          do {
              buf[offset + --charPos] = Integer.digits[val & mask];
              val >>>= shift;
          } while (val != 0 && charPos > 0);
    
          return charPos;
      }
    

    重点在于mask,取移位后的反码,当shift为4时,则mask=1111,我们通过val & mask4位4位的截取,就是16进制,1100这样为一组.
    charPos为什么从高往低处自减?
    11111111对应的就是FF,截取的顺序是从右到左,所以我们需要从高到低位的设置char[]的值

    展开全文
  • Java中的Integer

    千次阅读 2019-05-03 15:20:27
    常见对象(Integer类的概述和构造方法) 如果有两个需求: 需求: a: 将100转换成二进制, 八进制, 十六进制 b: 判断一个数是否在int的范围内 当然,可以使用最基本的方法累除来求一个十进制数的其他进制,也可以...

    常见对象(Integer类的概述和构造方法)

    如果有两个需求:
    需求:

    1. 将100转换成二进制, 八进制, 十六进制

    2. 判断一个数是否在int的范围内

    当然,可以使用最基本的方法累除取余来求一个十进制数的其他进制形式,也可以根据是否在int型数据的范围来判断这个数是否在int的范围内,我们不能使用int型变量.方法来调用一些现成的方法,但是Java为了我们更方便的去操作基本数据类型,给我们提供与之对应的包装类型

    基本类型 包装类型
    byte Byte
    short Short
    int Integer
    long Long
    float Float
    double Double
    char Character
    boolean Boolean

    Integer类概述:
    在Java中,可能会使用到int类型的数据,但可能会有所要求:比如只能使用引用数据类型,但是由于int类型是基本数据类型,无法直接使用,所以需要进行包装,这就引入了Integer类,其他基本数据类型的包装类也是这样

    Integer 类在对象中包装了一个基本类型 int 的值,该类提供了多个方法,能在 int 类型和 String 类型之间互相转换,还提供了处理 int 类型时非常有用的其他一些常量和方法

    用Integer类解决上述的两个需求:(省略主方法)

    int num=100;
    String string = Integer.toBinaryString(num);
    String string1 = Integer.toOctalString(num);
    String string2 = Integer.toHexString(num);
    

    通过调用Integer类的静态方法可以直接将一个int型整数转换为相应的二进制、八进制以及十六进制并且返回结果的字符串形式,我们通过查阅API可以知道上面的静态方法的格式

    1. static String toBinaryString(int i), 以二进制(基数 2)无符号整数形式返回一个整数参数的字符串表示形式。
    2. static String toHexString(int i), 以十六进制(基数 16)无符号整数形式返回一个整数参数的字符串表示形式。
    3. static String toOctalString(int i),以八进制(基数 8)无符号整数形式返回一个整数参数的字符串表示形式。

    通过查阅得到上面的方法的状态修饰符是static,所以这些方法都是静态方法,可以直接通过类名来调用

    当然在Integer类中还存在一些常量,可以直接通过类来调用常量来判断一个数据是否在int的范围内

    boolean b= 100000>=Integer.MIN_VALUE&& 100000<=Integer.MAX_VALUE?true:false;
    System.out.println(b);
    

    这里不再赘述

    Integer类的构造方法

    Integer( int value),构造一个新分配的 Integer 对象,它表示指定的 int 值。
    Integer(String s),构造一个新分配的 Integer 对象,它表示 String 参数所指示的 int 值,这里需要一个字面上是数字的字符串
    

    常见对象(String和int类型的相互转换)

    int --> String

    1. ""(空字符串)进行拼接,在我之前的博客中使用打印方法时一直在这样使用

    2. static String valueOf(int i)String类中的静态方法,可以返回 int 参数的字符串表示形式。由于是静态方法,可以直接使用类名来调用

    3. static String toString(int i) ,这是Integer类中的静态方法,可以返回一个表示指定整数的 String 对象。

    String --> int

    1. String --> Integer --> intValue();

    2. static int parseInt(String s) ,将字符串参数作为有符号的十进制整数进行解析,返回一个和字面值一样的int型数据

    上述讲解的代码实现:

    int ----->String

    int num=100;
    String str=num+"";
    String s1 = String.valueOf(num);
    String s = new Integer(num).toString();
    

    String ----->int (必须字符串的字面值是数字)

    String str2="50";
    

    方式1

    Integer integer = new Integer(str2); //调用第二种构造方法
    int i = integer.intValue();//将包装类型,转换成他所对应的基本类型
    System.out.println(i+1);
    

    方式2

    int i1 = Integer.parseInt(str2);      //直接使用Integer中的静态方法,实现起来更加方便
    System.out.println(i1);
    

    常见对象(JDK5的新特性自动装箱和拆箱)

    JDK5的新特性
    自动装箱:把基本类型转换为包装类类型
    自动拆箱:把包装类类型转换为基本类型
    代码示例:

    package org.westos.demo3;
    
    /**
     * @Author: Administrator
     * @CreateTime: 2019-05-01 11:22
     */
    public class MyTest {
        public static void main(String[] args) {
            Integer ii = 100;//自动装箱
            ii += 200;//自动拆箱。自动装箱
    
            Integer integer = new Integer(1000);
            int i = integer.intValue(); //手动拆箱
    
            Integer integer1 = Integer.valueOf(100);//手动装箱
            Integer integer2 = Integer.valueOf("10000");
        }
    }
    

    在上述代码中存在自动装箱、自动拆箱、手动装箱以及手动拆箱:

    注意事项
    在使用时,Integer x = null;代码就会出现NullPointerException。
    建议先判断是否为null,然后再使用。

    常见对象(Integer的面试题)

    A:Integer的面试题
    	看程序写结果
    	
    	Integer i1 = new Integer(127);
    	Integer i2 = new Integer(127);
    	System.out.println(i1 == i2);
    	System.out.println(i1.equals(i2));
    	System.out.println("-----------");
    
    	Integer i3 = new Integer(128);
    	Integer i4 = new Integer(128);
    	System.out.println(i3 == i4);
    	System.out.println(i3.equals(i4));
    	System.out.println("-----------");
    
    	Integer i5 = 128;
    	Integer i6 = 128;
    	System.out.println(i5 == i6);
    	System.out.println(i5.equals(i6));
    	System.out.println("-----------");
    
    	Integer i7 = 127;
    	Integer i8 = 127;
    	System.out.println(i7 == i8);
    	System.out.println(i7.equals(i8));
    
    1. 由于我们要经常使用Integer类,所以他会提前为int型创建-128~127一共256个对象,如果在自动装箱的时候给局部变量int型值是在上面的范围之中,就会直接将之前创建好的对象的地址值赋给等号左边的局部变量,

    2. new一个对象不同,如果new就会在堆内存开辟空间,new两次就开辟两段空间,两段空间地址值一定不一样,所以System.out.println(i1 == i2);的执行结果为false

     public boolean equals(Object obj) {
            if (obj instanceof Integer) {
                return value == ((Integer)obj).intValue();
            }
            return false;
     }
    

    Integer类中的equals方法定义如上述代码所示,value是个成员变量,被final修饰,所以是个常量

    private final int value;
    

    参数为int型的构造方法如下面代码所示:

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

    所以equals方法比较的是两个Integer类是对象的内容的大小,所以通过上面的讲解可以知道,在执行完System.out.println(i1.equals(i2));语句后,运行结果为true

    1. 再来看一下第2条所提到的:如果new就会在堆内存开辟空间,new两次就开辟两段空间,两段空间地址值一定不一样,所以在执行完System.out.println(i3 == i4);语句后,肯定打印的是false,因为不在指向同一个对象了

    2. 但是System.out.println(i3.equals(i4));执行结果依然为true,因为两个对象中所存储的内容的大小一样

    System.out.println(i5 == i6);
    System.out.println(i5.equals(i6));
    

    在第一条中提到过,如果在自动装箱的时候给局部变量int型值是在上面的范围之中,就会直接将之前创建好的对象的地址值赋给等号左边的局部变量,但是上述代码中在自动装箱时的int型值不在上述范围内,所以会重新new对象,既然会new,那么就不再指向同一个对象了,所以System.out.println(i5 == i6);执行结果为false

    因为内容一样,所以 System.out.println(i5.equals(i6));结果为true

    1. 经过上述讲解可知最后两条语句执行结果都为true
    展开全文
  • int和Integer有什么区别?

    千次阅读 2018-07-26 20:37:38
    无意中又看到了这个问题,今天总结一下  一、 int就是我们常说的java八大(primitive types : blooean、 byte 、 short 、 char 、int 、 float 、 double 、 long)原始数据类型之一。java虽然号称一切皆对象但是...

    无意中又看到了这个问题,今天总结一下

        一、  int就是我们常说的java八大(primitive types : blooean、 byte 、 short 、 char 、int 、 float 、 double 、 long)原始数据类型之一。java虽然号称一切皆对象但是基本数据类型是例外。

    【八种基本数据类型的包装类】

    byte ——Byte

    short ——Short

    int ——Integer

    long-----Long

    float-----Float

    double----Double 

    char----Character

    boolean---Boolean

    4.2.1. Integral Types and Values

    The values of the integral types are integers in the following ranges:

    • For byte, from -128 to 127, inclusive
    • For short, from -32768 to 32767, inclusive
    • For int, from -2147483648 to 2147483647, inclusive
    • For long, from -9223372036854775808 to 9223372036854775807, inclusive
    • For char, from '\u0000' to '\uffff' inclusive, that is, from 0 to 65535

     

    Integer是int对应的包装类,在 Java 5 中,引入了自动装箱和自动拆箱功能(boxing/unboxing),Java 可以根据上下文,自动进行转换,极大地简化了相关编程。

    关于 Integer 的值缓存,这涉及 Java 5 中另一个改进。构建 Integer 对象的传统方式是直接调用构造器,直接 new 一个对象。但是根据实践,我们发现大部分数据操作都是集中在有限的、较小的数值范围,因而,在 Java 5 中新增了静态工厂方法 valueOf,在调用它的时候会利用一个缓存机制,带来了明显的性能改进。按照 Javadoc,这个值默认缓存是 -128 到 127 之间。

     

     

    二、那么为什么会有这个设计呢?

          原始数据类型和 Java 泛型并不能配合使用,也就是Primitive Types 和Generic 不能混用,于是JAVA就设计了这个auto-boxing/unboxing机制,实际上就是primitive value 与 object之间的隐式转换机制,否则要是没有这个机制,开发者就必须每次手动显示转换,那多麻烦是不是?但是primitive value 与 object各自有各自的优势,primitive value在内存中存的是值,所以找到primitive value的内存位置,就可以获得值;不像object存的是reference,找到object的内存位置,还要根据reference找下一个内存空间,要产生更多的IO,所以计算性能比primitive value差,但是object具备generic的能力,更抽象,解决业务问题编程效率高。于是JAVA设计者的初衷估计是这样的:如果开发者要做计算,就应该使用primitive value如果开发者要处理业务问题,就应该使用object,采用Generic机制;反正JAVA有auto-boxing/unboxing机制,对开发者来讲也不需要注意什么。然后为了弥补object计算能力的不足,还设计了static valueOf()方法提供缓存机制,算是一个弥补。

     

     

    三、再说一下关于缓存的问题

    关于 Integer 的值缓存,这涉及 Java 5 中另一个改进。构建 Integer 对象的传统方式是直接调用构造器,直接 new 一个对象。但是根据实践,我们发现大部分数据操作都是集中在有限的、较小的数值范围,因而,在 Java 5 中新增了静态工厂方法 valueOf,在调用它的时候会利用一个缓存机制,带来了明显的性能改进。按照 Javadoc,这个值默认缓存是 -128 到 127 之间。

    源码:[

    This method will always cache values in the range -128 to 127,

    * inclusive, and may cache other values outside of this range.

     

    public static Integer valueOf(int i) {

    if (i >= IntegerCache.low && i <= IntegerCache.high)

    return IntegerCache.cache[i + (-IntegerCache.low)];

    return new Integer(i);

    }

    ]

    面试题:

    Integer i1=123;

    Integer i2=123;

    System.out.println(i1==i2);//true

    Integer i3=128;

    Integer i4=128;

    System.out.println(i3==i4);//false

    解析:“==”对于引用类型比较的是对象地址是否相同,

    JVM会自动维护八种基本类型的常量池,int常量池中初始化-128~127的范围,所以当为Integer i=127时,在自动装箱过程中是取自常量池中的数值,而当Integer i=128时,128不在常量池范围内,所以在自动装箱过程中需new 128,所以地址不一样。

    Integer i1=new Integer(123);

    Integer i2=new Integer(123);

    System.out.println(123==i1);//true

    System.out.println(i1==i2);//false

     

    Integer i3=new Integer(128);

    Integer i4=new Integer(128);

    System.out.println(i3==i4);//false

    System.out.println(128==i3);//true

    解析:以上结果说明:

    a.当数值范围为-128~127时:如果两个new出来Integer对象,即使值相同,通过“==”比较结果为false,但两个对象直接赋值,则通过“==”比较结果为“true,这一点与String非常相似。

    b.当数值不在-128~127时,无论通过哪种方式,即使两个对象的值相等,通过“==”比较,其结果为false;

    c.当一个Integer对象直接与一个int基本数据类型通过“==”比较,其结果与第一点相同;

    d.Integer对象的hash值为数值本身;

     

    源码:/** 

    1.    * Returns a hash code for this {@code Integer}. 
    2.    * 
    3.    * @return  a hash code value for this object, equal to the 
    4.    *          primitive {@code int} value represented by this 
    5.    *          {@code Integer} object. 
    6.    */  
    7.   public int hashCode() {  
    8.       return value;  
    9.   }  

    Integer重写了hashCode方法,返回值是value,即Integer对象 的数值。

     

    第二个问题,为什么Integer对象的范围是-128~127?

    查看Integer类源码,发现里面有一个私有的静态内部类IntegerCache,而如果直接将一个基本数据类型的值赋给Integer对象,则会发生自动装箱,其原理就是通过调用Integer类的public static Integer valueOf(将int类型的值包装到一个对象中 ,其部分源码如下:

    1. /** 
    2.     * Cache to support the object identity semantics of autoboxing for values between 
    3.     * -128 and 127 (inclusive) as required by JLS. 
    4.     * 
    5.     * The cache is initialized on first usage.  The size of the cache 
    6.     * may be controlled by the -XX:AutoBoxCacheMax=<size> option. 
    7.     * During VM initialization, java.lang.Integer.IntegerCache.high property 
    8.     * may be set and saved in the private system properties in the 
    9.     * sun.misc.VM class. 
    10.     */  
    11.   
    12.    private static class IntegerCache {  
    13.        static final int low = -128;  
    14.        static final int high;  
    15.        static final Integer cache[];  
    16.   
    17.        static {  
    18.            // high value may be configured by property  
    19.            int h = 127;  
    20.            String integerCacheHighPropValue =  
    21.                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");  
    22.            if (integerCacheHighPropValue != null) {  
    23.                int i = parseInt(integerCacheHighPropValue);  
    24.                i = Math.max(i, 127);  
    25.                // Maximum array size is Integer.MAX_VALUE  
    26.                h = Math.min(i, Integer.MAX_VALUE - (-low) -1);  
    27.            }  
    28.            high = h;  
    29.   
    30.            cache = new Integer[(high - low) + 1];  
    31.            int j = low;  
    32.            for(int k = 0; k < cache.length; k++)  
    33.                cache[k] = new Integer(j++);  
    34.        }  
    35.   
    36.        private IntegerCache() {}  
    37.    }  
    38.   ..................  
    39.  ...................  
    40.  ...................  
    41.   
    42.      /** 
    43.     * Returns an {@code Integer} instance representing the specified 
    44.     * {@code int} value.  If a new {@code Integer} instance is not 
    45.     * required, this method should generally be used in preference to 
    46.     * the constructor {@link #Integer(int)}, as this method is likely 
    47.     * to yield significantly better space and time performance by 
    48.     * caching frequently requested values. 
    49.     * 
    50.     * This method will always cache values in the range -128 to 127, 
    51.     * inclusive, and may cache other values outside of this range. 
    52.     * 
    53.     * @param  i an {@code int} value. 
    54.     * @return an {@code Integer} instance representing {@code i}. 
    55.     * @since  1.5 
    56.     */  
    57.    public static Integer valueOf(int i) {  
    58.        assert IntegerCache.high >= 127;  
    59.        if (i >= IntegerCache.low && i <= IntegerCache.high)  
    60.            return IntegerCache.cache[i + (-IntegerCache.low)];  
    61.        return new Integer(i);  
    62.    }  

    我想通过以上的分析,应该知道原因了吧,简要的说就是在Integer类中有一个静态内部类IntegerCache,在IntegerCache类中有一个Integer数组,用以缓存当数值范围为-128~127时的Integer对象。

    注意:可以通过下面这个参数设置最大值

    -XX:AutoBoxCacheMax

    这个属性是在使用Oracle/Sun JDK 6,在server模式下,使用-XX:AutoBoxCacheMax=NNN参数即可将Integer的自动缓存区间设置为[-128,NNN]。注意区间的下界固定在-128不可配置。 

    在client模式下该参数无效。这个参数是server模式专有的,在c2_globals.hpp中声明,默认值是128;不过这个默认值在默认条件下不起作用,要手动设置它的值或者是开启-XX:+AggressiveOpts参数才起作用。

    Cache to support the object identity semantics of autoboxing for values between

    * -128 and 127 (inclusive) as required by JLS.

    *

    * The cache is initialized on first usage. The size of the cache

    * may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option.

    * During VM initialization, java.lang.Integer.IntegerCache.high property

    * may be set and saved in the private system properties in the

    * sun.misc.VM class.

     

     

    展开全文
  • java中int与Integer用==比较详解

    万次阅读 多人点赞 2018-03-19 23:02:04
    前言: 越是简单的东西,我们往往越是没有去把它明白,但我们大部分时间又常常在用,就像我们今天说的int与Integer的使用,我们程序员基本天天都在用,但是我今天没用详细弄清楚之前我也是不清楚,我们来看看这两个...
  • java中int与Integer用==比较详解

    万次阅读 多人点赞 2018-11-21 15:53:25
     越是简单的东西,我们往往越是没有去把它明白,但我们大部分时间又常常在用,就像我们今天说的int与Integer的使用,我们程序员基本天天都在用,但是我今天没用详细弄清楚之前我也是不清楚,我们来看看这两个在用==...
  • int的默认值为0, * 而Integer的默认值为null * ,即Integer可以区分出未赋值和值为0的区别,int则无法表达出未赋值的情况,例如,要想表达出没有参加考试和考试成绩为0的区别 * ,则只能使用Integer * 。...
  • package mytest; public class TestInteger { public static void main(String args[]) ... Integer a =127; Integer b =127; System.out.println(a==b); a=128; b=128; System.out.println(a==b); a...
  • 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...
  • Integer的定义以及一些使用

    千次阅读 2019-04-21 08:47:26
    Integer a=new Integer(3); //声明Integer int aa=a.intValue(); //Integer转int /* * 如果不需要新的 Integer 实例,则通常应优先使用以下方法,.valueOf(int) *而不是构造方法 Integer(int), 因为该方法有可能...
  • Integer

    千次阅读 2016-10-11 23:35:27
    Interger:整数类型 1、属性。 static int MAX_VALUE:返回最大的整型数;  static int MIN_VALUE:返回最小的整型数;...System.out.println(“Integer.MAX_VALUE: ” + Integer.MAX_VALUE );  结果为:In
  • Java进阶(三十五)java int与integer的区别

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

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

    千次阅读 2017-03-15 15:52:21
    int from = Integer.valueOf(range.getFrom()); int from = Integer.parseInt(range.getFrom()); 我看我们项目里面很多是第一种写法,那么有什么区别呢? Integer.valueOf的源代码是这样的: public static...
  • 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[]; ... } ...
  • java int 类整数的最大值是 2 的 31 次方 - 1...可以用 Integer.MAX_VALUE 表示它,即 int value = Integer.MAX_VALUE; Integer.MAX_VALUE + 1 = Integer.MIN_VALUE = -2147483648 再大的数就要用 long (最大值...
  • java Integer常用方法详解

    千次阅读 2019-08-27 11:50:28
    先来Integer吧 package com.String; //封装类 /* * 比如int对应的类是Integer 这种类就叫做封装类 */ public class Damo { static void m1() { // Integer 的构造函数 Integer it1 = new Integer(5);// ...
  • 彻底让你明白 Integer 类和 int 基本数据类型的区别

    万次阅读 多人点赞 2018-02-01 16:46:33
    1、Integer 类简介2、Integer 类和 int 的区别3、Integer 的自动拆箱和装箱  ①、自动装箱 ②、自动拆箱 4、回顾开头的问题5、测试    突然发现自己对Integer i = 10;这种语法不太明白,于是乎有了这...
  • Integer详细讲解 十进制转成二进制 十进制转八进制 十进制转十六进制 十六进制转成十进制 十六进制转成二进制 十六进制转成八进制 八进制转成十进制 八进制转成二进制 八进制转成十六进制 二进制转十进制 二进制转八...
  • INTEGER PRIMARY KEY简介

    万次阅读 2011-10-31 15:23:04
    Sqlite 中INTEGER PRIMARY KEY AUTOINCREMENT和rowid/INTEGER PRIMARY KEY的使用 在用sqlite设计表时,每个表都有一个自己的整形id值作为主键,插入后能直接得到该主键. 因为sqlite内部本来就会为每个表加上...

空空如也

1 2 3 4 5 ... 20
收藏数 1,973,120
精华内容 789,248
关键字:

integer