Java数据类型

             浅谈Java数据类型

一、Java数据类型简单介绍

1、Java数据类型

（1）基本数据类型

1.Java的八大基本数据类型为： 

整型 

byte字节型1字节 8bit  最大存储数据量是255，存放的数据范围是-128~127之间 

short短整型2字节 16bit最大数据存储量是65536，数据范围是-32768~32767之间 

int整型4字节 32bit最大数据存储容量是2的32次方减1，数据范围是负的2的31次方到正的2的31次方减1 

long长整型8字节 64bit最大数据存储容量是2的64次方减1，数据范围为负的2的63次方到正的2的63次方减1 

浮点型

float单精度4字节 32bit数据范围在3.4e-45~1.4e38，直接赋值时必须在数字后加上f或F 

double双精度8字节 64bit数据范围在4.9e-324~1.8e308，赋值时可以加d或D也可以不加 

字符类型

char字符型用单引号 

布尔类型

boolean布尔型true/false（只有真假两种结果）

数据值域的知识说明： 

1.一个bit是计算机考研存储的最小的数据单位。即1位，只可能是0或1. 

2.一个byte由八个bit组成，即八位，可以表示256个整数值，又由于byte在Java中有符号之分（即正负数），所以范围位-128~127. 

3.一个char在Java中由两个byte组成，用来表示一个字符，即unicode编码，是无符号类型。 

4.int和float在Java中由4个byte组成。 

5.每个long或double型变量占用八个byte的存储空间。 

6.1T=1024G，1G=1024M，1M=1024K，1K=1024B 

小心得：

1.程序中的整数默认都是int型，即在方法调用直接传入的一个具体的整数值，默认情况下是int型。

2.值域小的的类型可以自动转化为值域大的。值域大的不能直接转化为值域小的，但是可以通过强制转化实现。 

eg： 

   byte a=10； 

int 

i=a；

（程序正常运行，输出的i为10） 

 

eg：int a=10； 

byte 

i=（byte）a； 

（程序正常运行，输出的i为10） 

若a的值超出了byte类型的上限或下限，可以输出值，但该值的数据会改变，改变规律如下： 

假设a为int型，b为byte型（其他情况可以类比！~） 

若a大于byte的上限值，则应减去其值域n次，直到最终的值落在-128~127之间，举个例子:

int a=1000； 

byte 

b=（byte）a；//1000-256-256-256-256=-24

（输出的b为-24） 

3.浮点型转化为整型是不是四舍五入，而是直接截去小数部分。如： 

double 

b=12.5； 

int 

i=(int)12.5; 

(输出值为12而不是13！) 

4.浮点型数字的科学表示方法： 

比如：1.2e+12f（表示1.2乘以10的12次幂） 

1e-21f(表示1乘以10的-21次幂) 

（2）对象数据类型（应用数据类型，类类型）

所有用class，interface，abstract 

class定义的类； 

String是Java定义的一个类。 

String的数据存储方式和Java的基本数据类型是一致的。 

String的定义方式 

String 

str="abc"; 

String 

str-new String();

对于数值类型的基本类型的取值范围，我们无需强制去记忆，因为它们的值都已经以常量的形式定义在对应的包装类中了。如：

基本类型byte 二进制位数：Byte.SIZE最小值：Byte.MIN_VALUE最大值：Byte.MAX_VALUE

基本类型short二进制位数：Short.SIZE最小值：Short.MIN_VALUE最大值：Short.MAX_VALUE

基本类型char二进制位数：Character.SIZE最小值：Character.MIN_VALUE最大值：Character.MAX_VALUE

基本类型double 二进制位数：Double.SIZE最小值：Double.MIN_VALUE最大值：Double.MAX_VALUE

注意：float、double两种类型的最小值与Float.MIN_VALUE、 Double.MIN_VALUE的值并不相同，实际上Float.MIN_VALUE和Double.MIN_VALUE分别指的是 float和double类型所能表示的最小正数。也就是说存在这样一种情况，0到±Float.MIN_VALUE之间的值float类型无法表示，0 到±Double.MIN_VALUE之间的值double类型无法表示。这并没有什么好奇怪的，因为这些范围内的数值超出了它们的精度范围。

