integer_integers - CSDN
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-11-07 11:50:35
    作为一名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[]的值

    展开全文
  • int和Integer有什么区别?

    千次阅读 2018-07-26 20:39:09
    无意中又看到了这个问题,今天总结一下  一、 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-05-19 16:28:54
    前言: 越是简单的东西,我们往往越是没有去把它明白,但我们大部分时间又常常在用,就像我们今天说的int与Integer的使用,我们程序员基本天天都在用,但是我今天没用详细弄清楚之前我也是不清楚,我们来看看这两个...

    前言:

        越是简单的东西,我们往往越是没有去把它明白,但我们大部分时间又常常在用,就像我们今天说的int与Integer的使用,我们程序员基本天天都在用,但是我今天没用详细弄清楚之前我也是不清楚,我们来看看这两个在用==号比较给我们带来的疑问。

            先看看下面的代码,看看我们是否都会

            @Test
    	public void testEquals() {
    		int int1 = 12;
    		int int2 = 12;
    		
    		Integer integer1 = new Integer(12);
    		Integer integer2 = new Integer(12);
    		Integer integer3 = new Integer(127);
    		
    		Integer a1 = 127;
    		Integer a2 = 127;
    		
    		Integer a = 128;
    		Integer b = 128;
    			
    		System.out.println("int1 == int2 -> " + (int1 == int2));					
    		System.out.println("int1 == integer1 -> " + (int1 == integer1));			
    		System.out.println("integer1 == integer2 -> " + (integer1 == integer2));	
    		System.out.println("integer3 == a1 -> " + (integer3 == a1));				
    		System.out.println("a1 == a2 -> " + (a1 == a2));							
    		System.out.println("a == b -> " + (a == b));													
    	}   

    答案是:
    1、   int1 == int2 -> true
    2、   int1 == integer1 -> true
    3、   integer1 == integer2 -> false
    4、   integer3 == a1 -> false
    5、   a1 == a2 -> true
    6、   a == b -> false
    

    看看结果跟我们自己做的是不是都一样。

            下面我们就来详细解释一下,为什么是上面的结果。(下面的序号就是对应的是上面的答案序号)

              1、int1 == int2 为true,这个我就讲了,这个都知道

              2、int1 == integer1,Integer是int的封装类,当Integer与int进行==比较时,Integer就会拆箱成一个int类型,所以还是相当于两个int类型进行比较,这里的Integer,不管是直接赋值,还是new创建的对象,只要跟int比较就会拆箱为int类型,所以就是相等的。

              3、integer1 == integer2 -> false,这是两个都是对象类型,而且不会进行拆箱比较,所以不等

              4、integer3 == a1 -> false , integer3是一个对象类型,而a1是一个常量它们存放内存的位置不一样,所以也不等,具体存在内存的位置看以看文章:点击打开链接

              5、6   看起来是一模一样的为什么一个是true,一个是false,这是因为Integer作为常量时,对于-128到127之间的数,会进行缓存,也就是说int a1 = 127时,在范围之内,这个时候就存放在缓存中,当再创建a2时,java发现缓存中存在127这个数了,就直接取出来赋值给a2,所以a1 == a2的。当超过范围就是new Integer()来new一个对象了,所以a、b都是new Integer(128)出来的变量,所以它们不等。

    根据以上总结:

        

            ①、无论如何,Integer与new Integer不会相等。不会经历拆箱过程,因为它们存放内存的位置不一样。(要看具体位置,可以看看这篇文章:点击打开链接

            ②、两个都是非new出来的Integer,如果数在-128到127之间,则是true,否则为false。

            ③、两个都是new出来的,则为false。

           ④、int和integer(new或非new)比较,都为true,因为会把Integer自动拆箱为int,其实就是相当于两个int类型比较。


    展开全文
  • 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的区别

    2018-11-19 11:25:48
    先看下面的一段代码: public class IntegerTest { public static void main(String[] args){ Integer a=new Integer(1); Integer b=new Integer(2); Integer c=new Integer(3); Intege...
  • Java中的Integer

    千次阅读 2019-05-04 18:48:37
    常见对象(Integer类的概述和构造方法) 如果有两个需求: 需求: a: 将100转换成二进制, 八进制, 十六进制 b: 判断一个数是否在int的范围内 当然,可以使用最基本的方法累除来求一个十进制数的其他进制,也可以...
  • int的默认值为0, * 而Integer的默认值为null * ,即Integer可以区分出未赋值和值为0的区别,int则无法表达出未赋值的情况,例如,要想表达出没有参加考试和考试成绩为0的区别 * ,则只能使用Integer * 。...
  • Java中int和Integer的区别

    千次阅读 2019-05-03 18:02:43
    1.int是基本数据类型,int变量存储的是数值。Integer是引用类型,实际是一个对象,Integer存储的是引用对象的地址。 2. Integer i =newInteger(100); Integer j =newInteger(100); System.o...
  • 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-24 08:18:51
    Integer a=new Integer(3); //声明Integer int aa=a.intValue(); //Integer转int /* * 如果不需要新的 Integer 实例,则通常应优先使用以下方法,.valueOf(int) *而不是构造方法 Integer(int), 因为该方法有可能...
  • 判断Integer类型等于null

    万次阅读 2018-03-28 23:57:50
    如果在后面判断int 类需==null 或!=null的情况下,可以将int类型改为Integer类型
  • Java中Integer和int之间的转换

    万次阅读 2018-05-08 10:09:29
    本文转载自:http://isnb.blog.163.com/blog/static/194111114201061334935457/int到...Integer A=new Integer(a);或:Integer A=Integer.valueOf(a);Integer到int:Integer A=new Integer(5);int a=A.intValue();...
  • Java为每个原始类型提供了封装类,Integer是java为int提供的封装类。 int的默认值为0,而Integer的默认值为null,即Integer可以区分出未赋值和值为0的区别,int则无法表达出未赋值的情况,
  • 1、String的非空判断。 StringUtils.isNotEmpty(String str); 2、Integer的非空判断。 null != Integer ; 3、list的大小判断。 list.size() == 0 4、对象的非空判断 null != object
  • Java中Integer的最大值和最小值

    万次阅读 多人点赞 2017-11-15 09:38:30
    Java中Integer的最大值和最小值 . Java Byte的最大值和最小值 . Java float的最大值和最小值 . Java long的最大值和最小值 .
  • Object类型转换为Integer类型

    万次阅读 2020-03-26 17:44:19
    有两种写法:Integer.parseInt(obj.toString()); Integer.parseInte(String.valueof(obj));
  • java-String与Integer的相互转化

    万次阅读 2017-12-10 13:37:48
    一、Integer转String //方法一:Integer类的静态方法toString() Integer a = 2; String str = Integer.toString(a) //方法二:Integer类的成员方法toString() Integer a = 2; String str = a.toString(); //方法三:...
  • String与Integer相互转换

    万次阅读 2018-03-07 16:04:03
    一、Integer转String //方法一:Integer类的静态方法toString() Integer a = 2; String str = Integer.toString(a) //方法二:Integer类的成员方法toString() Integer a = 2; String str = a.toString(); //方法...
  • JAVA语言Integer转换为byte

    万次阅读 2012-08-21 08:31:12
    今天需要使用同事定义的函数接口碰到一个问题,eclipse提示Integer无法转换为byte. 后来想到int可以强制转换为byte。于是便思考把Integer先转换为int,然后再转换为byte. Integer itg = 5; byte bt = (byte)itg....
1 2 3 4 5 ... 20
收藏数 1,767,356
精华内容 706,942
关键字:

integer