java 基本类型的相互转换_JAVA_编程开发_程序员俱乐部

int z=257；
byte x=(byte)z；
为什么x等于1

因为在java中，int类型的占4个字节，而byte占1个字节，所以int类型转化为byte类型时会出现位丢失情况，即将int的低8位作为byte类型的值。int型变量的值为257，对应的二进制是100000001，后8位是00000001，第一个0表示符号位，表示正数，所以变量x的值为1。

http://blog.sina.com.cn/s/blog_6ab84a580100vndv.html

Java包装类：在介绍具体的数据类型转换之前，我们有必要先介绍java中的一个特殊的拆装箱类型----java包装类。


Java包装类出现的目的：为了能够使java程序员可以将java中基本数据类型视为类引用类型进行操作，即直接将简单类型的变量表示为一个类。


Java共分为六个包装类，分别是Boolean,Character,Integer,Long,Float和Double。当然从字面上我们就能看出他们分别对应的是boolean , char , int , long , float ,double .除此之外，我们常见的String和Date类型本身就是类引用类型的，所以就不存在什么包装类的概念。


详细的转换机制：


基本数据类型之间的转换：


基本数据类型之间有一定的优先级顺序，在java中变量的优先级由低到高的排列顺序是：byte -  (short  ,   char)  -    int   -  long  -   float  -   double


基本数据类型之间的转换可分为两种：


自动类型转换：由优先级低的数据类型转向优先级高的数据类型。
举例：char  c = 10 ;

             int b = c ;

             long d = c ;

强制类型转换：由优先级高的数据类型转向优先级低的数据类型。
举例： float  f = 3 ;

              int  a = f ; (编译器会报错)，正确的写法是：int  a  =(int) f ;

很显然，这样的转换可能会导致数据溢出或是精度下降。



简单类型变量和包装类之间的转换：


简单数据类型转换成相应的包装类，可以利用包装类的构造函数。如Boolean(boolean value)  , Character(char  value)  ,   Integer( int   value) , Long (long  value)  ,Float (float  value) , Double(double  value)


而包装类转换成相应的简单数据类型，可以利用包装类中的xxValue()方法。如Long.intValue()可以将Long包装类型的变量转换成int型的数据类型。


String型和其他数据类型之间的数据转换：


String类型和包装类之间的转换：


String 类型转换成各种包装类，除了Character包装类之外，都有可以直接使用字符串作为参数的构造函数使得String类型转换成各种包装类；比如new Integer(String value) , Long(String value) , Double (String value)


包装类转换成String类型,可以使用各种包装类提供的toString()方法。如Long LongValue = 13 ; LongValue.toString();


String 类型和基本数据类型之间的转换：


String 类型转换成基本数据类型可以使用基本数据类型的包装类的parseXxx（）方法。如 Long.parseLong(String value)就可以将一个String类型的数据转换成一个long型的数据。

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

http://hi.baidu.com/mangzijava/blog/item/9cdab44582eb7184b2b7dc89.html

java的类命名风格：

1java的类首字母最好大写，然后使用“驼峰式”，就是说累的每个单词的首字母都要大写，这个是不仅仅在类命名如此使用，而是在包括方法取名等都是这样的方式，而且最好名字可以“见名知意”。例如“ClassName”.
2 源代码的文件名必须与包含main()方法的类名相同


java的数据类型：

java的数据类型的范围是固定不变的，在不同的操作系统中都是固定的，正因为这个特点才使得它有跨平台的优越性。因为当你用C语言写好一个程序编译好，是不可以在不同的平台使用的因为在不同它的数据类型是不确定的，比如说int型，在别的语言中不同的平台存储需求是不同的，可能是4个字节，也可能是两个字节。而在java中则很确定它是4个字节，不多比较了，直接来看看java中的四种基本数据类型。
整型（默认的是int型，如果使用long型的，则需要在数字后面加上l）
btye 1个字节 -128~127
short 2个字节 -32768~32767
int    4个字节 取值范围很大就不说啦
long 8个字节 略
浮点型有两种哦(默认是double型的，如果使用浮点型就必须在数字后面加上f)
float 4个字节 很很大
double 8个字节   大的惊人

