精华内容
下载资源
问答
  • 更详细的说明,请参考:Java 原生类型与包装器类型深度剖析,... 原生类型与包装器类型1Byte = 8 Bits二. 自动转型与强制转型精度(低1-高5)1byte(1字节)Byteshort(2字节)Shortchar(2字节)Character2int(4字节)Integ...

    更详细的说明,请参考: Java 原生类型与包装器类型深度剖析,https://blog.csdn.net/justloveyou_/article/details/52651211

    一. 原生类型与包装器类型

    1Byte = 8 Bits

    a53eafa4e2622ff10217432a349c4b09.png

    二. 自动转型与强制转型

    精度(低1-高5)

    1

    byte(1字节)

    Byte

    short(2字节)

    Short

    char(2字节)

    Character

    2

    int(4字节)

    Integer

    3

    long(8字节)

    Long

    4

    float(4字节)

    Float

    5

    double(8字节)

    Double

    NA

    boolean(未定)

    Boolean

    1、 自动转型

    自动转型总原则:byte,short,char(同级)-> int -> long -> float -> double (由低精度到高精度)

    1.1 由低精度到高精度的自动转换

    具体可分为以下两种情形:

    1)从位数低的类型向位数高的类型转换

    byte b = 1;char c = 1;short s = 1;int i = 1;

    c= b; //Error,同级

    c = s; //Error,同级

    s = c; //Error,同级

    i = c; //OK

    2) 从整型向浮点型的转换

    int i = 1;long t = 1;float f = 1;double d = 1;

    f= i; //Ok

    f = t; //Ok

    d = f; //Ok

    1.2 运算符对基本类型的影响

    具体可分为以下两种情形:

    1) 当使用 +、-、*、/、%、==、>、< 等 等运算符对基本类型进行运算时,遵循如下规则:

    两个操作数中,先考虑是否有一个是double类型的。如果有,另一个操作数和结果 将会被转换成double类型。再依次考虑float,long。除此之外,两个操作数(包括byte、short、int、char)都将会被转换成int类型。

    byte b1 = 10 ; //OK,会检查发现10没有超过byte类型的最大值

    byte b2 = 12; //OK,会检查发现12没有超过byte类型的最大值

    byte b = b1 + b2; //Error,byte类型在计算时会自动提升为int类型,此时就会报错,因为b1+b2实际上是int类型,但是左侧的变量为byte类型。

    short s1=1; //OK,会检查发现1没有超过short类型的最大值

    s1=s1+1; //Error,因为s1+1 结果int,但左侧变量为 short,报错

    s1++; //OK,不会报错,与s1=s1+1不同!!!,会检查发现2没有超过short类型的最大值

    s1=1+1; //OK,1+1 是个编译时可以确定的常量,'+'运算在编译时就被执行了,而不是在程序执行的时候,这个语句的效果等同于s1=2

    2) 当使用+=、-=、*=、/=、%=、i++、 ++i运算符对基本类型进行运算时,遵循如下规则:

    运算符右边的数值将首先被强制转换成与运算符左边数值相同的类型,然后再执行运算,且运算结果与运算符左边数值类型相同。自增(减)运算也类似。

    short s1=1; //OK,会检查发现1没有超过short类型的最大值

    shorts2;

    s1+=1; //OK,正确,1首先被强制转换为short型,然后再参与运算,并且结果也是short类型

    s2= ++s1; //OK,正确,s2的值为2

    2、强制转型

    强制转换的格式是在需要转型的数据前加上 “( )”, 然后在括号内加入需要转化的数据类型。主要发生于以下两种情形:

    由高精度向低精度转换

    一种类型到另一种类型转换,则必须使用强制类型转化(同级之间:byte,short,char)

    byte b = 3;int i = 3;long t = 3;float f = 3;char c = 3;short s = 3;

    i= (int) f; //OK,由高精度向低精度转换

    t = (long) f; //OK,由高精度向低精度转换

    b = (byte) i; //OK,由高精度向低精度转换

    i= b; //OK,由低精度向高精度转换,自动转型

    System.out.println(c==s); //OK,true,c 和 s 自动转型为int,然后比较

    b= (byte) s; //OK,一种类型到另一种类型转换

    c = (char) b; //OK,一种类型到另一种类型转换

    c = (char) s; //OK,一种类型到另一种类型转换

    特别需要注意的是,强制转换常常会导致二进制位的截取,甚至会导致意想不到的结果:

    int i = 128;byte b = (byte)i;

    System.out.println(b);//-128(即-0)

    ---------------------

    作者:书呆子Rico

    来源:CSDN

    原文:https://blog.csdn.net/justloveyou_/article/details/52651211

    版权声明:本文为博主原创文章,转载请附上博文链接!

    展开全文
  • 1. Java中包装类和原生类型8个原生类型分别是:byte, short, int, long, float, double, char, boolean。8个包装类分别是:Byte, Short, Integer, Long, Float, Double, Character, Boolean。原生数据类型与包装类型...

    1. Java中包装类和原生类型

    8个原生类型分别是:byte, short, int, long, float, double, char, boolean。

    8个包装类分别是:Byte, Short, Integer, Long, Float, Double, Character, Boolean。

    原生数据类型与包装类型的双向转换

    自动转型总原则:byte,short,char(同级)-> int -> long -> float -> double (由低精度到高精度)

    public class IntegerTest{

    public static void main(String[] args){

    int a = 10;

    Integer integer = new Integer(a);

    int b = integer.intValue();

    System.out.println(a == b);

    }

    }

    运行结果:

    true

    2. Java中自动装箱和拆箱

    装箱就是自动将基本数据类型转换为包装器类型 Integer i = 10;

    拆箱就是自动将包装器类型转换为基本数据类型 int n = i;

    装箱过程是通过调用包装器的valueOf方法实现的

    拆箱过程是通过调用包装器的 xxxValue方法实现的(xxx代表对应的基本数据类型)

    Integer类有一个缓存,它会缓存介于-128~127之间的整数。Integer.valueof()方法会将缓存值返回,不会生成新的对象。

    在装箱时,valueOf方法会被自动调用:如果整型字面值在[-128,127]之间,便返回 IntegerCache.cache(在类加载时就自动创建)中已经存在的对象的引用;否则,创建一个新的Integer对象并返回。

    public class BoxTest {

    public static void main(String[] args){

    Integer i1 = 100;

    Integer i2 = 100;

    if(i1 == i2){

    System.out.println("i1 == i2");

    }else{

    System.out.println("i1 != i2");

    }

    }

    }

    运行结果:i1 == i2

    public class BoxTest {

    public static void main(String[] args){

    Integer i1 = 200;

    Integer i2 = 200;

    if(i1 == i2){

    System.out.println("i1 == i2");

    }else{

    System.out.println("i1 != i2");

    }

    }

    }

    运行结果:i1 != i2

    Double就没有这种情况,是因为在某个范围内的整型数值的个数是有限的,而浮点数却不是。

    Integer、Short、Byte、Character、Long 这几个类的valueOf方法的实现是类似的,有限可列举,共享[-128,127];

    Double、Float的valueOf方法的实现是类似的,无限不可列举,不共享;

    Boolean的valueOf方法的实现不同于以上的整型和浮点型,只有两个值,有限可列举,共享;

    Integer i = new Integer(xxx); 不会触发自动装箱;

    Integer i = xxx; 会触发自动装箱;执行效率和资源占用在一般性情况下([-128,127])要高

    详细参考博客: https://blog.csdn.net/justloveyou_/article/details/52651211

    分享到:

    18e900b8666ce6f233d25ec02f95ee59.png

    72dd548719f0ace4d5f9bca64e1d7715.png

    2018-10-09 10:08

    浏览 432

    评论

    展开全文
  • 基本类型(原生类型)

    2020-10-31 16:08:48
    基本类型(原生类型) 今天学习了JAVA中的基本类型(原生类型) 基本类型是指不能再分解的数据类型,其数据在函数的调用中是以传值方式工作的。 简单数据类型代表单值,而不是复杂的对象 Java是完全面向对象的,但简单...

    基本类型(原生类型)

    今天学习了JAVA中的基本类型(原生类型)

    基本类型是指不能再分解的数据类型,其数据在函数的调用中是以传值方式工作的。

    简单数据类型代表单值,而不是复杂的对象

    Java是完全面向对象的,但简单数据类型却不是,它们类似于其他大多数非面向对象语言中的简单数据类型。这样做的原因是出于效率方面的考虑。在面向对象中引入简单数据类型不会对执行效率产生太多的影响。

    Java编程语言有八个原始数据类型,可分为4种整型、浮点数、字符型数据和布尔型数据,不会随着计算机类型而变化的,注意Java具有平台无关性,所以不论硬件平台是什么,1B都是8位 【B表示字节,b表示位

    整型

    有4种:byte字节整、short短整、int整、long长整

    • java中的数据采用的是补码的存储方式
      • 原码、反码、补码:正数没有区别,最高位为符号位,java中没有无符号整数的概念
      • 16机制15=1*16+5*16^0=21
      • 10进制的21=00010101=15
    • byte:1B(8b): -128到127
    byte k=(byte)3000;   //如果不进行数据类型转换,则IDE工具会报错。但是将大范围数据强转[窄化操作]为小类型变量会有精度损失

    short:2B:-32768到32767

    int:4B:-2147483648到2147483647

    //具体数据取值范围的查询方法
    public class Test4 {
    	public static void main(String[] args) {
    		System.out.println(Long.MAX_VALUE);//上限
    		System.out.println(Integer.MIN_VALUE);//下限
    	}
    }

    long:8B:-9223372036854775808到9223372036854775807

    十进制整数。如123,-456,0

    八进制整数。以0开头,如0123表示十进制数83,-011表示十进制数-9。

    十六进制整数。以0x或0X开头,如0x123表示十进制数291,-0X12表示十进制数-18

    二进制整数,以0b或0B开头,例如0b10110010

    整数类缺省为int类型,如在其后有一个字母“l或者L”表示一个long值

    short k1=123;
    k1=k1+1;//报错的原因是1默认是int类型,所以计算结果为int类型,需要进行窄化操作
    short k=Short.MAX_VALUE;
    k+=1; //+=这个运算符会自动进行数据类型转换

    浮点数类型

    float单精度、double双精度

    在Java中浮点数无法精确存放,除非使用BigDecimal

    • 在金融系统中针对浮点数一般都会转换为整数进行处理

    float:4B:1.4E-45到3.4028235E38 保存7-8位有效数据

    double:8B:4.9E-324到1.7976931348623157E308 保存15-16位有效数据

    • 默认浮点数类型为double,如果需要使用float,则默认添加f或者F

    需要注意:浮点数无法精确存放

    float f1=1.23;
    float f2=2-0.77f;
    //判断f1和非相等,使用f1==f2是错误的
    public class Test4 {
    	public static void main(String[] args) {
    		float k=0;//这里不报错的原因是0为int类型,计算中会自动转换为float
    		for(int i=0;i<10;i++){
    			k=k+0.1f;//如果不写0.1f则报错,因为系统识别0.1为double类型,则计算结果为double。
    		}
    		System.out.println(k); //1.0000001
    	}
    }

    表示方法:

    • 十进制数形式。由数字和小数点组成,且必须有小数点,如0.123, 1.23, 123.0
    • 科学计数法形式。如:123e3或123E3,其中e或E之前必须有数字,且e或E后面的指数必须为整数

    字符类型 char

    Java中存放字符采用的是Unicode编码字符集,2B,0-65535

    • 可以充当整形数进行计算
    • 这里允许的字符包括中英文等,实际可以包含全世界范围的所有文字
    • windows默认编码字符集为GB18030(GBK)
    //字符类型的变量可以当作整数使用
    
    char c='a'; //注意:这里使用的是单引号,不是双引号,单引号中只能包含一个字符
    
    需要记忆:
    '0' < 'A' <'a'
    
    查询对应字符的整形值
    char c='中';
    System.out.println((int)c);
    
    Java也提供转义字符,以反斜杠(\)开头,将其后的字符转变为另外的含义
    \ddd	138进制数所表示的字符(ddd)  例如'\110'实际就是字符H
    	char c='\129'; // 注意这里是8进制数,报错原因是9超出范围
    \uxxxx	1416进制数所表示的字符(xxxx),例如'\u9110'表示字符'鄐'
    \’		单引号字符,例如'\''
    \"		双引号字符,例如'"'实际上是可以的,但是这样写可读性非常差,所以建议使用'\"'
    \\		反斜杠字符

    布尔类型

    boolean数据类型有两种文字值:true真和false假

    在Java编程语言中boolean类型只允许使用boolean值,在整数类型和boolean类型之间无转换计算

    boolean bb=0;  //语法错误

    基本数据类型转换

    小转大自动转换

    byte b1=123;
    long k1=b1;
    double kk=k1;
    System.out.println(kk);
    

    大转小需要强制转换–窄化操作,可能会有数据精度丢失

    double dd=123.567;
    long kk=(int)dd;
    System.out.println(kk);
    

    类型转换的语法:

    int k=100;
    char cc=(char)k; //强制类型转换:  窄化操作
    
    char k='d';
    System.out.println((int)k);
    
    boolean bb=true;
    System.out.println((int)bb);//语法错误,因为boolean类型和数值类型之间没有任何对应关系,所以这里的强转会报语法错误
    float f1=123.456;//语法报错,因为系统默认带小数点的数据为double类型,所以123.456是double类型的数据,而声明f1为float,所以这里需要进行数据类型转换或者进行特殊声明。如果浮点数转换为整数是直接截断小数部分。
    
    float f1=(float)123.456;
    float f1=123.456f;  //数字末尾的f类似于数字末尾的L,用于进行数据类型的说明,f/F表示这是一个float类型的数据 d/D表示是一个double类型的数据

    复合数据类型

    复合数据类型包括:class类、interface接口、数组。

    null 索引在运行时并没有对应的类型,但它可以被转换为任何类型(不能是简单类型)。在虚拟机中null是一个固定位置上数据

    Object b=null;
    System.out.println(null==b);//返回为true
    
    //在数据库中bb=null是永不为真,bb!=null是永不为真。只能使用is null或者is not null进行判断

    索引类型的默认值就是null

    ##常量

    常量就是指在程序执行期间其值不能发生变化的数据,常量是固定的。如整型常量123【字面量】,实型常量1.23,字符常量’A’,布尔常量true等

    表达式

    表达式就是运算符、操作数以及方法调用的序列,用来说明某个计算过程并返回计算结果. 按照运算符功能来分,基本的运算符分包括算术运算符、关系运算符、位运算符、条件运算符等

    算术运算符 +、-、*、/、%、++、–

    关系运算符 >、<、>=、<=、==、!=

    逻辑运算符 &&、 ||、 !。注意:逻辑计算支持短路操作

    位运算符 &、|、^、~、<< 、 >>、>>>。注意:为运算符不支持短路操作[考点]

    赋值运算符 =,+=,―=,*=,/=

    三目条件运算符(?:)规则是完全一致的,使用的形式是: x ? y:z;

    算术运算符 +、-、*、/、%、++、–

    +-*/
    整除:参与运算的双方都是整数,这里的小数部分是直接抛弃,没有进位一说。 10/3=3而不是3.33333
    10./3=3.333...这里由于10.是浮点数,则3会自动转换为大类型并参与计算,所以最终是 10.0/3.0的计算结果
    
    计算次序为先乘除后加减,如果优先级一致,则自动从左向右进行计算  10+2*5=20
    
    %求余(取模)  10%3=1实际就是10除以3求余数
    double k=10.12;
    System.out.println(k%3);  //参与计算的只有整数部分,符号不参与计算
    输出:1.1199999999999992
    
    ++--是单目运算符
    i++等价于i=i+1,i--等价于i=i-1,注意类型问题
    以++为例写法有2个:i++或者++i
    
    	short kk=1;
    	kk++; //自动类型转换
    	kk=kk+1; //报错,因为数据类型
    
    i++是先获取i的值,然后再对i加1
        int age=100;
    	System.out.println(age++);输出为100
    	System.out.println(age);  输出为101,因为上面进行加1
    	
    ++i是先对i加1,然后再获取i的值
        int age=100;
    	System.out.println(++age);输出101,先加1然后获取值
    	System.out.println(age);  输出101

    几个需要注意的例子:

    package com.yan1;
    
    public class Test1 {
    	public static void main(String[] args) {
    		int kk = 100;
    		System.out.println(kk / 2);
    
    		String k1 = "100";
    		System.out.println(k1+2); //这个加号在java内部进行重新定义,在字符串中不是执行数学计算,而是执行字符串拼接
    	}
    }
    package com.yan1;
    
    public class Test2 {
    	public static void main(String[] args) {
    		{
    			int kk=100;  //这个kk只在它所在的花括号范围内有效
    			System.out.println(kk);
    		}
    		System.out.println(kk); //语法报错,原因是超出定义的范围
    	}
    }
    package com.yan1;
    
    public class Test3 {
    public static void main(String[] args) {
    	int kk=345;
    	long k1=123L;
    	int k2="sdfasdf";
    }
    }
    package com.yan1;
    
    public class Test4 {
    	public static void main(String[] args) {
    		short kk=1;
    		kk++; //自动类型转换
    		
    		kk=kk+1; //报错,因为数据类型
    	}
    }
    展开全文
  • Google Guava 原生类型

    2019-07-16 19:23:07
    这一章我们主要讲Guava 里面针对Java的原生类型(byte、short、int、long、float、double、char、boolean)提供的一些工具类。里面的内容也很简单。 一 工具类        JAVA 原生类型对应的工具类 ...

           这一章我们主要讲Guava 里面针对Java的原生类型(byte、short、int、long、float、double、char、boolean)提供的一些工具类。里面的内容也很简单。

    一 工具类

           JAVA 原生类型对应的工具类

    原生类型 Guava工具类(都在com.google.common.primitives包)
    byte Bytes, SignedBytes, UnsignedBytes
    short Shorts
    int Ints, UnsignedInteger, UnsignedInts
    long Longs, UnsignedLong, UnsignedLongs
    float Floats
    double Doubles
    char Chars
    boolean Booleans

           上面这些工具类(Bytes、Ints等等)里面的工具方法都大体相同,很多连名字都是一样的,所以这里我们就值只列出Ints里面的一些常用方法。如下:

    Ints static方法 解释
    int checkedCast(long value) long转换为int,给定的值超过了int最大值,最小值则IllegalArgumentException
    int saturatedCast(long value) long转换为int。超过最大值为Integer.MAX_VALUE,小于最小值Integer.MIN_VALUE
    int compare(int a, int b) 比较
    boolean contains(int[] array, int target) 是否包含
    int indexOf(int[] array, int target) 数组下标
    int indexOf(int[] array, int[] target) 数组下标
    int lastIndexOf(int[] array, int target) 最后一次出现的下标
    int min(int… array) 最小值
    int max(int… array) 最大值
    int constrainToRange(int value, int min, int max) [min,max]区间里面最接近value的值
    int[] concat(int[]… arrays) 多个数组组合成一个数组
    byte[] toByteArray(int value) int转byte数组
    int fromByteArray(byte[] bytes) byte数组转int
    int fromBytes(byte b1, byte b2, byte b3, byte b4) byte转int
    Converter<String, Integer> stringConverter() String转int
    int[] ensureCapacity(int[] array, int minLength, int padding) 返回一个包含与array相同值的数组,如果原数组长度小于minLength则进行拷贝操作并且保证新数组长度为minLength + padding,否则直接返回原数组
    String join(String separator, int… array) 多个int拼接成一个字符串
    Comparator<int[]> lexicographicalComparator() 返回一个比较int数组的比较器
    void sortDescending(int[] array) 降序排序
    void sortDescending(int[] array, int fromIndex, int toIndex) 降序排序
    void reverse(int[] array) 反转
    void reverse(int[] array, int fromIndex, int toIndex) 反转
    int[] toArray(Collection<? extends Number> collection) 转换成数组
    List asList(int… backingArray) 转换成list
    Integer tryParse(String string) string转int
    Integer tryParse(String string, int radix) string转int

    二 无符号支持

           JDK原生类型包装类提供了针对有符号类型的方法,而UnsignedInts和UnsignedLongs工具类提供了相应的无符号通用方法。UnsignedInts和UnsignedLongs直接处理原生类型:使用时,由你自己保证只传入了无符号类型的值。此外,对int和long,Guava提供了无符号包装类(UnsignedInteger和UnsignedLong),来帮助你以极小的性能消耗,对有符号和无符号类型进行强制转换。

           关于UnsignedInteger和UnsignedLong。以及他俩对应的工具类UnsignedInts和UnsignedLongs已改就不用列出里面的方法了。都是很常规的一些方法。大家一看api的解释就能明白了。

    展开全文
  •  本文对 Java 原生类型与包装器类型进行深度剖析,主要涉及以下四个方面:原生类型与包装器类型基础、字面值概念和种类、 基本类型的自动转型与强制转型和自动装箱与拆箱机制。 要点: 原生类型与包装器类型 ...
  • 更详细的说明,请参考:Java 原生类型与包装器类型深度剖析,... 原生类型与包装器类型1Byte = 8 Bits 二. 自动转型与强制转型精度(低1-高5)1byte(1字节)Byteshort(2字节)Shortchar(2字节)Character2int(4字节)Inte...
  • java编程语言是静态类型,这表示变量使用前必须声明。这涉及阐明该变量的类型和名称,如你已经看到了:int gear = 1;上面告诉你的程序,存在一个字段名为”gear”,存储数字的数据,...原生类型的值,不会和其他原生...
  • 其实在原生类型中也是有 Class 的,有时候我们需要判断某个 Class 是否是原生类型,这时候可以使用 java.lang.Class#isPrimitive 方法: package dongguabai.demo.testing.classloader; /** * @author Dongguabai ...
  • 文章转载自Java 原生类型与包装器类型深度剖析 摘要:  本文对 Java 原生类型与包装器类型进行深度剖析,主要涉及以下四个方面:原生类型与包装器类型基础、字面值概念和种类、 基本类型的自动转型与强制转型和...
  • 编程入门基础 原生类型与复合类型 主讲教师 耿宇航 Copyright2013, All Rights Reserved java数据类型 int byte short long double float 基本类型 char boolean 类型 类 复合类型 接口 数组 Copyright2013,, All ...
  • rust 语法和语义 04 原生类型 原生类型 primitive types 本章讲述 rust 内建的数据类型。 概述 类型名 类型 说明 bool bool true or false char char 'c' 32-bits unicode integer i/...
  • Java的原生类型就是指基本类型:byte、short、int、long、float、double、char和boolean。 在从Guava查找原生类型方法之前,可以先查查Arrays类,或者对应的基础类型包装类,如Integer。 原生类型不能当作对象或...
  • Guava 7-原生类型

    2012-10-24 19:08:00
    Java的原生类型就是指基本类型:byte、short、int、long、float、double、char和boolean。 在从Guava查找原生类型方法之前,可以先查查Arrays类,或者对应的基础类型包装类,如Integer。 原生类型不能当作对象或...
  • 原生类型的autoboxing和auto-unboxing 我们知道,在Java中,int,long等原生类型不是一个继承自Object的类,所以相应的,有很多操作我们都不能利用原生类型操作,比如想要把一个整数放入到一个集合中,我们必须首先...
  • java反射之dynamic invocation与原生类型

    千次阅读 2016-08-28 18:15:47
    java反射之dynamic invocation与原生类型 java中的方法参数或者返回值可能为原生类型,反射调用方法的时候,理解在反射invoke方法中如何使用原生类型很重要。  如果方法的参数为原生类型,involve方法第二个数组...
  • Java中的原生数据类型(Primitive DataType)共有8种:1)整型: 使用int表示(32位)。2)字节型:使用byte表示(从-128到127之间的256个整数)。3)短整型:使用short表示(16位)。4)长整型:使用long表示(64位)。5)单精度...
  • Guava处理原生类型的数据

    千次阅读 2017-04-09 18:19:08
    概述Java的原生类型就是指基本类型:byte、short、int、long、float、double、char和boolean。 基本类型byte: 8位 -128~127 基本类型char char 是字符数据类型 ,是无符号型的,占2字节(Unicode码),大小范围 是0—...
  • 文章目录1.概述2.原生数组工具3.通用工具方法4.字节转换方法5....Java的原生类型是基本类型:byte、short、int、long、float、double、char、boolean。 在搜索Guava中的方法之前,你应该检查它是在Arrays...
  • Java泛型知乎,关于原生类型

    千次阅读 2017-05-04 23:18:45
    众所周知,raw type(原生类型)这一概念是为了在Java推出泛型以后,依然兼容过去的代码所发明的。因此,我们可以得出一条推论,就是假如一个类C已经泛型化了,而你却在使用它的raw type,那说明你压根不知道它是个...
  • 1.Redis 模块中的原生类型 1.1.原生类型概述 1.2.注册新的数据类型 1.3.为什么模块类型需要9个字符的名称? 1.4.设置和获取键 1.4.free方法 1.5.RDB加载和保存方法 1.6.AOF重写 1.7.处理多种编码 1.8.分配...
  • java原生类型

    2013-04-20 14:33:20
    Java中,数据类型分为基本数据类型(或叫做原生类、内置类型)和引用数据类型。 Java中的原生数据类型(Primitive DataType)共有8种:1)整型: 使用int表示(32位)。2)字节型: 使用byte表示(从-128到127...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,105
精华内容 4,042
关键字:

原生类型