Float和Double的最小值和最大值都是以科学记数法的形式输出的，结尾的"E+数字"表示E之前的数字要乘以10的多少倍。比如3.14E3就是3.14×1000=3140，3.14E-3就是3.14/1000=0.00314。

Java基本类型存储在栈中，因此它们的存取速度要快于存储在堆中的对应包装类的实例对象。从Java5.0（1.5）开始，JAVA虚拟机（Java Virtual Machine）可以完成基本类型和它们对应包装类之间的自动转换。因此我们在赋值、参数传递以及数学运算的时候像使用基本类型一样使用它们的包装类，但这并不意味着你可以通过基本类型调用它们的包装类才具有的方法。另外，所有基本类型（包括void）的包装类都使用了final修饰，因此我们无法继承它们扩展新的类，也无法重写它们的任何方法。

基本类型的优势：数据存储相对简单，运算效率比较高

包装类的优势：有的容易，比如集合的元素必须是对象类型，满足了java一切皆是对象的思想

2.Java中的常量

十六进制整型常量：以十六进制表示时，需以0x或0X开头，如0xff,0X9A。

八进制整型常量：八进制必须以0开头，如0123，034。

长整型：长整型必须以L作结尾，如9L,342L。

浮点数常量：由于小数常量的默认类型是double型，所以float类型的后面一定要加f(F)。同样带小数的变量默认为double类型。

如：float f;

    f=1.3f;//必须声明f。

字符常量：字符型常量需用两个单引号括起来（注意字符串常量是用两个双引号括起来）。Java中的字符占两个字节。一些常用的转义字符：

①\r表示接受键盘输入，相当于按下了回车键；

②\n表示换行；

③\t表示制表符，相当于Table键；

④\b表示退格键，相当于Back Space键；

⑤\'表示单引号；

⑥\''表示双引号；

⑦\\表示一个斜杠\。

3. 数据类型之间的转换

1).简单类型数据间的转换,有两种方式:自动转换和强制转换,通常发生在表达式中或方法的参数传递时。

自动转换

具体地讲,当一个较"小"数据与一个较"大"的数据一起运算时,系统将自动将"小"数据转换成"大"数据,再进行运算。而在方法调用时,实际参数较"小",而被调用的方法的形式参数数据又较"大"时(若有匹配的,当然会直接调用匹配的方法),系统也将自动将"小"数据转换成"大"数据,再进行方法的调用,自然,对于多个同名的重载方法,会转换成最"接近"的"大"数据并进行调用。这些类型由"小"到"大"分别为 (byte，short，char)--int--long--float—double。这里我们所说的"大"与"小",并不是指占用字节的多少,而是指表示值的范围的大小。

①下面的语句可以在Java中直接通过：

byte b;int i=b; long l=b; float f=b; double d=b;

②如果低级类型为char型，向高级类型（整型）转换时，会转换为对应ASCII码值，例如

char c='c'; int i=c;

System.out.println("output:"+i);输出：output:99;

③对于byte,short,char三种类型而言，他们是平级的，因此不能相互自动转换，可以使用下述的强制类型转换。

short i=99 ; char c=(char)i; System.out.println("output:"+c);输出：output:c;

强制转换

将"大"数据转换为"小"数据时，你可以使用强制类型转换。即你必须采用下面这种语句格式： int n=(int)3.14159/2;可以想象，这种转换肯定可能会导致溢出或精度的下降。

2)表达式的数据类型自动提升, 关于类型的自动提升，注意下面的规则。

①所有的byte,short,char型的值将被提升为int型；

②如果有一个操作数是long型，计算结果是long型；

③如果有一个操作数是float型，计算结果是float型；

④如果有一个操作数是double型，计算结果是double型；

例， byte b; b=3; b=(byte)(b*3);//必须声明byte。

