Java支持的8种基本数据类型

墨蓝 2022-05-20 07:25 239阅读 0赞

## 官方文档 ##

*  [Primitive Data Types][]

**In addition to the eight primitive data types listed above, the Java programming language also provides special support for character strings via the java.lang.String class. Enclosing your character string within double quotes will automatically create a new String object; for example, String s = “this is a string”;. String objects are immutable, which means that once created, their values cannot be changed. The String class is not technically a primitive data type, but considering the special support given to it by the language, you’ll probably tend to think of it as such. You’ll learn more about the String class in Simple Data Objects**

## 列举 ##

byte（字节型）、short（短整型）、int（整型）、long（长整型）、float（单精度浮点型）、double（双精度浮点型）、boolean（布尔型）、char（字符型）

## 对应包装类 ##

java.lang.Byte、java.lang.Short、java.lang.Integer、java.lang.Long、java.lang.Float、java.lang.Double、java.lang.Boolean、java.lang.Character

## 详细划分 ##

**具体可分为四类**

*  整型 byte short int long
 *  浮点型 float double
 *  逻辑型 boolean
 *  字符型 char

## 八种基本数据类型的默认值 ##

<table> 
 <tbody> 
 <tr> 
 <td> 序号 </td> 
 <td> 数据类型 </td> 
 <td> 大小/位 </td> 
 <td> 封装类 </td> 
 <td> 默认值（零值） </td> 
 <td> 可表示数据范围 </td> 
 </tr> 
 <tr> 
 <td> 1 </td> 
 <td> byte(字节) </td> 
 <td> 8-bit </td> 
 <td> Byte </td> 
 <td> (byte)0 </td> 
 <td> -128~127 </td> 
 </tr> 
 <tr> 
 <td> 2 </td> 
 <td> short(短整数) </td> 
 <td> 16-bit </td> 
 <td> Short </td> 
 <td> (short)0 </td> 
 <td> -32768~32767 </td> 
 </tr> 
 <tr> 
 <td> 3 </td> 
 <td> int(整数) </td> 
 <td> 32-bit </td> 
 <td> Integer </td> 
 <td> 0 </td> 
 <td> -2147483648~2147483647 </td> 
 </tr> 
 <tr> 
 <td> 4 </td> 
 <td> long(长整数) </td> 
 <td> 64-bit </td> 
 <td> Long </td> 
 <td> 0L </td> 
 <td> -9223372036854775808~9223372036854775807 </td> 
 </tr> 
 <tr> 
 <td> 5 </td> 
 <td> float(单精度) </td> 
 <td> 32-bit </td> 
 <td> Float </td> 
 <td> 0.0F </td> 
 <td> 1.4E-45~3.4028235E38 </td> 
 </tr> 
 <tr> 
 <td> 6 </td> 
 <td> double(双精度) </td> 
 <td> 64-bit </td> 
 <td> Double </td> 
 <td> 0.0D </td> 
 <td> 4.9E-324~1.7976931348623157E308 </td> 
 </tr> 
 <tr> 
 <td> 7 </td> 
 <td> boolean </td> 
 <td> but its "size" isn't something that's precisely defined. </td> 
 <td> Boolean </td> 
 <td> flase </td> 
 <td> true或false </td> 
 </tr> 
 <tr> 
 <td> 8 </td> 
 <td> char(字符) </td> 
 <td> 16-bit </td> 
 <td> Character </td> 
 <td> '\u0000'（对应数字0，输出为空） </td> 
 <td> 0~65535 </td> 
 </tr> 
 </tbody> 
</table>

## 实例 ##

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

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);  
        }  
    }

## 8 种基本类型的包装类和常量池 ##

*  Java 基本类型的包装类的大部分都实现了常量池技术，即 Byte,Short,Integer,Long,Character,Boolean；这 5 种包装类默认创建了数值\[-128，127\] 的相应类型的缓存数据，但是超出此范围仍然会去创建新的对象。
 *  两种浮点数类型的包装类 Float,Double 并没有实现常量池技术。

> 具体实现，Integer的静态内部类IntegerCache，Long的静态内部类LongCache

## ClassUtils源码 ##

> org.springframework.util.ClassUtils

