Java中常见数据类型转换

最新推荐文章于 2022-04-05 04:00:00 发布

踏着七彩祥云的小丑

最新推荐文章于 2022-04-05 04:00:00 发布

阅读量306

点赞数

分类专栏： Java 文章标签： java 数据类型

本文链接：https://blog.csdn.net/weixin_43839323/article/details/110819054

版权

Java 专栏收录该内容

42 篇文章 0 订阅

订阅专栏

数据类型转换

什么是数据类型

简单来说就是数据的类型；数据类型限定了分配的内存空间大小。

程序中定义的变量就是申请内存来存储值的，创建变量的时候，需要在内存中申请空间，内存管理系统根据变量的类型为变量分配存储空间，分配的空间只能用来存储该类型的数据。

数据类型的作用

数据类型来声明变量，程序在运行过程中，根据不同的数据类型分配不同大小的空间。

数据类型分类

基本数据类型

变量名指向具体的数值。声明之后Java就会立即分配给他内存空间。使用时需要赋具体的值，判断时使用“==”。

在这里插入图片描述
注意：

整数的默认类型是：int；浮点数的默认类型是double。

引用数据类型

变量名指向存数据对象的内存地址，即变量名指向hash值。以特殊的方式（类似指针）指向对象实体，声明时不会立马分配内存，只是存储了一个内存地址。使用时可以赋null，判断时使用equals方法。

常见的引用类型

String。
🔍类。
🔍接口。
🔍数组。
🔍枚举。
标注。

更多引用数据类型相关内容可以看另一篇文章：
https://blog.csdn.net/weixin_43839323/article/details/110819733

数据类型转换

直接量

整数型的直接量默认是int类型。
浮点型的直接量默认是double类型。

基本类型转换

注意

除Boolean类型不能转换，其余七种类型之间可以相互转换。
如果整数型字面量没有超出byte , short,char的取值范围，可以直接将其赋值给byte , short, char类型的变量。
byte , short,char类型混合运算时，先各自转换成int类型再做运算。
多种数据类型混合运算，各自先转换成容量最大的那一种再做运算。
转换过程中可能会导致溢出或损失精度。

自动类型转换（小容量到大容量）

小容量向大容量转换称为自动类型转换，容量从小到大的排序为:

（byte，short ，char）< int< long < float < double, 其中short和 char都占用两个字节，但是char可以表示更大的正整数。

强制类型转换（大容量到小容量）

大容量转换成小容量，称为强制类型转换，编写时必须添加“强制类型转换符”,但运行时可能出现精度损失，谨慎使用。

实例

数据溢出：

int a = 128;
byte b = (byte)a;//byte类型最大值127，int类型转byte类型时导致溢出。

int c = 10000000;
int d = 10000000;
int i = c×d;
System.out.println(i)//输出276447232，得到的结果超出了int类型的范围，数据溢出

损失精度：

double d = 23.7;
int i = (int)d;
System.out.println(i);//输出23，浮点数到整数的转换是舍弃小数

强制类型转换（溢出、损失精度）

//强制类型转换
	public void dataTest4(){
		int i = 128;
		byte b = (byte) i;
		System.out.println(b);//输出-128,出现了数据溢出.
		
		double d = 1.23;
		int i1 = (int) d;
		System.out.println(i1);//输出1,精度丢失.
	}

定义变量的类型转换

/*
*数据类型转换
*/
public class DataTyprClass {
	
	public void dataTest(){
		long a = 200;//200是直接量，默认为int类型，这里自动转换为long类型。
		
		//这个是报错的，提示The literal 10000000000 of type int is out of range 
		//long l = 10000000000;//10000000000是直接量，默认为int类型超出了int类型的取值范围。
		
		long s = 10000000000L;//10000000000L直接量不再是默认int类型，因为加了L。
		
		//这个是报错的，提示Type mismatch: cannot convert from double to float
		//float f = 1.2;//浮点类型的默认直接量的类型是double，此时需要强转。
		
		float d = 1.2f;//该直接量的默认类型不再是double，因为加了f。
		
		//char c = -51;//直接量-51不在char类型的取值范围内，不能直接将int类型赋值给char类型。
		
		char z = 51;//chat类型是一种特殊的int类型。
		
		//baty j = 128;//直接量128，超过了byte类型的取值范围，不能直接将int类型赋值给byte类型。
		
		byte k = 100;//在byte类型的取值范围内，int类型可以直接赋值给byte类型。
		
		short l = 200;//在short类型的取值范围内，int类型可以直接赋值给short类型。
	}
}