3)包装类过渡类型转换

一般情况下，我们首先声明一个变量，然后生成一个对应的包装类，就可以利用包装类的各种方法进行类型转换了。例如：

①当希望把float型转换为double型时：

float f1=100.00f;

Float F1=new Float(f1);

double d1=F1.doubleValue();//F1.doubleValue()为Float类的返回double值型的方法

②当希望把double型转换为int型时：

double d1=100.00;

Double D1=new Double(d1);

int i1=D1.intValue();

简单类型的变量转换为相应的包装类，可以利用包装类的构造函数。即：Boolean(boolean value)、Character(char value)、Integer(int value)、Long(long value)、Float(float value)、Double(double value)

而在各个包装类中，总有形为××Value()的方法，来得到其对应的简单类型数据。利用这种方法，也可以实现不同数值型变量间的转换，例如，对于一个双精度实型类，intValue()可以得到其对应的整型变量，而doubleValue()可以得到其对应的双精度实型变量。

4)字符串与其它类型间的转换

其它类型向字符串的转换

①调用类的串转换方法:X.toString();

②自动转换:X+"";

③使用String的方法:String.volueOf(X);

字符串作为值,向其它类型的转换

①先转换成相应的封装器实例,再调用对应的方法转换成其它类型

例如，字符中"32.1"转换double型的值的格式为:new Float("32.1").doubleValue()。也可以用:Double.valueOf("32.1").doubleValue()

②静态parseXXX方法

String s = "1";

byte b = Byte.parseByte( s );

short t = Short.parseShort( s );

int i = Integer.parseInt( s );

long l = Long.parseLong( s );

Float f = Float.parseFloat( s );

Double d = Double.parseDouble( s );

③Character的getNumericValue(char ch)方法

5）Date类与其它数据类型的相互转换

整型和Date类之间并不存在直接的对应关系，只是你可以使用int型为分别表示年、月、日、时、分、秒，这样就在两者之间建立了一个对应关系，在作这种转换时，你可以使用Date类构造函数的三种形式：

①Date(int year, int month, int date)：以int型表示年、月、日

②Date(int year, int month, int date, int hrs, int min)：以int型表示年、月、日、时、分

③Date(int year, int month, int date, int hrs, int min, int sec)：以int型表示年、月、日、时、分、秒

在长整型和Date类之间有一个很有趣的对应关系，就是将一个时间表示为距离格林尼治标准时间1970年1月1日0时0分0秒的毫秒数。对于这种对应关系，Date类也有其相应的构造函数：Date(long date)。

获取Date类中的年、月、日、时、分、秒以及星期你可以使用Date类的getYear()、getMonth()、getDate()、getHours()、getMinutes()、getSeconds()、getDay()方法，你也可以将其理解为将Date类转换成int。

而Date类的getTime()方法可以得到我们前面所说的一个时间对应的长整型数，与包装类一样，Date类也有一个toString()方法可以将其转换为String类。

有时我们希望得到Date的特定格式，例如20020324，我们可以使用以下方法，首先在文件开始引入，

import java.text.SimpleDateFormat;

import java.util.*;

java.util.Date date = new java.util.Date();

//如果希望得到YYYYMMDD的格式

SimpleDateFormat sy1=new SimpleDateFormat("yyyyMMDD");

String dateFormat=sy1.format(date);

//如果希望分开得到年，月，日

SimpleDateFormat sy=new SimpleDateFormat("yyyy");

SimpleDateFormat sm=new SimpleDateFormat("MM");

SimpleDateFormat sd=new SimpleDateFormat("dd");

String syear=sy.format(date);

String smon=sm.format(date);

String sday=sd.format(date);

总结：只有boolean不参与数据类型的转换

（1）.自动类型的转换：a.常数在表数范围内是能够自动类型转换的

b.数据范围小的能够自动数据类型大的转换（注意特例）

int到float，long到float，long到double 是不会自动转换的，不然将会丢失精度

c.引用类型能够自动转换为父类的