告诉了大家java的几个数据类型，那么有新的问题出现了，数据类型会互相转换吗?

那么让我们往后详细解释吧

byte short char 一般不会互相转化，如果转化通常是转化成为int型的，另外就是我们要说说它们的转化原则，按照它们的大小，也就是它们表示的范围来判断它们的大小顺序   byte short char >>int >>long>>float>>double
有这么几条总结的原则

1整数型的数据都是默认为int型，而浮点型的数据都是默认为double型的
2表示范围大的转化为小的时候，分几点情况，首先在整数类型时，当范围大的那个类型转化为小的时候，如果范围大的那个类型不超过小类型表示的范围，那么就可以直接赋值表示，比如:
byte = 1 就是可以的，因为虽然1是整数常量，所以当表示出来它就默认为int型的，而int型转化为byte本来是需要强制转化符号的，但是因为只是赋值的类型转化，而1又在byte 的表示范围之内所以就可以不用加任何符号就直接使用了。而如果是需要计算的式子，那么就算计算的结果没有超过小类型的范围，那么也不可以。
例如 int i =2 ;int j = 4;
byte b=(byte)( i + j); 如果不加这个强制转换的话，就是错误了哦.
另外当大范围转化为小范围时还需要注意的就是，看下面的例子，因为口说无凭嘛

例子：
double d = 3333310.40;
float f = (float)d;如果不加也是错误的

还有一个很小的地方补充一下：就是以下两种写法其实本质上是大不相同的

float f1 = 233434.33f;这个是直接定义的变量就是float型的

float f1 = (float)233434.33;这个是将一个double型的转化为float


3还有种需要单独提出的类型，枚举类型，和c++中的类似，让我们直接看它是如何使用的吧

enum Size{S, M, L, XL,XXL};

size s = Size.M;

现在先简单的提一下它，让我们日后再详细类解释吧


4有些类型不用单独提出来讲了，因为没什么意思。让我们讲讲大家不知道的东西吧，关于字符串一直都是个问题在各种语言里，使用却是不完全一样的，那么就让我们看看在java里有什么不同之处吧

String s = "hello";

String sb = s.substring(0, 2);

知道这样会输出什么吗？会输出 he, 这个是不是非常有趣，他可以将你的字符串分成字串输出呢

要知道我们容易迷惑的是会把java的字符串当作一个字符数组，其实这个观念是错误的，java中的string是一个引用类型，它只是类似一个指针，（是这样的指针char*).



以上就是关于几种类型转换的问题，还是一样当我发现还需要补充的时候，我会继续改的
---------------------------

Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。
1、整数：包括int,short,byte,long
2、浮点型：float,double
3、字符：char
4、布尔：boolean

基本型别 大小 最小值 最大值
boolean ----- ----- ------
char 16-bit Unicode 0 Unicode 2^16-1
byte 8-bit -128 +127
short 16-bit -2^15 +2^15-1
int 32-bit -2^31 +2^31-1
long 64-bit -2^63 +2^63-1
float 32-bit IEEE754 IEEE754
double 64-bit IEEE754 IEEE754
void 　 　 　


注意！：表格里的^代表的是次方哈～

使用 Float 类 节省开发时间
作者： Builder.com
2004-11-16 11:50 AM

即使你可能知道 IEEE 浮点数，你可能也从来没有逐个比特地处理过这类数据。下面我将向你展示如何逐个比特地处理 IEEE 浮点数，下次在你的 Java 项目需要从比特序列创建浮点数时，或者从浮点数创建比特序列时，你就知道Float 类可以为完成这一工作。

IEEE 浮点数介绍

IEEE 754 浮点单精度数字格式定义了一个用于存储浮点数的比特布局。在空比特布局中，一个比特留作符号位，八个比特留作指数，23个比特留作尾数。这些比特是按最重要比特到最不重要比特进行排列的，如下例所示：



31                             0
|                              |                     
SEEEEEEEEMMMMMMMMMMMMMMMMMMMMMMM

其中：

S = 符号位
E = 指数
M = 尾数

