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 int与integer的区别前言 int与integer的区别从大的方面来说就是基本数据类型与其包装类的区别: int 是基本类型,直接存数值,而integer是对象,用一个引用指向这个对象。 1.Java 中的数据类型分为基本数据...

    Java进阶(三十五)java int与Integer的区别

    前言     

         int与Integer的区别从大的方面来说就是基本数据类型与其包装类的区别:

         int 是基本类型,直接存数值,而Integer是对象,用一个引用指向这个对象。

         1.Java 中的数据类型分为基本数据类型和复杂数据类型

         int 是前者而Integer 是后者(也就是一个类);因此在类进行初始化时int类的变量初始为0.而Integer的变量则初始化为null。

         2.初始化时:

         int i =1;

         Integer i= new Integer(1);(要把Integer 当做一个类看);但由于有了自动装箱和拆箱(始于jdk1.5),使得对Integer类也可使用:Integer i= 1;       

         int 是基本数据类型(面向过程留下的痕迹,不过是对java的有益补充),Integer 是一个类,是int的扩展,定义了很多的转换方法。

        类似的还有:float Float;double Double;boolean Boolean等,而且还提供了处理 int 类型时非常有用的其他一些常量和方法

         举个例子:当需要往ArrayList,HashMap中放东西时,像int,double这种内建类型是放不进去的,因为容器都是装 object的,这是就需要这些内建类型的外覆类了。

         Java中每种内建类型都有相应的外覆类。

         Java中int和Integer关系是比较微妙的。关系如下:

      1.int是基本的数据类型;

      2.Integer是int的封装类;

      3.int和Integer都可以表示某一个数值;

      4.int和Integer不能够互用,因为他们两种不同的数据类型;

      举例说明

      ArrayList al=new ArrayList();

      int n=40;

      Integer nI=new Integer(n);

      al.add(n);//不可以

      al.add(nI);//可以

      并且泛型定义时也不支持int: 如:List<Integer> list = new ArrayList<Integer>();可以  而List<int> list = new ArrayList<int>();则不行。

    总而言之:如果我们定义一个int类型的数,只是用来进行一些加减乘除的运算or作为参数进行传递,那么就可以直接声明为int基本数据类型,但如果要像对象一样来进行处理,那么就要用Integer来声明一个对象,因为java是面向对象的语言,因此当声明为对象时能够提供很多对象间转换的方式与一些常用的方法。自认为java作为一门面向对象的语言,我们在声明一个变量时最好声明为对象格式,这样更有利于你对面向对象的理解。

    注  基本类型与包装类型的异同

         1、在Java中,一切皆对象,但八大基本类型(char,byte,int,double,float,short,long,boolean)却不是对象。

         2、声明方式的不同,基本类型无需通过new关键字来创建,而封装类型需new关键字。

         3、存储方式及位置的不同,基本类型是直接存储变量的值保存在堆栈中能高效的存取,封装类型需要通过引用指向实例,具体的实例保存在堆中。

         4、初始值的不同,封装类型的初始值为null,基本类型的的初始值视具体的类型而定,比如int类型的初始值为0(整数:包括int,short,byte,long ,初始值为0),boolean类型为false,浮点型:float,double ,初始值为0.0,字符:char ,初始值为空格,即'' ",如果输出,在Console上是看不到效果的。

         5、使用方式的不同,比如与集合类合作使用时只能使用包装类型。

    美文美图

     


    展开全文
  • 一、Integer转String //方法一:Integer类的静态方法toString() Integer a = 2; String str = Integer.toString(a) //方法二:Integer类的成员方法toString() Integer a = 2; String str = a.toString(); //方法三:...

    一、Integer转String

    //方法一:Integer类的静态方法toString()
    Integer a = 2;
    String str = Integer.toString(a)
    
    //方法二:Integer类的成员方法toString()
    Integer a = 2;
    String str = a.toString();
    
    //方法三:String类的静态方法valueOf()
    Integer a = 2;
    String str = String.valueOf(a);
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    1、从Integer类的源码可以看出,Integer的静态方法toString()和成员方法toString()是一样的,成员方法里面仅仅是调用了静态方法而已。如下图所示: 
    这里写图片描述

    通过toString()方法,可以把整数(包括0)转化为字符串,但是Integer如果是null的话,就会报空指针异常。

    2、String.valueOf(Object obj)可以把整型(包括0)转化为字符串,但是Integer如果是null的话,会转化为”null”。从String.valueOf(Object obj)方法的源码可以看出:

     public static String valueOf(Object obj) {
            return (obj == null) ? "null" : obj.toString();
        }
    • 1
    • 2
    • 3

    3、当Integer是null的情况下,我们也希望String是null,上面的方法都没法做到。可以自己写一个方法:

     public static String toString(Object obj) {
            return (obj == null) ? null : obj.toString();
        }
    • 1
    • 2
    • 3

    另外,Apache提供的ObjectUtils.identityToString(Object obj)也可以实现。但是ObjectUtils.toString(Object obj)不行,该方法会把null转化为”“。

    二、String转Integer

    当我们要把String转化为Integer时,一定要对String进行非空判断,否则很可能报空指针异常。

    String str = "...";
    Integer i = null;
    if(str!=null){
         i = Integer.valueOf(str);
    }
    展开全文
  • 1. int 和Integer在进行比较的时候,Integer会进行拆箱,转为int值与int进行比较。 2. IntegerInteger比较的时候,由于直接赋值的时候会进行自动的装箱,那么这里就需要注意两个问题,一个是-128 3. new Integer(1...

    先做一些总结,询问了些经验比较多的师傅,在这里表示感谢,然后自己总结下,今天的收获分享给大家:

    1. int 和Integer在进行比较的时候,Integer会进行拆箱,转为int值与int进行比较。

    2. Integer与Integer比较的时候,由于直接赋值的时候会进行自动的装箱,那么这里就需要注意两个问题,一个是-128<= x<=127的整数,将会直接缓存在IntegerCache中,那么当赋值在这个区间的时候,不会创建新的Integer对象,而是从缓存中获取已经创建好的Integer对象。二:当大于这个范围的时候,直接new Integer来创建Integer对象。

    3. new Integer(1) 和Integer a = 1不同,前者会创建对象,存储在堆中,而后者因为在-128到127的范围内,不会创建新的对象,而是从IntegerCache中获取的。那么Integer a = 128, 大于该范围的话才会直接通过new Integer(128)创建对象,进行装箱。


    实例分析


    先看一个例子。

    public class Test {
    
    	public static void main(String[] args) {
    		
    		Integer i = new Integer(128);
    		Integer i2 = 128;
    		
    		System.out.println(i == i2);
    		
    		Integer i3 = new Integer(127);
    		Integer i4 = 127;
    		System.out.println(i3 == i4);
    		
    		Integer i5 = 128;
    		Integer i6 = 128;
    		System.out.println(i5 == i6);
    		
    		Integer i7 = 127;
    		Integer i8 = 127;
    		System.out.println(i7 == i8);
    	}
    }
    
    输出的结果为

    false
    false
    false
    true
    


    我们一个一个的进行分析。

    第一个情况:

    Integer i = new Integer(128);
    Integer i2 = 128;

    i 是创建的一个Integer的对象,取值是128。
    i2 是进行自动装箱的实例,因为这里超出了-128--127的范围,所以是创建了新的Integer对象。

    那么i和i2都是Integer的对象咯。存储在堆中,分配的地址不同,在使用==进行判读的时候,由于双方都是对象,所以比较对象的地址是不是相同,这里的地址是不同的,因为new的时候会在堆中重新分配存储空间。


    第二个情况:

    Integer i3 = new Integer(127);
    Integer i4 = 127;
    i3 是创建的一个Integer的对象,取值是127.

    i4 是进行自动装箱后生成的Integer的对象,其值-128<= i4 <= 127,所以在这里会与第一种情况有所不同,这个i4对象直接取缓存IntegerCache中的对应的对象,当然了也是对象。

    那么i3和i4也都是对象咯,而且一个是缓存中的,一个自己new的,既然是对象那么==会比较其地址,因为都new出来的对象(一个是自己new出来的,一个是IntegerCache中new出来的对象),那么自然这两种情况下,在堆中分配的地址是不同的。


    第三种情况:

    Integer i5 = 128;
    Integer i6 = 128;

    i5是自动装箱产生的Integer的对象,但是其大小超过了范围:-128<=A <=127,那么,这里会直接自己创建该对象即:new Integer(128);

    i6和i5类似的原理。

    显然这两个对象都是new出来,在堆中的地址值是不同的,那么==的时候判读其地址是不是相等,也就不一样了。


    第四种情况:

    Integer i7 = 127;
    Integer i8 = 127;
    i7、i8是自动装箱产生的对象,其值都是127,那么这里很特殊的是127正好在-128<=i7<=127这个范围内的,那么会去IntegerCache中取,既然都是去IntegerCache中去取,那么自然该对象应该是一个对象,那么再堆中的地址应该是一样的,所以在判读两个对象是不是== 的时候,会输出true


    源码解析

    下面看下,Integer中的装箱的代码



    当不用new Integer的时候,构造方法会通过这个方法来构造对象并返回。那么你看if中的代码就知道了,i>=IntegerCache.low&&i<=IntegerCache.high的时候,从IntegerCache中获取的实例,否则,直接new Integer(i);


    下面就是IntegerCache的代码,其中low就是-128,high是默认的127,不过可以进行设置。

    通过静态代码块直接创建了256个Integer的对象,从-128到127之间。

    所以在第四种情况中,取出来的时候,都是经过了上面的return IntegerCache.cache[i + (-IntegerCache.low)]得到的最终的对象,因为在IntegerCache中是创建好的,不会从新new了,所以地址值是一样的,也就是同一个对象,所以为true。



    转载请注明出处:Java 的Integer、int与new Integer到底怎么回事?


    展开全文
  • 发现做项目的过程中,在数值类型的比较上容易犯错,特别是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
    
    展开全文
  • int的默认值为0, * 而Integer的默认值为null * ,即Integer可以区分出未赋值和值为0的区别,int则无法表达出未赋值的情况,例如,要想表达出没有参加考试和考试成绩为0的区别 * ,则只能使用Integer * 。...
  • 本文转载自: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();...
  • 1.IntegerInteger.valueOf()的比较分析 Integer x = 394; Integer x1 = Integer.valueOf(&amp;amp;quot;394&amp;amp;quot;); if(x==x1){ //执行代码 } 如上面代码所示:我在做数据转换并进行...
  • 一、使用new Integer()创建的对象Integer i=new Integer(50);Integer j=new Integer(50);System.out.println(i==j); //运行的结果是false我们可以看到程序运行的结果是false,这不难理解,我们执行了两次new,所以...
  • Integer是Int的封装,即Integer其实是一个对象。可以通过new来创建一个Integer对象,也可以直接将Int值赋给Integer变量。它们之间的区别如下: 一:Int Int是Java八种基本数据类型之一,一般大小为4字节32位,...
  • String与Integer的相互转化的方式大概有三种:1、从Integer类的源码可以看出,Integer的静态方法toString()和成员方法toString()是一样的,成员方法里面仅仅是调用了静态方法而已。如下图所示: 通过toString()方法...
  • 今天在开发中判断两个Integer值相等, Integer a = 3; Duixiang duixiang = new Duixiang(); duixiang = DAO.getDuixiang(); Integer b = duixiang.getB(); System.out.print(a == b...
  • 这个没什么好说的,感觉大家看完代码和结果就应该明白了,很简单,但是容易混 代码如下-------------------------------- ...Integer i5 = new Integer(100); Integer i6 = new Integer(100); Integer i7 = ...
  • 首先需要注意的是 f1、f2、f3、f4 四个变量都是 Integer 对象引用,所以下面的==运算比较的不是值而是引用。装箱的本质是什么呢?当我们给一个 Integer 对象赋一个 int 值的时候,会调用 Integer 类的静态方法 value...
  • Integer与int的种种比较你知道多少?前言 如果面试官问Integer与int的区别:估计大多数人只会说到两点:Ingeter是int的包装类,注意是一个类;int的初值为0,Ingeter的初值为null。但是如果面试官再问一下Integer i ...
  • 在使用Navicat for MySQL还原数据库备份时,出现Incorrect integer value: '' for column 'id' at row 1的错误; 网上查资料发现5以上的版本如果是空值应该要写NULL这种问题一般mysql 5.x上出现。使用Select version...
  • java int 类整数的最大值是 2 的 31 次方 - 1...可以用 Integer.MAX_VALUE 表示它,即 int value = Integer.MAX_VALUE; Integer.MAX_VALUE + 1 = Integer.MIN_VALUE = -2147483648 再大的数就要用 long (最大值...
  • 昨天在开发中遇到一个问题,定义了两个Integer变量,暂且定义为Integer a; Integer b; 这两个值由前端赋值并传到后台,前台传的是a = 12345, b = 12345, 但我在后台比较的时候 if (a == b),却返回false,好无语啊...
  • Integer和int的区别

    2018-10-25 21:31:26
    Integer是int的包装类, int是基本数据类型 最主要的区别就是这句 一个是基本数据类型, 一个是类, 但其实其中隐含的细节很多,比如: Integer的默认初始值是null,而int的默认初试值是0。 Integer变量必须先实例,...
  • int和Integer的区别 1、Integer是int的包装类,int则是java的一种基本数据类型 2、Integer变量必须实例化后才能使用,而int变量不需要 3、Integer实际是对象的引用,当new一个Integer时,实际上是生成一个指针指向此...
  • Int和Integer的区别

    2019-11-07 15:01:06
    Int和Integer的区别 1、Integer是Int的包装类,Int是八种基本数据类型之一。 2、Integer变量必须实例化以后才可以使用,而Int变量不需要实例化。 3、Integer实际是对象的引用,当new一个Integer时,实际上是生成一个...
1 2 3 4 5 ... 20
收藏数 1,718,325
精华内容 687,330
关键字:

integer