d.基本类型和它们包装类型是能够互相转换的

（2）.强制类型转换：用圆括号括起来目标类型，置于变量前 

4.Java引用类型

Java有 5种引用类型（对象类型）：类 接口 数组 枚举 标注

引用类型：底层结构和基本类型差别较大

JVM的内存空间：（1）. Heap 堆空间：分配对象 new Student（）

（2）. Stack 栈空间：临时变量 Student stu

（3）.Code 代码区 ：类的定义，静态资源 Student.class

eg：Student stu = new Student（）； //new 在内存的堆空间创建对象

stu.study(); //把对象的地址赋给stu引用变量

上例实现步骤：

a.JVM加载Student.class 到Code区

b.new Student()在堆空间分配空间并创建一个Student实例

c.将此实例的地址赋值给引用stu，栈空间

 

 

二、Java数据类型的相关应用

         Java中不同类型数据间的转换

1、引言

Java 语言的数据类型有许多种, 如: char 、byte 、int、Integer、float 、Float 、String

, 它们彼此是不同的数据类型,有许多是相关的或是相容的。大多数Java教科书或资料上多一一介绍各个类型, 而少提及它们之间的关系, Java 的使用者一般都会遇到 Java 的数据类型之间转换的麻烦。

2、
Java的简单类型及其封装器类

我们知道, Java 语言是典型的支持面向对象的程序语言,但考虑到有些基本数据类型的结构简单, 占内存小且存取速度快等优点, Java依然提供了对这些非面向对象的简单数据类型的支持。当然, Java 在提供大量的其它类时,也提供了与简单数据类型对应的封装类, 于是, Java 中就有了诸如int和Integer( float和Float、double和Double
 
)的不同的数据类型。

Java 语言的数据类型有两大类: 一类是简单类型,也称主要类型( Primitive) , 另一类是引 用类型 ( Reference) 。

简单类型变量中存储的是具体的值, 而引用类型的变量中存储的是对象的引用。

Java 决定了每种简单类型的大小。这些大小并不随着机器结构的变化而变化。这种大小的不可更改正是 Java 程序具有很强移植能力的原因之一。

下表 1 列出了 Java 中定义的简单类型、占用二进制位数及

对应的封装器类。

表 1 
 Java 中的简单类型

简单类型  boolean  byte   char   short  int   long  float   double    void

二进制位数 1       8     16    1    6    32    64      32        64 

封装器类 Boolean  Byte  Character  Short Integer Long Float  Douele  Void

 
以int和Integer为例来说, 虽然从本质上它们都代表一个32位的整数,但它们 却是不同的数据类型。事实上, Java中直接使用的整数都为 i n t( 就int和Integer 而言) , 只有当数据必须作为对象的身份出现时, 才必须用i n t 对应的封装器I n tege 将整数值封装成对象, 这也是有许多 Java 的初学者甚至 还不这清楚什么是 Inte ger 的一个原因。

例如: 为给 j ava. u ti l 包 中的 Vec tor 添加 一个 整数, 就 必须

如下将该整数值封装在一个 I n tege r 实例中:

Ve ctor
 v= n ew Ve ctor ( ) ; 
 i n t k= 12 1; 
 v. add El emt ( ne w

Inte ger ( k ) ) ;

另外, Inte ger 作为 i nt 对应 的 封装 器 类, 提 供了 许 多 的方

法, 比如: Inte ger 的构造方法、 Inte ger 向其它各 种数值类型的转

换方法等等, 而这些是int 类型数据所没有的。

3、简单类型数据间的转换方式

简单类型数据 间的 转 换, 有两 种方 式: 自动 转换 和强 制转

换, 通常发生在表 达式 中或 方法 的参 数传 递时。 具体 地讲, 当

一个较 
 小
 数据与一个较
 大
 的数 据一起 运算时, 系统 将自动

将 
 小
 数据 转换成
 大
 数据, 再 进行 运算。 而在 方法 调用 时,