你可以从 IEEE 的站点购买一份 IEEE 浮点数的完整解释。（如果在线搜索 IEEE 754，你应该可以找到免费的版本。）

Float 对 Java 社区的贡献

下面的示例程序使用 Float 的两个方法将一个浮点数转成比特，然后又将这些比特转成一个浮点数。

使用Float.floatToIntBits(float f) 方法可以将一个浮点数转成一个比特序列。这个方法返回一个32位整数，表示你作为参数提供的浮点数的 IEEE 754 比特排列。

使用Float.intBitsToFloat(int bits) 方法可以进行反方向转换。这个方法接受传入的整数作为参数，将这些比特转成一个 IEEE 浮点数。

下面是示例程序：

public class BitsTip {
    public static void main(String args[]) {
        float f = Float.parseFloat(args[0]);
        int bits = Float.floatToIntBits(f);

        System.out.println("bits: " + bits);
        System.out.println("back to float: " + Float.intBitsToFloat(bits));
    }
}

如果你曾经必须要手工进行这种转换，那么你就会很欣赏这两个简单的方法为你节省的工作。如果你正在处理64位数，那么可以选择使用Double 包装器（wrapper）类。这个类提供同样的方法处理IEEE 754 双精度浮点数。

最好选择阅读一下javadoc，查阅里面有关浮点数与比特序列之间的转换的部分，以便完整地了解这些方法都能为你些做什么。
-----------------


基本类型，或者叫做内置类型，是JAVA中不同于类的特殊类型。它们是我们编程中使用最频繁的类型，因此面试题中也总少不了它们的身影，在这篇文章中我们将从面试中常考的几个方面来回顾一下与基本类型相关的知识。

基本类型共有八种，它们分别都有相对应的包装类。关于它们的详细信息请看下表：

基本类型可以分为三类，字符类型char，布尔类型boolean以及数值类型byte、short、int、long、float、double。数值类型又可以分为整数类型byte、short、int、long和浮点数类型float、double。JAVA中的数值类型不存在无符号的，它们的取值范围是固定的，不会随着机器硬件环境或者操作系统的改变而改变。实际上，JAVA中还存在另外一种基本类型void，它也有对应的包装类 java.lang.Void，不过我们无法直接对它们进行操作。对于数值类型的基本类型的取值范围，我们无需强制去记忆，因为它们的值都已经以常量的形式定义在对应的包装类中了。请看下面的例子：
Java代码
public class PrimitiveTypeTest { 
    public static void main(String[] args) { 
        // byte 
        System.out.println("基本类型：byte 二进制位数：" + Byte.SIZE); 
        System.out.println("包装类：java.lang.Byte"); 
        System.out.println("最小值：Byte.MIN_VALUE=" + Byte.MIN_VALUE); 
        System.out.println("最大值：Byte.MAX_VALUE=" + Byte.MAX_VALUE); 
        System.out.println(); 
 
        // short 
        System.out.println("基本类型：short 二进制位数：" + Short.SIZE); 
        System.out.println("包装类：java.lang.Short"); 
        System.out.println("最小值：Short.MIN_VALUE=" + Short.MIN_VALUE); 
        System.out.println("最大值：Short.MAX_VALUE=" + Short.MAX_VALUE); 
        System.out.println(); 
 
        // int 
        System.out.println("基本类型：int 二进制位数：" + Integer.SIZE); 
        System.out.println("包装类：java.lang.Integer"); 
        System.out.println("最小值：Integer.MIN_VALUE=" + Integer.MIN_VALUE); 
        System.out.println("最大值：Integer.MAX_VALUE=" + Integer.MAX_VALUE); 
        System.out.println(); 
 
        // long 
        System.out.println("基本类型：long 二进制位数：" + Long.SIZE); 
        System.out.println("包装类：java.lang.Long"); 
        System.out.println("最小值：Long.MIN_VALUE=" + Long.MIN_VALUE); 
        System.out.println("最大值：Long.MAX_VALUE=" + Long.MAX_VALUE); 
        System.out.println(); 
 
        // float 
        System.out.println("基本类型：float 二进制位数：" + Float.SIZE); 
        System.out.println("包装类：java.lang.Float"); 
        System.out.println("最小值：Float.MIN_VALUE=" + Float.MIN_VALUE); 
        System.out.println("最大值：Float.MAX_VALUE=" + Float.MAX_VALUE); 
        System.out.println(); 
 
        // double 
        System.out.println("基本类型：double 二进制位数：" + Double.SIZE); 
        System.out.println("包装类：java.lang.Double"); 
        System.out.println("最小值：Double.MIN_VALUE=" + Double.MIN_VALUE); 
        System.out.println("最大值：Double.MAX_VALUE=" + Double.MAX_VALUE); 
        System.out.println(); 
 
        // char 
        System.out.println("基本类型：char 二进制位数：" + Character.SIZE); 
        System.out.println("包装类：java.lang.Character"); 
        // 以数值形式而不是字符形式将Character.MIN_VALUE输出到控制台 
        System.out.println("最小值：Character.MIN_VALUE=" 
                + (int) Character.MIN_VALUE); 
        // 以数值形式而不是字符形式将Character.MAX_VALUE输出到控制台 
        System.out.println("最大值：Character.MAX_VALUE=" 
                + (int) Character.MAX_VALUE); 
    } 
} 