数据运算时的转换

先转换为较大类型，在进行运算

public void dataTest2(){
		
		int i = 5;
		double d = 4;
		System.out.println(i+d);//输出9.0
		
		float f = 5.2f;
		f = f + 1.2f;
		System.out.println(f);//输出6.3999996
//		f = f + 1.2;//编译错误，计算后的结果是double类型
	}

特殊情况：byte、short、char三种类型参与运算时，先转换为int，再运算

public void dateTest(){
		
		byte a = 3;
		byte b = 4;
//		byte c = a + b;//编译错误，要先转int类型再计算，最终的结果也是int类型。
		int i = a + b;
		System.out.println(i);//输出7
	}

基本类型的包装类型转换

在这里插入图片描述

常用方法

静态方法 valueOf()

用于返回给定参数的原生number对象值，参数可以是原生数据类型、string等。
参数是基本数据类型，返回对应的包装类对象（就是谁调用valueOf()方法）。
参数是string字符串，也返回对应包装类对象。
该方法可以接收两个参数：一个是字符串，一个是基数。

常用的语法格式：

//返回一个表示指定的int值的Integer实例。
static Integer valueOf(int i)//参数是Integer对象的整数。
//返回保存指定的String的值的Integer对象。
static Integer valueOf(String s)//参数是Integer对象的字符串。
//返回一个Integer对象，该对象中保存了用第二个参数提供的基数进行解析时从指定的 String 中提取的值。
static Integer valueOf(String s, int radix)//参数一个是Integer对象的字符串，一个是在解析字符串时使用的进制数。

实例：

public static void main(String args[]){
	Byte by = Byte.valueOf("123");
	Short sh = Short.valueOf("123");
    Integer x =Integer.valueOf(123);
    Long lo = Long.valueOf(123l);
    Long lo2 = Long.valueOf("123");
    Double c = Double.valueOf(123);
    Float a = Float.valueOf("123");  
    Integer b = Integer.valueOf("123",16);   // 使用 16 进制
    System.out.println("by："+by);//输出123
    System.out.println("sh："+sh);//输出123
    System.out.println("x："+x);//输出123
    System.out.println("lo："+lo);//输出123
    System.out.println("lo2："+lo2);//输出123
    System.out.println("c："+c);//输出123.0
    System.out.println("a："+a);//输出123.0
    System.out.println("b："+b);//输出291
}

静态方法parseXXX(String str)

Character类没有该方法；
常用的是将字符串通过Integer包装类转换为int类型。

实例：

public static void main(String[] args) {
	
	String str = "123";
	System.out.println(Byte.parseByte(str));//输出123
	System.out.println(Short.parseShort(str));//输出123
	System.out.println(Integer.parseInt(str));//输出123
	System.out.println(Long.parseLong(str));//输出123
	System.out.println(Float.parseFloat(str));//输出123.0
	System.out.println(Double.parseDouble(str));//输出123.0
	
}

非静态方法XXXValue()

是非静态的方法，不能通过类名直接调用。
数字类的包装类才有该方法。（Byte、short、int、long、float、double）
将包装类对象转换位对应的基本数据类型。

实例：

public void testInteger(){
		Integer it = 123;//Byte、short、int、long、float、double都可以
		byte bv = it.byteValue();
		short sv = it.shortValue();
		int iv = it.intValue();
		long lv = it.longValue();
		float fv = it.floatValue();
		double dv = it.doubleValue();
		System.out.println("I:byte："+bv);//输出123
		System.out.println("I:short："+sv);//输出123
		System.out.println("I:int："+iv);//输出123
		System.out.println("I:long："+lv);//输出123
		System.out.println("I:float："+fv);//输出123.0
		System.out.println("I:double："+dv);//输出123.0
	}

