java---基本数据类型

数据类型：基本数据类型和引用数据类型
基本数据类型:保存在栈内存中的简单数据段.即这种值完全保存在内存中的一个位置。
引用数据类型:保存在栈内存中的引用名指向保存在堆内存中的对象，类似一个指针， java中除了基本类型其他都是引用类型。
引用类型，默认值是null(空值)

八种基本数据类型：

整数型:
1byte = 8Bit

byte b1=10;//1个字节（二进制8位）（-128~127）
short //短整型，2个字节
int //整形，4个字节
long L1 = 10L;//长整型，8个字节

字符型:

char c='a'

1） char类型是一个单一的16 位Unicode 字符
2）最小值 ‘\uo000’ (即为0)
3）最大值 ‘\uFFFF’ (即为65535)
4）作用: char数据类型可以储存任何字符
5）示例: char no = 'a';给char类型赋值，c必须要用单引号”

布尔型:

默认值是false

boolean b1=true; //false

浮点型:

float f1=1.1f;//单精度
double d1=2.2;//双精度

float：
1）float数据类型是单精度，32位，符合IEEE754标准的浮点数;
2）最小值 1.17549435E-38f = 1. 1754943*(10^—38)
3）最大值 3.4028235e+38f
4）默认值 0.0f
5）示例: float no = 12.123f;
double:
1）double数据类型是双精度、64位、符合IEEE 754标准的浮点数
2）最小值 2.2250738585072014E-308
3）最大值 1.7976931348623157e+308

解释:单精度和双精度的概念和区别
单精度和双精度精确的范围不一样。单精度，也即float，一般在计算机中存储占用4字节，也就是32位，有效位数为7位;双精度（double）在计算机中存储占用8字节，64位.有效位数为16位。
单精度浮点型（float）：专指占用32位存储空间的单精度（single-precision ）值。单精度在一些处理器上比双精度更快而且只占用双精度一半的空间，但是当值很大或很小的时候。它将变得不精确。当你需要小数部分并且对精度的要求不高时，单精度浮点型的变量是有用的。例如，当表示美元和分时，单精度浮点型是有用的。
双精度型（double）：占用64位的存储空间。在一些现代的被优化用来进行高速数学计算的处理器上双精度型实际上比单精度的快。所有超出人类经验的数学函数。如sin( )，cos( ) ，和sqrt( )均返回双精度的值。当你需要保持多次反复迭代的计算的精确性时，或在操作值很大的数字时，双精度型是最好的选择。

类型转换：
自动类型转换
数值的范围越大，表示该数据类型的精度越高，根据精度的由低到高排序为

byte -> short,char -> int -> long -> float ->double

根据上面顺序，低精度数据类型的变量，可以自动地转为高精度类型的变量。

强制类型转换只发生在高精度类型转为低精度类型的情况下,必须显式的在变量前声明要转换的数据类型，且会损失数据精度，如:

float a = 12.23f;
int b = (int) a;

数据类型转换规则:
1)不能对boolean类型进行类型转换;
2)把高精度类型转换为低精度类型时，必须使用强制类型转换;
3)转换过程中可能导致溢出或损失精度（高精度转低精度)；
4)浮点数到整数的转换．舍弃小数部分，而不是四舍五入;

基本数据类型包装类：

基本数据类型 创建了对应的引用数据类型:

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

Integer b = Integer.valueOf(4);//装箱方法 都是valueOf()
a.intValue();拆箱方法 xxxValue()
jdk1.5之后,自动装箱-把基本数据类型包装成引用数据类型
自动拆箱 -把引用数据类型或封装类型变成基本数据类型

public static void test4() {
		int a = 5;
		int b = 5;
		System.out.println(a == b);//"true"
		Integer c = new Integer(100);
		Integer d = new Integer(100);
		//引用数据类型c与d指向的地址不同，故输出false
		System.out.println(c == d);//"false"
		
		Integer e = new Integer(200);
		Integer f = 200;//Integer.valueOf(200);
		//f自动装箱，e与f指向的地址不同，故输出false
		System.out.println(e == f);//"false"
		
		Integer g = new Integer(300);
		int h = 300;
		//g自动拆箱，把g拆成基本数据类型
		System.out.println(g == h);//"true"
		
		/*当触发自动装箱时 首先 去缓存区域中获取，若缓冲区域中有就会赋值，如：k与m，缓冲区域中有100，直接赋值，故k与m比较返回的是true；
		*而若缓冲区中没有就会新建，如,i与j,缓存中没有400，故返回值为false。
		*/
		Integer i = 400;
		Integer j = 400;
		System.out.println(i == j);//"false"
		Integer k = 100;
		Integer m = 100;
		System.out.println(k == m);//"true"
	}

主要属性和方法（Integer类为例）：
（1）属性：
public static final int MAX_VALUR //返回int数据的最大值
public static final int MIN_VALUR //返回int数据的最小值
（2）构造方法：
public Integer(int value)//利用整数生成对象
public Integer(String s)//利用字符串生成对象
（3）成员方法：
public int intValue() //返回对象的整数值
public double doubleValue() //返回对象的浮点数值
public String toString() //将对象对应整数值转化为字符串
public static String toString() //将指定整数转化为10进制字符串
public static int parseInt(String s) //将字符串转化为整数
public static Integer valueOf(String s) //利用字符串转化为对象
（4）实例：

public class Test {
    public static void main(String[] args) {
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
        Integer i1 = new Integer(123);
        Integer i2 = new Integer("123");
        System.out.println(i1 == i2);
        System.out.println(i1.equals(i2));//判断两个值是否相等
        System.out.println(i1.intValue());
        System.out.println(i1.doubleValue());
        int i3 = Integer.parseInt("12");//字符串转基本类型
        int i4 = Integer.parseInt("34");
        System.out.println(i3 + i4);
        int i5=Integer.parseInt("12",8);//其它进制转十进制
        String s1=Integer.toString(10,2);//十进制转其它进制
        System.out.println(i5+","+s1);
        Integer a = 10;//基本类型和包装类型自动转换，自动装箱（Auto Boxing）
        int i = a;//自动拆箱（Auto Unboxing）
        System.out.println(i);
        String s2=123+"";//基本类型转字符串的简单方法
        System.out.println(s2);
    }
}

结果：
2147483647
-2147483648
false
true
123
123.0
46
10,1010
10
123