实际参数较 
 小
 , 而被调用的方 法的形式 参数数 据又较
 大
 时

( 若有匹配的, 当然会直接调用匹配 的方法) , 系统也 将自动 将

小 
 数据转换成
 大
 数 据, 再进 行方 法的 调用, 自 然, 对于 多个

同名的重载方法, 会转换成最
 接近
 的
 大
 数据并进行调用。

例如: 若有方法:

f( b yte x) { 
 
} ;

f( s h ort x) { 
 
} ;

f( i nt x) { 
 
} ;

f( l ong x) { 
 
} ;

f( f l oat x) { 
 
} ;

f( d ou bl e x) { 
 
} ;

又有: char y= 
 A 
 ; 那么, 语句 f( y) 会调用哪一个方法呢?

答案是: f( i n t x) { 
 
} 方法, 因为它的 形参比实参
 大
 且

是最
 接近
 的。

而对于方法:

f( f l oat x) { 
 
} ;

f( d ou bl e x) { 
 
} ;

又有: l ong y= 1 23 L ; 那么, 语句 f( y) 调用的方法则是 f( fl oa t

x ) { 
 
} 。这个例子同 时也 向我 们证 明, 我们 所说 的
 大
 与

 小
 , 并不是指占用字节的多少, 而是指表示值的范围的大小。

而当
 大
  小
 不同的数据在一 起运算, 且 较
 大
 数 据要向

较
 小
 的数据类型看齐时, 或 要将较
 大
 实参 传递给较
 小
 的

形参时, 必须通过形如( X) Y 的方式来 进行强制 转换, 这 里 Y 是

较
 大
 的数据类型, 而 X 是较
 小
 的数 据类型标 识符, 如: i nt n

= ( i nt ) 3. 14 159 / 2 。

另外一种情形是, 利 用封 装器 类, 实现 简单 类型 数据 间的

相互 转换。下 面 仍然 以 Inte ger 为 例, 介 绍一 下 封装 器 Inte ger

的构造方法, 其它的封装器是 相似的。

将一个整数封装成 I n tege r 的实例的格式是: Inte ger ( i n t) ;

将一个整数字符串封 装成 I n tege r 的实 例的格式是: Inte ger

( St ri n g[ , i n t] ) 。

值得一提的是, 还有一种方法也可 以构造一个 I n tege r 的实

例, 那就是:

Inte ger. val u eOf( St ri n g[ , i n t] ) 。

绝大多数封装器类, 都提供 了众多 的向简 单数据类 型转换

的方法, 将封装器实例 X 转换成 Y 类型的简单数据 值一般格式

为: X. YV a l u e( ) 。

例如: 将整数值 321 转换成对 应的短 整数值 的格式为 : new

Inte ger ( 3 21 ) . shor tVal u e( ) ; 而 将 fl oa t 型 值 32 . 1 F 转 换 d oub l e

型的值的格式为: new Fl oat( 32 . 1 F ) . d ou bl eVal u e ( ) 。

 

4、引用类型间的转换

引用类型的实例间 的转 换只 限于 有继 承关 系的 类的 对象

之间。如有两个继承关系类: p aren t 和 chi l d , ch i l d 类型 的实例

向 par ent 型实例的转换是自动的, 但反过来的 转换强制 转换虽

然是可以的, 但是, 是不安全的。

5、字符串与其它类型间的转换

由于字符串是一种常用的数据类型, 故 Java 中 提供了与各

种数据类型间的转换方法。

首先, 看其它类 型向字 符串 的转换 , 将 实例 变量 X 转 换成

字符串的常用方法有:

1) 调用类的串转换方法: X . toS tri ng( ) ;

2) 自动转换: X+ 
  ;

3) 使用 S tri ng 的方法: S tr i ng . vol u e Of( X) ;

4) 强制类型转换: ( S tri ng ) X。

其次, 字符串作为值, 向其它类 型的转换 , 通 常要先 转换成

相应的封装 器实例, 再调 用对 应的 方法 转换 成其 它类 型, 如将