static { 
 	primitiveWrapperTypeMap.put(Boolean.class, boolean.class);
 	primitiveWrapperTypeMap.put(Byte.class, byte.class);
 	primitiveWrapperTypeMap.put(Character.class, char.class);
 	primitiveWrapperTypeMap.put(Double.class, double.class);
 	primitiveWrapperTypeMap.put(Float.class, float.class);
 	primitiveWrapperTypeMap.put(Integer.class, int.class);
 	primitiveWrapperTypeMap.put(Long.class, long.class);
 	primitiveWrapperTypeMap.put(Short.class, short.class);
 
 	for (Map.Entry<Class<?>, Class<?>> entry : primitiveWrapperTypeMap.entrySet()) { 
 		primitiveTypeToWrapperMap.put(entry.getValue(), entry.getKey());
 		registerCommonClasses(entry.getKey());
 	}
 
 	Set<Class<?>> primitiveTypes = new HashSet<Class<?>>(32);
 	primitiveTypes.addAll(primitiveWrapperTypeMap.values());
 	primitiveTypes.addAll(Arrays.asList(new Class<?>[] { 
 			boolean[].class, byte[].class, char[].class, double[].class,
 			float[].class, int[].class, long[].class, short[].class}));
 	primitiveTypes.add(void.class);
 	for (Class<?> primitiveType : primitiveTypes) { 
 		primitiveTypeNameMap.put(primitiveType.getName(), primitiveType);
 	}
 
 	registerCommonClasses(Boolean[].class, Byte[].class, Character[].class, Double[].class,
 			Float[].class, Integer[].class, Long[].class, Short[].class);
 	registerCommonClasses(Number.class, Number[].class, String.class, String[].class,
 			Object.class, Object[].class, Class.class, Class[].class);
 	registerCommonClasses(Throwable.class, Exception.class, RuntimeException.class,
 			Error.class, StackTraceElement.class, StackTraceElement[].class);
 }

## 数值自动转换 ##

>  *  该部分转载自他人，[点击查看原文][Link 1]
>  *  char可以转型成int，但是Character是绝对不会转型为Integer的，它只能安全地转型为它实现的接口或父类。

*  转换原则：从低精度向高精度转换byte 、short、int、long、float、double、char
 *  数据类型的转换，分为自动转换和强制转换。自动转换是程序在执行过程中“悄然”进行的转换，不需要用户提前声明，一般是从位数低的类型向位数高的类型转换；强制类型转换则必须在代码中声明，转换顺序不受限制。

### 自动数据类型转换 ###

*  自动转换按从低到高的顺序转换。不同类型数据间的优先关系如下：  
    低--------------------------------------------->高  
    byte,short,char-> int -> long -> float -> double
 *  运算中，不同类型的数据先转化为同一类型，然后进行运算，转换规则如下：

<table> 
 <thead> 
 <tr> 
 <th>操作数1类型</th> 
 <th>操作数2类型</th> 
 <th>转换后的类型</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td>byte、short、char</td> 
 <td>int</td> 
 <td>int</td> 
 </tr> 
 <tr> 
 <td>byte、short、char、int</td> 
 <td>long</td> 
 <td>long</td> 
 </tr> 
 <tr> 
 <td>byte、short、char、int 、long</td> 
 <td>float</td> 
 <td>float</td> 
 </tr> 
 <tr> 
 <td>byte、short、char、int 、long、float</td> 
 <td>double</td> 
 <td>double</td> 
 </tr> 
 </tbody> 
</table>

### 强制数据类型转换 ###

强制转换的格式是在需要转型的数据前加上“( )”，然后在括号内加入需要转化的数据类型。有的数据经过转型运算后，精度会丢失，而有的会更加精确，下面的例子可以说明这个问题。

public static void main(String[] args) { 
    	int x;
    	double y;
    	x = (int) 34.56 + (int) 11.2; // 丢失精度
    	y = (double) x + (double) 10 + 1; // 提高精度
    	System.out.println("x=" + x);
    	System.out.println("y=" + y);
    }

[Primitive Data Types]: https://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
[Link 1]: https://www.cnblogs.com/zhengfengyun/p/5091282.html