Java的数据类型（复习版）

思维导图

在这里插入图片描述

一.字面常量

什么是常量？在我的理解看来常量就是在一个程序运行期间，保持不变的量就是常量。
例如：

		System.out.println(100);
        System.out.println('a');
        System.out.println(3.114);

这些都可以称为常量。

字面常量的分类：

字符串常量：由""括起来的，比如“12345”、“hello”、“你好”。
整形常量：程序中直接写的数字(注意没有小数点)，比如：100、1000
浮点数常量：程序中直接写的小数，比如：3.14、0.49
字符常量：由单引号括起来的当个字符，比如：‘A’、‘1’
布尔常量：只有两种true和false
空常量：null

二.数据类型

数据类型分为基本数据类型和引用数据类型

我们这里先介绍基本数据类型和变量的定义：

变量定义：数据类型变量名=变量值

整型：int

   int a=10;//在定义整型变量时最好给一个初始值，不然编译器会报错

字节类型：byte

byte a=127;//127是byte类型可以存储的最大值

短整型：short

short a=10;

长整型：long

long a=100L;// // 为了区分int和long类型，一般建议：long类型变量的初始值之后加L或者l

字符型：char

char a='帅';//java中的字符可以存放整形
char b='a';
//注意事项:
1. Java 中使用 单引号 + 单个字母 的形式表示字符字面值.
2. 计算机中的字符本质上是一个整数. 在 C 语言中使用 ASCII 表示字符, 而 Java 中使用 Unicode 表示字符. 因此
一个字符占用两个字节, 表示的字符种类更多, 包括中文.

单精度浮点数：float

float a=10.1f;//小数默认都是double类型，所以在后面加f可以区分。

双精度浮点数：double

double a=10.14;

布尔类型：boolean

boolean a=true;
boolean b=false;

数据类型的最值

这里我们简单介绍了八种基本数据类型。接下来我们看一下每一个基本数据类型所占的内存和他的最值。如何在代码中求的基本数据类型的最大值，这里先简单介绍下包装类。

Java的包装类是为了方便操作基本数据类型而提供的类。Java的基本数据类型（如int、char、boolean等）是非对象的，不能直接参与面向对象的操作，也不能直接调用方法。为了解决这个问题，Java提供了对应的包装类。

基本数据类型对应的包装类：Java为每种基本数据类型都定义了一个对应的包装类，用于将基本数据类型转换为对象。这些包装类提供了一些常见的方法，以便于操作基本数据类型的值。

Integer：对应int类型

Long：对应long类型

Short：对应short类型

Byte：对应byte类型

Float：对应float类型

Double：对应double类型

Character：对应char类型

Boolean：对应boolean类型

这里只有int和char的包装类尤为特殊，其他类型都是首字母大写即可。

如何用包装类求每一个数据类型的最大值和最小值呢？

 //int 类型的变量
 		int b;
        b=10;
        System.out.println(b);

        //如何查看int类型的最大值和最小值(借用包装类就可以查看int数据类型的最大值和最小值)
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
        //byte 类型
        byte c=100;
        //如何查看byte类型的最大值和最小值(借用包装类就可以查看byte数据类型的最大值和最小值)
        System.out.println(Byte.MAX_VALUE);
        System.out.println(Byte.MIN_VALUE);

        //short类型
        short d=100;
        //如何查看short类型的最大值和最小值(借用包装类就可以查看short数据类型的最大值和最小值)
        System.out.println(Short.MAX_VALUE);
        System.out.println(Short.MIN_VALUE);

        //long 类型
        long e=1000L;//long 后面最好要加上"L"，和int区别开来，当然也可以使用"l"，但是"l"和1类似，所以用"L"
        //如何查看long类型的最大值和最小值(借用包装类就可以查看long数据类型的最大值和最小值)
        System.out.println(Long.MAX_VALUE);
        System.out.println(Long.MIN_VALUE);

        //float类型
        float f=10.4f;//为了强调是单精度浮点数需要在后面加上f
        //如何查看float类型的最大值和最小值(借用包装类就可以查看float数据类型的最大值和最小值)
        System.out.println(Float.MAX_VALUE);
        System.out.println(Float.MIN_VALUE);

        //double 类型
        double g=100.36;//小数默认都是double类型
        //如何查看double类型的最大值和最小值(借用包装类就可以查看double数据类型的最大值和最小值)
        System.out.println(Double.MAX_VALUE);
        System.out.println(Double.MIN_VALUE);

        //char类型
        char h='A';
        char i='刷';//注意：Java中可以用字符存放一个中文汉字

        //boolean 类型
        //只表示真假
        boolean j=true;
        boolean k=false;

