Java——数据类型与运算符

Phriya

于 2024-04-13 14:20:00 发布

阅读量1.2k

点赞数 21

分类专栏： Java SE 文章标签： java 开发语言

本文链接：https://blog.csdn.net/m0_64005051/article/details/137710442

版权

Java SE 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

在Java中，程序由三个部分组成：

源文件（扩展名为*.java）：源文件带有类的定义。类用来表示一个程序的组建，小程序或许只有一个类。类的内容必须包含在{ }中。
类：类中带有一个或多个方法，方法必须在类的内部声明
方法：在方法的{ }中编写方法应该执行的语句

总之。类存在于源文件中，方法存在于类中，语句存在于方法中。

下面详细介绍Java中的数据类型与运算符

一、数据类型

Java中数据类型分为基本数据类型和引用数据类型。

基本数据类型

基本数据类型分为四类，分别为：整型、浮点型、字符型和布尔型。

这四类又分为八种：

数据类型	关键字	内存占用	范围
字节型	byte	1字节	- 128 ~ 127
短整型	short	2字节	- 32768 ~ 32767
整型	int	4字节	- 2^31 ~ 2^31 - 1
长整型	long	8字节	- 2^63 ~ 2^63 - 1
单精度浮点数	float	4字节	有范围，一般不关注
双精度浮点数	double	8字节	有范围，一般不关注
字符型	char	2字节	0 ~ 65535
布尔型	boolean	没有明确规定	true 和 false

注意：

无论是32位系统还是64位系统，int都占4个字节，long都占8个字节
整型和浮点型都是带有符号的
整型默认为int ,浮点型默认为double

变量在设置初始值前必须要赋初值，如果没有合适的初始值，可以置为0，否则编译会报错.赋值时，不能超过类型的范围，否则会导致溢出

整型变量

byte 的包装类型为 Byte

short 的包装类型为 Short

int 的包装类型为 Integer

long 的包装类型为 Long。长整型变量的值后加 l 或者 L。

浮点型变量

浮点数与整数在内存中的存储方式不同，不能单纯的使用2^n的形式来计算。double类型与float类型的内存布局遵守IEEE 754 标准。尝试使用有限的内存空间表示无限可能的小数，势必会产生一些精度误差，所以浮点数是一个近似值，并不是准确数。

float 的包装类型为 Float

double 的包装类型为 Double

字符型变量

Java中，使用‘ ’ +单个字母的形式表示字符字面值

计算机的字符本质上时一个整数，在Java 中使用Unicode表示字符。因此一个字符要占2个字节，表示的字符种类更多，包括中文

char 的包装类型为 Character

布尔型变量

布尔类型常用来表示真假

boolean 类型的变量只有两种值，true表示真，false表示假。

Java中，boolean 类型与int 类型不能互换。不存在1表示true，0表示false的用法

boolean 的包装类型为 Boolean

引用数据类型

包装类型是针对基本数据类型提出的，所以String 不是包装类型

字符串与整型数字之间的转换：

public class Test {
    public static void main(String[] args) {
       
        //字符串转为int
        String str1="123";
        int val=Integer.valueOf(str1);
        int val2=Integer.parseInt(str1);  //两种都可
        System.out.println(val);
        System.out.println(val2);

        //int转为字符串
        int p=234;
        //方法1
        String str2=String.valueOf(p);
        System.out.println(str2);
        //方法2
        String str3="p="+p;  //+为拼接
        System.out.println(str3);
    }
}

类型转换

Java 作为一个强类型编程语言, 当不同类型之间的变量相互赋值的时候, 会有教严格的校验.

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

自动类型转换（隐式）

自动类型转换：代码不需要经过任何处理，在代码编译时，编译器会自动进行处理

特点：数据范围小的转为数据范围大的时会自动进行

public class Test {
    public static void main(String[] args) {
        //自动类型转换
        int a=100;
        long b=10L;
        b=a;  //a,b都是整型，但b的范围更大。当将a赋值给b的时候，编译器会将a自动提升为long类型，然后赋值
        //a=b;  //编译会报错，long的范围比int大，会有数据丢失，不安全

        float f=3.14f;
        double d=5.21;
        d=f;  //编译器会将f转换为double型，然后赋值
        //f=d;  //double表示的数据范围大，将f给d会有数据丢失，不安全

        byte b1=100; //编译通过，100没有超过byte的范围，编译器隐式将100转换为byte
        //byte b2=257; //编译报错，257超过了byte的数据范围，会有数据丢失
    }
}

强制类型转换（显式）

强制类型转换：当进行操作时，代码需要经过一定的格式处理，不能自动完成

特点：数据范围大的转为数据范围小的

public class Test {
    public static void main(String[] args) {
       //强制类型转换
        int i=100;
        long x=10L;
        a=(int)x;  //后果：可能会丢失数据
    }
}

注意：

不同数字类型的变量之间赋值，表示范围更小的类型隐式转换为范围较大的类型
如果需要把范围较大的类型赋值给范围小的，需要强制类型转换，但是可能会导致精度丢失
将一个字面值常量进行赋值时，Java会自动针对数字范围进行检查
强制类型转换不一定能成功。不相干的类型不能相互转换

类型提升

不同类型的数据进行相互运算的时候，数据类型小的会被提升到数据类型大的