自动拆箱与装箱

jdk1.5后的新特性。
在编译器中自动将基本数据类型和包装类型相互转换。

自动装箱基本数据类型→包装类（原理：调用了valueOf()方法）
自动拆箱包装类→基本数据类型（原理：调用了xxxValue()方法）

//自动装箱和自动拆箱
public void testB(){
	//自动装箱
	Byte b = 100;//等价于Byte.valueOf((byte) 100);
	Short s = 100;//等价于Short.valueOf((Short) 100);
	Integer i = 100;//等价于Integer.valueOf(100);
	Long l = 100l;//等价于Long.valueOf(100);
	Float f = 100.0f;//等价于Float.valueOf(100f);
	Double d = 100.0;//等价于Double.valueOf(100.0);
	
	//自动拆箱
	byte b1 = b;//等价于b.byteValue();
	short s1 = s;//等价于s.shortValue();
	int i1 = i;//等价于i.intValue();
	long l1 = l;//等价于l.longValue();
	float f1 = f;//等价于f.floatValue();
	double d1 = d;//等价于d.doubleValue();
}

Integer的valueOf()方法源码：

public static Integer valueOf(int i) {
    assert IntegerCache.high >= 127;
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

intValue()方法源码：

public int intValue() {
    return value;
}

注意：

Integer派别：Integer、Short、Byte、Character、Long这几个类的valueOf方法的实现是类似的。规定范围内的对象都相同，规定范围外的对象都不相同。

Double派别：Double、Float的valueOf方法的实现是类似的。每次都返回不同的对象。

"=="比较：

两边都是包装类型比较的是对象。
一边是包装类型一边是运算式比较的是值。

equals比较：

类型相同：内容相同true，内容不同false。
类型不同：false

public static void main(String[] args) {
	
	int in1 = 100;
	int in2 = 100;
	int in3 = 200;
	int in4 = 200;
	System.out.println(in1==in2); //true
	System.out.println(in3==in4); //true
	
    Integer i1 = 100;
    Integer i2 = 100;
    Integer i3 = 200;
    Integer i4 = 200;
    System.out.println(i1==i2); //true
    System.out.println(i3==i4); //false，比较的是对象，超过了范围，就是不同的对象。
    System.out.println(i3==(i1+i2)); //true，比较的是值是否相等。应为==号两边出现运算。
	
	int int1 = 100;
	Integer int2 = 100;
	int int3 = 200;
	Integer int4 = 200;
	//== 先拆箱在进行比较
	System.out.println(int1==int2); //true
	System.out.println(int3==int4); //true
	//equals先装箱再比较
	System.out.println(int1.equals(int2));  //true
	System.out.println(int3.equals(int4));  //true，类型相同，内容相同。默认先装箱再比较
	
	Long l1 = 200;
	long l2 = 100;
	long l3 = 100;
	System.out.println(l1==(l2+l3));//true，类型相同，比较的是值是否相等。应为==号两边出现运算。
	System.out.println(l1==(i1+i2));//false，类型不同
	
    
    //浮点型每个都是不同对象
	Double d1 = 100.0;
    Double d2 = 100.0;
    Double d3 = 200.0;
    Double d4 = 200.0;
    System.out.println(d1==d2); //false
    System.out.println(d3==d4); //false
	
	Boolean b1 = false;
    Boolean b2 = false;
    Boolean b3 = true;
    Boolean b4 = true;

    System.out.println(b1==b2);//true
    System.out.println(b3==b4);//true
}

Boolean类型的valueOf()方法的源码：

public static Boolean valueOf(boolean b) {
    return (b ? TRUE : FALSE);
}

/**
* The {@code Boolean} object corresponding to the primitive
* value {@code true}.
*/
public static final Boolean TRUE = new Boolean(true);

/**
* The {@code Boolean} object corresponding to the primitive
* value {@code false}.
*/
public static final Boolean FALSE = new Boolean(false);