当然，我们也可以自己计算每种数据类型的最值问题

但是我们还要了解什么是字节？

字节是计算机中表示空间大小的基本单位.
计算机使用二进制表示数据. 我们认为 8 个二进制位(bit) 为一个字节(Byte).
我们平时的计算机为 8GB 内存, 意思是 8G 个字节.
其中 1KB = 1024 Byte, 1MB = 1024 KB, 1GB = 1024 MB.
所以 8GB 相当于 80 多亿个字节

在这里插入图片描述

注意：
不论是在16位系统还是32位系统，int都占用4个字节，long都占8个字节
整形和浮点型都是带有符号的
整型默认为int型，浮点型默认为double

小插曲

int a = 1;
int b = 2;
System.out.println(a / b); // 输出 0.5 吗？

结果肯定不会输出为0.5，因为int是整型他只会取到整数位0，所以他的结果为0.
那我们该如何输出0.5呢？

double a = 1.0;
double b = 2.0;
System.out.println(a / b); // 输出0.5

or

int a = 1;
int b = 2;
System.out.println(a *1.0/ b);

三.类型转换

在Java中，当参与运算数据类型不一致时，就会进行类型转换。Java中类型转换主要分为两类：自动类型转换(隐式) 和强制类型转换(显式)。

自动类型转换(隐式)
自动类型转换即：代码不需要经过任何处理，在代码编译时，编译器会自动进行处理。特点：数据范围小的转为数据范围大的时会自动进行。

   		long a=100L;
        int b=5;
        a=b;//因为long占8字节，int占4字节，a和b都是整形，a的范围小，b的范围大，当将a赋值给b时，编译器会自动将a提升为long类型，然后赋值

 		long c=100L;
        int d=55;
        c=d;//int--->long进行赋值,将int类型提升为long类型

 	    float e=10.5f;
        double f=100.6;
        f=e;//float--->double 隐式转换 小的给大的不需要强转

强制类型转换(显式)

		long a=100L;
        int b=5;
        b=(int)a;//因为long占8字节，int占4字节，编译报错，long的范围比int范围大，所以需要将a（long类型）强行转换为int类型，但是可能会有数据丢失，不安全

		float f = 3.14F;
		double d = 5.12;
		d = f; // float-->double，数据范围由小到大，隐式转换
		f = (float)d; // double-->float, 数据范围由大到小，需要强转，否则编译失败
		a = d; // 报错，类型不兼容
		a = (int)d; // int没有double表示的数据范围大，需要强转，小数点之后全部丢弃



		byte b1 = 100; // 100默认为int，没有超过byte范围，隐式转换
		byte b2 = (byte)257; // 257默认为int，超过byte范围，需要显示转换，否则报错

这里byte需要重点看一下

四.类型提升

不同类型的数据之间相互运算时，数据类型小的会被提升到数据类型大的。

 //类型的提升

        //int类型会提升为long类型

        int a=100;
        long b=1000L;
        //int c=a+b;// 编译出错: a + b==》int + long--> long + long 赋值给int时会丢失数据
        //解决方法如下
        //1.
        int c=(int)(a+b);
        //2.
        long d=a+b;

 	    byte f=10;
        byte e=20;

        byte l=(byte)(f+e);
        //因为虽然都是相同的byte类型进行相加，但是无论是short或者是byte，两种相同的数据类型在相加的时候会提升为int类型，所以需要将右侧的数据进行强制转换

结论: byte 和 byte 都是相同类型, 但是出现编译报错. 原因是, 虽然 a 和 b 都是 byte, 但是计算 a + b 会先将 a
和 b 都提升成 int, 再进行计算, 得到的结果也是 int, 这是赋给 c, 就会出现上述错误.
由于计算机的 CPU 通常是按照 4 个字节为单位从内存中读写数据. 为了硬件上实现方便, 诸如 byte 和 short
这种低于 4 个字节的类型, 会先提升成 int, 再参与计算

【类型提升小结:】

不同类型的数据混合运算, 范围小的会提升成范围大的.
对于 short, byte 这种比 4 个字节小的类型, 会先提升成 4 个字节的 int , 再运算.

五.字符串类型

public static void main(String[] args) {
String s1 = "hello";
String s2 = " world";
System.out.println(s1);
System.out.println(s2);
System.out.println(s1+s2); // s1+s2表示：将s1和s2进行拼接
}

在有些情况下，我们需要字符串和整型之间的相互转换。

1.int转String

int num = 10;
// 方法1
String str1 = num + ""; 
// 方法2
String str2 = String.valueOf(num);

2.String转int

String str = "100";
int num = Integer.value(str);

可以看到两种类型之间的转换都是用了库方法value。