public class Test{
   public static void maint(String[] args) {
        int a=10;
        long b=10l;
        //int c=a+b;   //编译报错，int + long -->long + long ,赋值给ing会数据丢失
        long d=a+b;  //编译成功，int + long -->long + long ,赋值给long
        int c2=(int)(a+b);  //可能会丢失数据



        byte b1=10;
        byte b2=10;
        //byte bb=b1+b2; //编译报错，运算时会先将byte转换成int再进行计算
        int bb=b1+b1;
        byte bb1=(byte)(b1+b2);  //可能会丢失数据
    }
}

由于计算机的CPU通常是按照4个字节为单位从内存中读写数据，为了硬件上实现方便，诸如 byte 和 short 这种低于4个字节的类型，会先提升成int ，再参与计算。

二、运算符

Java中运算符可分为以下：算术运算符(+ - * /)、关系运算符(< > ==)、逻辑运算符、位运算符、移位运算符以及条件运算符等。

算数运算符

1. 基本四则运算符（+ - * / %）

注意：

都是二元运算符，使用时必须要有左右两个操作数
int / int 结果还是 int ，而且结果会向下取整
做除法和取模运算时，右操作数不能为0
% 不仅能对整数取模，还可以对double 类型取模，但是没有意义。一般来说都是对整数取模
两侧操作数类型不一致时，会向类型范围大的提升

2. 增量运算符（+= -= *= %=）

这种类型运算符操作完成后，会将操作的结果赋给左操作数

注意：

只有变量才能使用这种操作符，常量不能使用。

3. 自增/自减运算符（++ -- ）

++是给变量的值+1，--是给变量的值-1。

注意：

如果单独使用，前置++与后置++没有任何区别
如果混合使用，前置++先+1，然后使用变量+1后的值。后置++先使用原来变量的值，后变量再+1
-- 与 ++ 使用方法类似
只有变量才能使用++/--。常量不能使用，因为常量不允许被修改

关系运算符

关系运算符主要有六个: == != < > <= >= ，其计算结果是 true 或者 false 。

注意：

当需要多次判断时，不能连着写，比如：3 < a < 5，Java程序与数学中是有区别的

逻辑运算符

逻辑运算符主要有三个: && || ! ，运算结果都是 boolean类型。

1. 逻辑与 &&

语法规则：表达式1 && 表达式2 ，左右表达式必须是 boolean 类型的结果

表达式1	表达式2	结果
真	真	真
真	假	假
假	真	假
假	假	假

2. 逻辑或 ||

语法规则：表达式1 || 表达式2 ，左右表达式必须是 boolean 类型的结果

表达式1	表达式2	结果
真	真	真
真	假	真
假	真	真
假	假	假

3. 逻辑非！

语法规则：！表达式

表达式	结果
真	假
假	真

4. 短路求值

System.out.println(10 > 20 && 10 / 0 == 0);  //打印false
System.out.println(10 > 20 || 10 / 0 == 0);  //打印true

我们可以知道 10 / 0 会导致程序异常，但是在上述代码中却能正确运行，说明&& 和 || 遵循短路求值

短路求值的规则：

对于&&：如果左侧表达式值为false，则表达式结果一定为false，无需计算右侧表达式
对于 || ：如果左侧表达式为true,则表达式结果一定为true，无需计算右侧表达式
&和|如果表达式结果也为boolean时，也表示逻辑运算，但与&&和||相比，他们不支持短路求值

位运算符

位运算符主要有四个: & | ~ ^ ，除 ~ 是一元运算符外，其余都是二元运算符。

位操作表示按二进制位运算. 计算机中都是使用二进制来表示数据的(01构成的序列), 按位运算就是在按照二进制位的每一位依次进行计算。

1. 按位与 &

如果两个二进制位都是 1, 则结果为 1, 否则结果为 0.

2. 按位或 |

如果两个二进制位都是 0, 则结果为 0, 否则结果为 1.

注意:

当 & 和 | 的操作数为整数(int, short, long, byte) 的时候, 表示按位运算, 当操作数为 boolean 的时候, 表示逻辑运算

3. 按位取反 ~

如果该位为 0 则转为 1, 如果该位为 1 则转为 0

4. 按位异或 ^

如果两个数字的二进制位相同, 则结果为 0, 相异则结果为 1.

移位运算符

移位运算符有三个: << >> >>> ，都是二元运算符，且都是按照二进制比特位来运算的

1. 左移 <<

最左侧位不要了, 最右侧补 0

注意：

向左移位时，丢弃的是符号位，因此正数左移可能会变成负数

2.右移 >>

最右侧位不要了, 最左侧补符号位(正数补0, 负数补1)

3. 无符号右移 >>>

最右侧位不要了, 最左侧补 0

注意:

1. 左移 1 位, 相当于原数字 * 2. 左移 N 位, 相当于原数字 * 2 的N次方.

2. 右移 1 位, 相当于原数字 / 2. 右移 N 位, 相当于原数字 / 2 的N次方.

3. 由于计算机计算移位效率高于计算乘除, 当某个代码正好乘除 2 的N次方的时候可以用移位运算代替.

4. 移动负数位或者移位位数过大都没有意义.

条件运算符

表达式1 ? 表达式2 : 表达式3（java中唯一一个三目运算符）

当表达式1 的值为 true 时, 整个表达式的值为表达式2 的值;

当表达式1 的值为 false 时, 整个表达式的值为表达式3 的值.

注意：

1. 表达式2和表达式3的结果需是同类型的，除非能发生类型隐式类型转换

2. 表达式不能单独存在，其产生的结果必须要被使用

public class Test{
    public static void main(String[] args) {
        boolean flg=true==true?false?true:false:true;
        System.out.println(flg);  //false

    }
}