字符中 
 32 . 1
 转换 dou bl e 型的值的格式为: n ew Fl oat(
 32 . 1
 ) .

d oub l eVal u e( ) 。

也可以用: Doub l e . val ue Of( 
 3 2. 1 
 ) . d oub l e Val u e( ) 。

不少的封装器类, 还提供了静态转换方法 , 如:

B ool e a n . ge tBool ean( S tri ng) , B yte. p arseB yte( St ri n g) , I n te 

ger . p a r seInt( Str i n g ) , Sh ort. p arseS hort( S tri ng) , L ong. par seLon g

( S tri ng)

例如, 将文本框 t ext1 中的字符 串转换成 整数, 并保 存到整

型变量 k 中的语句就可以写成:

i nt k = 0 ;

tr y { k = I nt eger . p arseInt( text1. ge tTe xg( ) ) ; }

c a t ch ( Numb er FormatE x c ept i on ( eve nt) )

{ text1. set Te x t ( 
 请确 保本文 本框 中输入 的是 数字字 符!
 )

; }

6、字符串与类实例

最后, 我们也介绍一下, 字符串作为类名时, 可以动态地创建相应的类实例, 这时, 则要用到Cl as s 类的两个重要的方法,即, 将字符串转换成类名的静态方法 Cl ass . f or Name( S tri ng) , 以及利用类来创建相应实例的方法newInstance ( ) 。需要特别注意的两点是:

 n ewInstanc e 的目标类必须有一个无参 的构造函数;

 n ewInstanc e 创建的是一个 C l ass 类型的实例 , 必须在使用前将其转换成一个更具体的类型。

例如, 我们要随机画出四种花色的纸牌中的一个, 假设已定义好有如下继承结构的类:

shap e 
 ( s h a p e 
 、 shape
 、shap e 
 、sh a p e 
 ) 。

那么, 随机地创建一个相应的纸牌实例的代码可以如下:

S tri ng s[ ] = { 
 shap e 
 
 , 
 s h ape 
 
 , 
 shap e 
 
 , 
 s h ape

 
 } ;

i nt k= ( i n t) Math . ( rand om( ) * 4) ;

shap e sh= ( s h ape ) Cl ass . forName ( s[ k ] ) . n ewInstanc e( ) ;

Date 类与其它数据类型的相互转换就比较简单, 主要用到是其构造函数和toString( )方法, 在此不再细述。

7、结束语

对于简单类型, 
大
数据向
小
数据转换需要强制转换;而小
数据向
大
数据转换通常利用其对应的封闭器类提供的方法来进行, 当然, 也可能进行自动转换; 简单类型向字符串的转换方法较多, 而使用与空串联结的方法比较简洁; 字符串向简单类型的转换, 通常先构造一个对应封闭器类的实例, 再使用对应的封闭器类提供的静态方法进行; 字符串向引用类型的转换, 则要用到 C l ass 类的两个重要的方法; 引用类型间的转换只能在有继承关系的类实例间进行。

8、结论

计算机技术的发展日新月异, Web 网络正在通Web Se r vice 网络服务技术向网格 悄然嬗变。事实上, 许多大型网络应用系统, 尤其网络游戏, 已经具备了 网格应 用的特征, 至少是网格应用雏形。针对某些网格还很遥远
以及
网格是未来的事情
等认识, 我从Webs er vi c e 被工业界广泛接受的事实出发, 指出
网格已经到来
、网格就在身边
。

Web S er v i c e 技术就是我们追求的网格基础设施基础,指出连通性是网格基 础设施的最重要特征。提出了本质安全性概念, 并基于网格基础设施构造了具有本质安全特性的v g OS 。

网格应用具有更低使用门槛、更低开发难度、更快开发进度、更低维护成本等诸多软件开发者梦寐以求的优点。我们应该抓住机遇, 尽快发展网格技术, 促进国 民经济发展。（材料参考文献《Java 中不同类型数据间的转换》作者：龚雄兴）