精华内容
下载资源
问答
  • 一、基本数据类型和引用类型 Java是面向对象的语言,一切都是对象,但是为了编程的方便还是引入了基本数据类型,为了能够将这些基本数据类型当成对象操作,java为每一个基本数据类型都引入了对应的包装类型,int的...

    一、基本数据类型和引用类型

    Java是面向对象的语言,一切都是对象,但是为了编程的方便还是引入了基本数据类型,为了能够将这些基本数据类型当成对象操作,java为每一个基本数据类型都引入了对应的包装类型,int的包装类就是Integer,从java5开始引入了自动装箱/拆箱机制,使得二者可以互项转换,对应如下

    原始类型:
    boolean, char, byte, short, int ,long, float, double
    包装类型:
    Boolean, Character, Byte, Short, Integer, Long, Float, Double

    二、基本数据类型和引用类的区别(以int和Integer为例)

    1. Integer是int的包装类,int则是java的一种基本数据类型
    2. Integer变量必须实例化后才能使用,而int变量不需要
    3. Integer实际是对象的引用,当new一个Integer时,实际上是生成一个指针指向这个对象;而int则是直接存储数据值
    4. Integer的默认值是null,int的默认值是0

    延伸:

    1. 由于Integer变量实际上是对一个Integer对象的引用,所以两个通过new生成的Integer变量是永远不相等的(因为new生成的是两个对象,内存地址不同)
    2. Integer变量和int变量比较时,只要两个变量的值是相等的,则结果为true(因为包装类Integer和基本数据类型int比较时,java会自动拆包装为int,然后进行比较,实际上就变为两个int变量的比较)
    3. 非new生成的Integer变量和new Integer()生成的变量比较时,结果为false(因为非new生成的Integer变量指向的是java常量池中的对象,而new Interger()生成的变量指向堆中新建的对象,两者在内存中的地址不同)
    public class
    test {
        public static void main(String[] args) {
            Integer i=new Integer(100);
            Integer j=100;
            System.out.println(i==j);
        }
    }
    
    输出结果:
    false
    
    1. 对于两个非new生成的Integer对象,进行比较时,如果两个变量的值在-128到127之间,则比较结果为true,如果两个变量的值不在此区间,则比较结果为false:
    public class
    test {
        public static void main(String[] args) {
            Integer i1=100;
            Integer j1=100;
            System.out.println(i1==j1);
            Integer i2=128;
            Integer j2=128;
            System.out.println(i2==j2);
        }
    }
    
    输出:
    true
    false
    

    原因:
    java在编译i=100时,会翻译成:

    Integer i=Integer.valueOf(100);
    

    而java API中对于Integer类型的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);
    }
    

    java对-128到127之间的数,会进行缓存,Integer i=127时,会将127进行缓存,下次再写Integer i=127时,就会直接从缓存中取,而不会new了

    展开全文
  • Java 基本数据类型和包装类1 Java 基本数据类型1.1 八种基本数据类型1.2 基本用法及说明byte:short:int:long:float:double:boolean:char:1.3 八种包装类型1.3.1 包装类1.3.2 包装类的构造方法2 int 和 ...

    1 Java 基本数据类型

    1.1 八种基本数据类型

    • 四种整数类型 (byte、short、int、long)
    • 两种浮点数类型 (float、double)
    • 一种字符类型(char)
    • 一种布尔类型(boolean)

    1.2 基本用法及说明

    byte:

    • 8 位,占 1 字节
    • 最小值是 -128(-2^7),最大值是 127(2^7 - 1)
    • 默认值是 0
    • 例子:byte a = 100,byte b = -50

    short:

    • 16位,占 2 字节
    • 最小值是 -32768(-2^15),最大值是 32767(2^15 - 1);
    • 默认值是0;
    • 例子:short s = 1000,short r = -20000

    int:

    • 32位,占 4 字节
    • 最小值是-2,147,483,648(-2^31)
    • 最大值是2,147,485,647(2^31 - 1)
    • 一般地整型变量默认为int类型;
    • 默认值是0;
    • 例子:int a = 100000, int b = -200000

    long:

    • 64位,占 8 字节
    • 最小值是-9,223,372,036,854,775,808(-2^63)
    • 最大值是9,223,372,036,854,775,807(2^63 -1)
    • 默认值是 0L
    • 例子: long a = 100000L,int b = -200000L

    float:

    • 32位,占4字节
    • -3.4E38- 3.4E38… 浮点数是有舍入误差的
    • 默认值是 0.0f
    • 例子:float f1 = 234.5f,float f = 6.26F

    double:

    • 64位,8位
    • 浮点数的默认类型为double类型
    • 默认值是 0.0d
    • 例子:double d1 = 123.4

    boolean:

    • 只有两个取值:true 和 false
    • 默认值是false;
    • 例子:boolean one = true, two = false

    Java 规范中,没有明确指出 boolean 的大小。在《Java虚拟机规范》给出了 4 个字节,和 boolean 数组1个字节的定义,具体还要看虚拟机实现是否按照规范来,所以1个字节、4个字节都是有可能的。

    char:

    • char 类型是一个单一的16位Unicode字符;用 ''表示一个字符
    • 可以当整数来用,它的每一个字符都对应一个数字

    1.3 八种包装类型

    1.3.1 包装类

    • byte --> Byte
    • short --> Short
    • int --> Integer
    • long --> Long
    • float --> Float
    • double --> Double
    • char --> Character
    • boolean --> Boolean

    1.3.2 包装类的构造方法

    • 所有包装类都可将与之对应的基本数据类型作为参数,来构造它们的实例

      public Type(type value)
      如:Integer i=new Integer(1);

    • 注意事项:
      (1)Boolean 类构造方法参数为 String 类型时,若该字符串内容为 true (不考虑大小写),则该 Boolean 对象表示 true,否则表示 false。
      (2)当 Number 包装类构造方法参数为 String 类型时,字符串不能为 null, 且该字符串必须可解析为相应的基本数据类型的数据,否则编译通过,运行时NumberFormatException异常。

    2 int 和 Integer 有什么区别

    2.1 区别

    • int 为基本类型,Integer 为包装类型,Integer 有很多方法可以使用。
    • int 可以通过 Integer.valueOf(xx) 转成 Integer
    • Integer 可以调用 intValue()方法得到 int值
    • Java 1.5 之后不用显示调用,JVM 会自动进行拆装箱

    2.2 注意事项

    • 使用 Integer 和 int 直接比较大小时需要判断 Integer 的值是否为null。因为 Integer 会调用 intValue()方法 拆箱为 int,为 null 时会报空指针异常。

    2.3 一个 Integer 值比较不注意的问题

    public void test2() {
        Integer a1 = Integer.valueOf(60);
        Integer b1 = 60;
        System.out.println("1:="+(a1 == b1));
    
        Integer a2 = 60;
        Integer b2 = 60;
        System.out.println("2:="+(a2 == b2));
    
        Integer a3 = new Integer(60);
        Integer b3 = 60;
        System.out.println("3:="+(a3 == b3));
    
        Integer a4 = new Integer(60);
        Integer b4 = new Integer(60);
        System.out.println("4:="+(a4 == b4));
    
        Integer a5 = 129;
        Integer b5 = 129;
        System.out.println("5:="+(a5 == b5));
    }
    

    结果:

    1:=true
    2:=true
    3:=false
    4:=false
    5:=false
    

    Java 中 Integer 类型对于 -128 - 127 之间的数是缓冲区取的。所以用等号比较是一致的。
    但对于不在这区间的数字是在堆中 new 出来的。所以地址空间不一样,也就不相等。

    展开全文
  • 文章目录基本数据类型和包装类指什么装箱以及拆箱自动装箱与拆箱的实现原理(基本数据类型和包装类存储在哪)基本数据类型存储位置包装类型的存储位置、自动装箱与拆箱的实现原理 基本数据类型和包装类指什么 我们先...

    基本数据类型和包装类指什么

    我们先来看一下Java中的基数据类型有哪些:
    在这里插入图片描述
    从上图我们能够看到数据类型主题氛围两类,基本数据类型和引用数据类型,但是为何我们要把它分为两类呢,这是由它底层的存储的位置决定了它的们拥有各自特殊的功能性质,我们这里先了解后面会详细赘述。
    我们这里在看基本数据类型,这里面有八种基本数据类型,它们都有自己对应的包装类型。
    在这里插入图片描述
    这里我们会有疑问为何会有包装类型,它能干什么,它们两个有什么区别、、、种种疑问。还是前面说的,一个东西性质是由它底层决定的,我们这里只是开个头,后面整篇文章看完后这些问题都会解决。

    装箱以及拆箱

    基本数据类型和包装类型直接的转换我们称之为装箱和拆箱操作。而我们的装箱以及拆箱操作在JDK5之前装箱以及拆箱只能程序员手动来操作,但是在JDK5之后就有了自动装箱以及拆箱,但是自动装箱以及拆箱原理和我们手动一样。这里我们先来看一下装箱以及拆箱的实现,之后我们在去看原理解决前一段后面的疑问。

    • 手动/自动装箱
    int a1=4;
    //手动装箱
          Integer ai = new Integer(a1);
    //自动装箱
         Integer aj = a1;
    
    
    • 手动/自动拆箱
    //手动拆箱
    int ah = ai.intValue();
     //自动拆箱
     int ag = ai;
    
    

    这里我们只是把自动装箱和拆箱开了个头,让大家看看,具体里面东西还要结合底层来说。

    自动装箱与拆箱的实现原理(基本数据类型和包装类存储在哪)

    基本数据类型存储位置

    我们先来说我们基本数据类型都存储在我们的Class常量池中。而我们的常量池属于方法区。

    包装类型的存储位置、自动装箱与拆箱的实现原理

    下面例子是自动装箱和拆箱带来的疑惑

    
        public class Test {  
            public static void main(String[] args) {      
                test();  
            }  
        
            public static void test() {  
                int i = 40;  
                int i0 = 40;  
                Integer i1 = 40;  
                Integer i2 = 40;  
                Integer i3 = 0;  
                Integer i4 = new Integer(40);  
                Integer i5 = new Integer(40);  
                Integer i6 = new Integer(0);  
                Integer i7=128;
                Integer i8=128;
                Double d1=1.0;  
                Double d2=1.0;  
                  
                System.out.println("i=i0\t" + (i == i0));  
                System.out.println("i1=i2\t" + (i1 == i2));  
                System.out.println("i1=i2+i3\t" + (i1 == i2 + i3));  
                System.out.println("i4=i5\t" + (i4 == i5));  
                System.out.println("i4=i5+i6\t" + (i4 == i5 + i6));
                System.out.println("i7==i8"+(i7==i8));      
                System.out.println("d1=d2\t" + (d1==d2));   
                  
                System.out.println();          
            }  
        } 
    

    请看下面的输出结果跟你预期的一样吗?
    输出的结果:
    i=i0        true
    i1=i2       true
    i1=i2+i3    true
    i4=i5       false
    i4=i5+i6    true
    i7=i8 false
    d1=d2     false

    为什么会这样?带着疑问继续往下看。
    自动装箱时编译器调用valueOf将原始类型值转换成对象,同时自动拆箱时,编译器通过调用类似intValue(),doubleValue()这类的方法将对象转换成原始类型值。
    双等号运算符==,对于基本数据类型比较的是数值,对于两个对象则比较的是地址

    明白自动装箱和拆箱的原理后,我们带着上面的疑问进行分析下Integer的自动装箱的实现源码。如下:

    
        public static Integer valueOf(int i) {
            //判断i是否在-128和127之间,存在则从IntegerCache中获取包装类的实例,否则new一个新实例
            if (i >= IntegerCache.low && i <= IntegerCache.high)
                return IntegerCache.cache[i + (-IntegerCache.low)];
            return new Integer(i);
        }
    
    
        //使用亨元模式,来减少对象的创建(亨元设计模式大家有必要了解一下,我认为是最简单的设计模式,也许大家经常在项目中使用,不知道他的名字而已)
        private static class IntegerCache {
            static final int low = -128;
            static final int high;
            static final Integer cache[];
    
            //静态方法,类加载的时候进行初始化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;
            }
    
            private IntegerCache() {}
        }
    

    Integer i1 = 40; 自动装箱,相当于调用了Integer.valueOf(40);方法。
        首先判断i值是否在-128和127之间,如果在-128和127之间则直接从IntegerCache.cache缓存中获取指定数字的包装类;不存在则new出一个新的包装类。
        IntegerCache内部实现了一个Integer的静态常量数组,在类加载的时候,执行static静态块进行初始化-128到127之间的Integer对象,存放到cache数组中。cache属于常量,存放在java的方法区中。

    接着看下面是java8种基本类型的自动装箱代码实现。如下

        //boolean原生类型自动装箱成Boolean
        public static Boolean valueOf(boolean b) {
            return (b ? TRUE : FALSE);
        }
    
        //byte原生类型自动装箱成Byte
        public static Byte valueOf(byte b) {
            final int offset = 128;
            return ByteCache.cache[(int)b + offset];
        }
    
        //byte原生类型自动装箱成Byte
        public static Short valueOf(short s) {
            final int offset = 128;
            int sAsInt = s;
            if (sAsInt >= -128 && sAsInt <= 127) { // must cache
                return ShortCache.cache[sAsInt + offset];
            }
            return new Short(s);
        }
    
        //char原生类型自动装箱成Character
        public static Character valueOf(char c) {
            if (c <= 127) { // must cache
                return CharacterCache.cache[(int)c];
            }
            return new Character(c);
        }
        
        //int原生类型自动装箱成Integer
        public static Integer valueOf(int i) {
            if (i >= IntegerCache.low && i <= IntegerCache.high)
                return IntegerCache.cache[i + (-IntegerCache.low)];
            return new Integer(i);
        }
    
        //int原生类型自动装箱成Long
        public static Long valueOf(long l) {
            final int offset = 128;
            if (l >= -128 && l <= 127) { // will cache
                return LongCache.cache[(int)l + offset];
            }
            return new Long(l);
        }
    
        //double原生类型自动装箱成Double
        public static Double valueOf(double d) {
            return new Double(d);
        }
    
        //float原生类型自动装箱成Float
        public static Float valueOf(float f) {
            return new Float(f);
        }
    

    通过分析源码发现,只有double和float的自动装箱代码没有使用缓存,每次都是new 新的对象,其它的6种基本类型都使用了缓存策略。
        使用缓存策略是因为,缓存的这些对象都是经常使用到的(如字符、-128至127之间的数字),防止每次自动装箱都创建一次对象的实例。
        而double、float是浮点型的,没有特别的热的(经常使用到的)数据的,缓存效果没有其它几种类型使用效率高。
        
    这个很好理解,因为对于Integer,在(-128,128]之间只有固定的256个值,所以为了避免多次创建对象,我们事先就创建好一个大小为256的Integer数组SMALL_VALUES,所以如果值在这个范围内,就可以直接返回我们事先创建好的对象就可以了。

    但是对于Double类型来说,我们就不能这样做,因为它在这个范围内个数是无限的。
    总结一句就是:在某个范围内的整型数值的个数是有限的,而浮点数却不是。

    下面在看下装箱和拆箱问题解惑。

        //1、这个没解释的就是true
        System.out.println("i=i0\t" + (i == i0));  //true
        //2、int值只要在-128和127之间的自动装箱对象都从缓存中获取的,所以为true
        System.out.println("i1=i2\t" + (i1 == i2));  //true
        //3、涉及到数字的计算,就必须先拆箱成int再做加法运算,所以不管他们的值是否在-128和127之间,只要数字一样就为true
        System.out.println("i1=i2+i3\t" + (i1 == i2 + i3));//true  
        //比较的是对象内存地址,所以为false
        System.out.println("i4=i5\t" + (i4 == i5));  //false
        //5、同第3条解释,拆箱做加法运算,对比的是数字,所以为true
        System.out.println("i4=i5+i6\t" + (i4 == i5 + i6));//true 
        //由于i7和i8超过了127,所以不能从缓存中直接取出,两个都需要在堆中创建不同的对象空间
        System.out.println("i7==i8"+(i7==i8));     
        //double的装箱操作没有使用缓存,每次都是new Double,所以false
        System.out.println("d1=d2\t" + (d1==d2));//false
    
    • 看到这里我们已经对自动装箱和拆箱的原理了解,现在需要解决最后一个问题自动拆箱和装箱的时机。
      当基础类型与它们的包装类有如下几种情况时,编译器会自动帮我们进行装箱或拆箱.
      进行 = 赋值操作(装箱或拆箱)
      进行+,-,*,/混合运算 (拆箱)
      进行>,<,==比较运算(拆箱)
      调用equals进行比较(装箱)
      ArrayList,HashMap等集合类 添加基础类型数据时(装箱)

    装箱带来的问题

    • 我们再来看看自动拆装箱我目前知道可能遇到的问题
      基本类型只有功能完备的值,而包装类型除了其对应的基本类型所有的功能之外,还有一个非功能值:null。
      现在来看一段简单的代码:
      static Integer i;
      public static void main(String[] args) {
        if(i == 128){
        System.out.println(“Unbelieveable~”);
        }
      }
      你认为会输出什么呢?不知道?自己运行一下~~~~
      其实这段代码并不能正确的运行,因为它会报一个NullPointException异常,为什么?因为在定义i的时候,它是Integer类的一个引用,而i没有初始化,就像所有对象引用一样,如果没有初始化那么就赋一个null值。既然现在i是一个null,那么上面已经提到,当混合使用基本类型与包装类型时,包装类会自动拆箱。现在i都没有指向任何对象,因此拆箱的时候就会报一个NullPointException异常。

    这里我们看到包装类可以允许NULL值,因为它是一个对象。而我们的基本数据类型没有NULL值,所以在我们想要从数据库的到值时候,一定要用包装类型,因为我们也不知道是否会返回一个NULL值。所以在平常使用中最好使用包装类。

    • 所有整型包装类对象之间值的比较,全部使用 equals 方法比较。
      在我们的Java开发手册中写到**“所有整型包装类对象之间值的比较,全部使用 equals 方法比较。”**
      说明:对于 Integer var = ? 在-128 至 127 之间的赋值,Integer 对象是在 IntegerCache.cache 产生,会复用已有对象,这个区间内的 Integer 值可以直接使用==进行判断,但是这个区间之外的所有数据,都会在堆上产生,并不会复用已有对象,这是一个大坑,推荐使用 equals 方法进行判断。
      这里我们不做多的解释了,相信看了上面的到这里我们已经知道为什么了!
    展开全文
  • Java基本数据类型和包装类 一、Java的两大数据类型:基本数据类型、引用类型。Java中除了八种基本数据类型,其他都是引用类型。 1.基本数据类型的值是放在变量里面; 变量里内存的地址就是引用类型。 2.Java语言...

    Java基本数据类型和包装类

    一、Java的两大数据类型:基本数据类型、引用类型。Java中除了八种基本数据类型,其他都是引用类型。

    1.基本数据类型的值是放在变量里面; 变量里内存的地址就是引用类型。

    2.Java语言提供了八种基本数据类型。六种数字类型(四个整数型,两个浮点型),一 种字符类型,还有一种布尔型。

    整形:byte、short、int、long

    byte: 占1字节(B), 8位(bit:8个内存空间为一为一个字节)范围:-2^7到 2^7-1默认值0   

    short:占2个字节,16位;范围:-2^15 到 2^15-1 ;默认值是0 ;Short 数据类型可以节省空间。一个short变量是int型变量所占空间的二分之一

    int:占4个字节,32位  范围:-2^31 到 2^31-1  默认值是 0   

    long:占8个字节,64位  范围:-2^63 到 2^63-1  默认值是 0L 后用l或L进行标识 建议使用L   

    注意:

    整形范围的第一位是符号位,符号位为:“+0”,“-:1

    10000代表为-128000000代表:0

     

    浮点型: float,double

    float:占4个字节,32位,后用f或F进行标识   单进度浮点型

    double:占8个字节,64位,小数默认的是double类型,double类型后可以用D或d标识,但一般不加  双进度浮点型

     

    字符类型: char

    char: 占2个字节,16位

    char类型有多种写法:

    1. g='a' 字符;

    2.h='\r' 特殊的转义字符;

    3.i='\u9990'  Unicode字符集\u0000-\uFFFF;

    4.j=65535字符0到 65535=\uFFFF; 

    特殊的转义字符还有:\n 换行(\u000a);\t 水平制表符(\u0009);\b 空格(\u0008);\r 回车(\u000d);\f 换页(\u000c);\' 单引号(\u0027);\" 双引号(\u0022);\\ 反斜杠(\u005c)

    Java中char类型中本质存的就是Unicode的字符集,这是全球通用字符集,它的每一位都是十六进制

     

    布尔型: boolean

    boolean:1字节  8位 true/false 

    二、基本数据类型对应的类类型叫做包装类

    1.包装类:Byte、Short、Integer、Long、Float、Double、Character、Boolean

    2.包装类都是首写字为大写,只有几个特殊int= Integerchar= Character

    3. 这八种包装类所继承的父类不全都相同

    Integer ,Byte,Float,Double,Short,Long都属于Number类的子类,Number类本身提供了一系列的返回以上六种基本数据类型的操作;Character属于Object子类;Boolean属于Object子类。

    4.包装类提供一些类型转换的方法 、类型的属性

    5.Java中字符串类型是引用类型,引用类型首写字母是大写

    6.在java中类型转换只有两种方法:一种就是包装类转换,还有一种就是强行转换。

    7.类型的属性:

    基本类型:byte 二进制位数:8

    最小值:Byte.MIN_VALUE=-128

    最大值:Byte.MAX_VALUE=127

     

    基本类型:short 二进制位数:16

    最小值:Short.MIN_VALUE=-32768

    最大值:Short.MAX_VALUE=32767

     

    基本类型:int 二进制位数:32

    最小值:Integer.MIN_VALUE=-2147483648

    最大值:Integer.MAX_VALUE=2147483647

     

    基本类型:long 二进制位数:64

    最小值:Long.MIN_VALUE=-9223372036854775808

    最大值:Long.MAX_VALUE=9223372036854775807

     

    基本类型:float 二进制位数:32

    最小值:Float.MIN_VALUE=1.4E-45

    最大值:Float.MAX_VALUE=3.4028235E38

     

    基本类型:double 二进制位数:64

    最小值:Double.MIN_VALUE=4.9E-324

    最大值:Double.MAX_VALUE=1.7976931348623157E308

     

    基本类型:char 二进制位数:16

    最小值:Character.MIN_VALUE=0

    最大值:Character.MAX_VALUE=65535

    Integer是进制转换的类

    8.人算的进制转换,一般我们长见的都是十进制,所以我们都是以十进制为中间桥梁来转。

    进制转换公式:sum(数值*进制^(数值所在位数-1))

    9. 装箱及拆箱

    将基本数据类型赋值包装类称为装箱。  

    将包装类的类型赋值基本数据类型称为拆箱。  

     在JDK1.5之后,提供了自动装箱和自动拆箱功能。

    展开全文
  • 1.基本数据类型和包装类的区别 这部分主要是加强对包装类的整体感官
  • 基本数据类型和包装类的区别: 1.int初始值0 Integer初始值null 2.包装类中有很多方法。 3.集合框架中不能存放基本数据类型,只能存对象。 什么时候去使用? 在类中,一般使用包装类。 方法中,一般使用基本...
  • 1.包装类的作用 Java是一种面向对象的编程语言,却存在几个不具有对象特征的异类;他们不能像对象一样进行属性和方法的调用,也无法进行相互之间的对象化处理。...2.基本数据类型和包装类的对应 3. ...
  • 基本数据类型包装类:通过对应包装类的构造方法实现除了Character外,其他包装类都可以传入一个字符串参数构建包装类对象。包装类基本数据类型包装类的实例方法xxxValue(); // xxx表示包装类对应的基本...
  • Java的基本数据类型和包装类 序号 数据类型 长度(位数) 默认值 1 byte(整数型) 8 0 2 short(整数型) 16 0 3 int(整数型) 32 0 4 long(整数型) 64 0 5 ...
  • 《Java基本数据类型和包装类》 开发工具与关键技术:MyEclipse 10、Java 作者:潘玉莹 撰写时间:2019-05-22 一、 Java的8种基本数据类型 Java的两大数据类型:基本数据类型、引用数据类型 Java语言提供了八种基本...
  • 你不知道的基本数据类型和包装类基本数据类型Java 基本数据按类型可以分为四大类:布尔型、整数型、浮点型、字符型,这四大类包含 8 种基本数据类型。布尔型:boolean整数型:byte、short、int、long浮点型:float、...
  • Java中基本数据类型和包装类互转中 缓冲机制的使用;java学习笔记:装箱和拆箱,包装器和缓冲池Java 各 类型数据在内存中分配情况详解 一 java内存分配 这里只是在网上找的一些资料;Java中的数据类型分为1. 基本类型...
  • 第1关:基本数据类型和包装类之间的转换 任务描述 本关任务:实现基本数据类型与包装类之间的互相转换。 测试说明 请仔细阅读右侧代码,根据方法内的提示,在Begin - End区域内进行代码补充,具体任务如下: 完成...
  • 你不知道的基本数据类型和包装类 + 面试题 基本数据类型 Java 基本数据按类型可以分为四大类:布尔型、整数型、浮点型、字符型,这四大类包含 8 种基本数据类型。 布尔型:boolean 整数型:byte、short、int、long ...
  • 基本数据类型和包装类的参数绑定 学习本文需要安装的软件: JDK1.8 、IDEA2017.3、Maven3.3.3、Tomcat7.0.64 - 基本数据类型和包装类的参数绑定 1.准备POJO public class TestUser { private ...

空空如也

空空如也

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

基本数据类型和包装类