运行结果：

1、基本类型：byte 二进制位数：8
2、包装类：java.lang.Byte
3、最小值：Byte.MIN_VALUE=-128
4、最大值：Byte.MAX_VALUE=127
5、
6、基本类型：short 二进制位数：16
7、包装类：java.lang.Short
8、最小值：Short.MIN_VALUE=-32768
9、最大值：Short.MAX_VALUE=32767
10、
11、基本类型：int 二进制位数：32
12、包装类：java.lang.Integer
13、最小值：Integer.MIN_VALUE=-2147483648
14、最大值：Integer.MAX_VALUE=2147483647
15、
16、基本类型：long 二进制位数：64
17、包装类：java.lang.Long
18、最小值：Long.MIN_VALUE=-9223372036854775808
19、最大值：Long.MAX_VALUE=9223372036854775807
20、
21、基本类型：float 二进制位数：32
22、包装类：java.lang.Float
23、最小值：Float.MIN_VALUE=1.4E-45
24、最大值：Float.MAX_VALUE=3.4028235E38
25、
26、基本类型：double 二进制位数：64
27、包装类：java.lang.Double
28、最小值：Double.MIN_VALUE=4.9E-324
29、最大值：Double.MAX_VALUE=1.7976931348623157E308
30、
31、基本类型：char 二进制位数：16
32、包装类：java.lang.Character
33、最小值：Character.MIN_VALUE=0
34、最大值：Character.MAX_VALUE=65535

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

大家将运行结果与上表信息仔细比较就会发现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类型无法表示。这并没有什么好奇怪的，因为这些范围内的数值超出了它们的精度范围。

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





      Java整型





int

4字节

-2147483648 ~ 2147483647   (正好超过20亿)



short

2字节

-32768 ~ 32767



long

8字节

-9223372036854775808 ~ 9223372036854774807



byte

1字节

-128 ~ 127




      浮点类型




float

4字节

大约±3.40282347E+38F (有效位数为6-7位)



double

8字节

大约±1.79769313486231570E+308 (有效位数为15位)


一些需要注意：


1if(x == Double.NaN)  // is never true


1if(Double.isNaN(x))  // check whether is "not a number"

      浮点数值不适合用于禁止出现舍入误差的金融计算中。例如System.out.println( 2.0 - 1.1);将打印0.899999999999999，而不是0.9。因为浮点数值采用二进制系统表示，而二进制无法精确表示分数1/10，就像十进制无法精确表示1/3一样。如果需要在数值计算中不含有舍入误差，就应该使用BigDecimal类。


      char类型

      在Java中，char类型用UTF－16编码描述一个代码单元。强烈建议不要在程序中使用char。


      boolean类型

      在C或C++中数值或指针可以代替boolean的值，0相当于flase，非0相当于true，而在Java中则不行，并且在编译时就会报错。