JavaSE学习--数据类型和运算符

 💕"哪里有人喜欢孤独，只不过更不喜欢失望。"💕

作者：Mylvzi 

 文章主要内容：JJavaSE学习--数据类型和运算符 

Java程序是如何运行的？

一.数据类型

整型：

注意事项：

1.整型变量在赋值的过程中要注意数据类型的取值范围，如果越界会报错；注意Java中没有Long long类型

2.整型变量都有包装类型，除了int的包装类型为Integer外，其余都是首字母大写；包装类型就是他们的plus版本，里面有方法和属性； 

3.整数会被默认为int类型，所以在使用long进行赋值时要在数字末尾添加大写L 

4. int在所有系统下都是4个字节，long在所有系统下都是8个字节

5.int,long都是有符号的

浮点型 

注意事项;

1.小数会被默认为double类型，而Java是一种强类型语言，使用float进行赋值时一定要在数字末尾添加f

 

2.浮点型数据也有包装类型，为首字母大写

3.由于其存储规则，浮点数都是不精确的，只有前XXXX位是精确的 

字符型：

1.char类型占两个字节，比C语言中的范围更大；一个汉字占两个字节，所以java中char类型可以存储一个汉字；Java使用的是Unicode编码，相当于是ASCII码的plus版本；

2.包装类型：Character 

布尔类型：

1.关键字--》boolean;只有两个值true,false;包装类型为Boolean；java中只有true和false才表示真假，在C语言中0可以表示假，但在Java中不表示 

注意：

1.不是所有的数据类型都能进行强制类型转换，布尔类型无法强制类型转换；

2.Java是一种强类型语言，有严格的语法规范； 一定要注意明确数据类型；

类型转换：

隐式类型转换-->小转大-->自动转换

显式类型转换-->大转小 -->必须人为添加强转类型

1.隐式类型转换

        // 1.自动转换（隐式类型转换）
        // 小范围-->大范围  不存在数据丢失，所以编译器会自动转换
        int a = 1024;// 注意整数默认都是Int  浮点型默认都是double类型
        long b = 10L;
 
        float c = 3.1f;
        double d = 4.0;
 
        b = a;// 编译通过
        a = b;// err 大范围--》小范围，会有数据丢失

2. 显式类型转换

        // 2.强制转换（显式类型转换）
        int a = 1024;
        long b  = 10L;
        
        float c = 3.14F;
        double d = 4.0;
        
        a = (int)b;// long > int  所以要进行强制类型转换
        c = (float) d;// double > float  所以要进行强制类型转换

3.检查范围 

        // 3.检查范围
        // byte -128~127
        byte a = 127;// right
        byte b = 128;// err 

 4.不相干的类型无法进行转换

        // 4.不相干的类型无法进行转换
        boolean a = true;
        int b = 10;
        b = (int)a;// err

总结：

1.小范围向大范围转移时，编译器会自动进行类型转换

2.大范围向小范围转移时，编译器不会自动进行类型转换，需要进行强制类型转换，但可能存在精度的丢失

3.在进行赋值时，编译器会检查数字是否超过对应类型的范围

4.不相干的类型无法进行强制类型转换（主要指布尔类型无法和其他类型进行强制类型转换）

类型提升

 1.int类型会被自动提升到long类型

        int a = 10;
        long b = 20L;
        
        int c = a+b;// err a+b-->int+long-->long+long 而c时int类型，大范围向小范围转移会报错
        long d = a+b;// right 被提升后是Long类型

当int类型的数据和Long类型的数据进行运算时，int类型的数据会被自动提升到long类型（范围扩大）

2.byte,short类型的数据会被提升到int类型

        byte a = 10;
        byte b = 20;
        
        byte c = a+b;// err  a+b-->byte+byte-->int+int 而c时byte类型，大范围向小范围转移会报错
        byte d = (byte)(a+b);// 进行强制类型转换即可
        
        short a2 = 10;
        short b2 = 20;
        short c2 = a2+b2;// err理由同上
        short d2 = (short) (a2+b2);

由于cpu在读取数据时一次读取4个字节，所以对于大小小于4个字节的数据（byte和short）来说，在进行运算时会被自动提升到int类型 

字符串类型：

1.基本概念

  在Java中字符串类型是一种引用数据类型，通过关键字String标识（注意S大写）

        String s1 = "hello";
        String s2 = "world";
        System.out.println(s1+" "+s2);// +代表将两边的内容拼接起来

 

2.int与String的转换

1.int-->String

        int a = 10;
        // 方法1
        String str1 = a+" ";
 
        // 方法2-->利用了String类的方法
        String str2 = String.valueOf(a);
        System.out.println(str2);

2.String-->int

        String str1 = "100";
        int a  = Integer.parseInt(str1);// 利用Integer类的方法
        System.out.println(a);

 

本文章只是对字符串进行简单的介绍，大家能够正常使用即可，后序会详细给大家介绍。 

二.运算符

1.算术运算符

1. 基本四则运算符：加减乘除模(+ - * / %)

int a = 20;
int b = 10;
System.out.println(a + b); // 30
System.out.println(a - b); // 10
System.out.println(a * b); // 200
System.out.println(a / b); // 2
System.out.println(a % b); // 0 --->模运算相当于数学中除法的余数

注意事项：

1./运算符右操作数不能是0

 2.两侧操作数类型不同，向类型大的提升

System.out.println(1+0.2); // +的左侧是int，右侧是double，在加之前int被提升为double
// 故：输出1.2

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

int a = 1;
a += 2; // 相当于 a = a + 2
System.out.println(a); // 输出3
a -= 1; // 相当于 a = a - 1
System.out.println(a); // 输出2
a *= 3; // 相当于 a = a * 3
System.out.println(a); // 输出6

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

int a = 1;
a++; // 后置++ 表示给a的值加1，此时a的值为2
System.out.println(a++); // 注意：后置++是先使用变量原来值，表示式结束时给变量+1，因此输出2
System.out.println(a); // 输出3
++a; // 前置++ 表示给a的值加1
System.out.println(++a); // 注意：前置++是先给变量+1，然后使用变量中的值，因此输出5
System.out.println(a); // 输出5
// --操作符给操作-1，与++含义类似

注意a++和++a的区别

2. 关系运算符 

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

int a = 10;
int b = 20;
// 注意：在Java中 = 表示赋值，要与数学中的含义区分
// 在Java中 == 表示相等
System.out.println(a == b); // false
System.out.println(a != b); // true
System.out.println(a < b); // true
System.out.println(a > b); // false
System.out.println(a <= b); // true
System.out.println(a >= b); // false

注意：需要多次判断时不能连着写：3

3. 逻辑运算符(重点) 

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

1.&&逻辑与    一假俱假

&&左右两边必须是boolean类型的结果

一假俱假：只要有一个式子的结果是false，则整个判断结果为false

int a = 1;
int b = 2;
System.out.println(a == 1 && b == 2); // 左为真 且 右为真 则结果为真
System.out.println(a == 1 && b > 100); // 左为真 但 右为假 则结果为假
System.out.println(a > 100 && b == 2); // 左为假 但 右为真 则结果为假
System.out.println(a > 100 && b > 100); // 左为假 且 右为假 则结果为假

2. 逻辑 ||     一真俱真

|| 左右两边必须是boolean类型的结果

一真俱真：只要有一个式子的结果是true，则整个判断结果为true

int a = 1;
int b = 2;
System.out.println(a == 1 || b == 2); // 左为真 且 右为真 则结果为真
System.out.println(a == 1 || b > 100); // 左为真 但 右为假 则结果也为真
System.out.println(a > 100 || b == 2); // 左为假 但 右为真 则结果也为真
System.out.println(a > 100 || b > 100); // 左为假 且 右为假 则结果为假

3. 逻辑非 !

运算关键字：!

真变假  假变真

int a = 1;
System.out.println(!(a == 1)); // a == 1 为true，取个非就是false
System.out.println(!(a != 1)); // a != 1 为false，取个非就是true

4.短路求值

 && 和 || 遵守短路求值的规则

• 对于 && , 如果左侧表达式值为 false, 则表达式结果一定是 false, 无需计算右侧表达式.
• 对于 ||, 如果左侧表达式值为 true, 则表达式结果一定是 true, 无需计算右侧表达式

        System.out.println(10>20 && 10/0==0);// 输出false
        System.out.println(10<20 || 10/0==0);// 输出true

对于这段代码，后段部分10/0按理说会报错，但是代码却能通过编译，并产生结果，说明后段部分并没有被执行，发生了短路求值！

 4. 位运算符

  Java中数组存储的最小单位是字节，而操作的最小单位是位（bit）;

位运算符就是“按二进制位运算”，对二进制位进行调整运算

1. 按位与 &:

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

        System.out.println(1 & 2);// 输出0
        // 1：0001
        // 2：0010
        // &: 0000

2. 按位或 |:

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

        System.out.println(1 | 2);// 输出3
        // 1：0001
        // 2：0010
        // |：0011

3. 按位取反 ~:

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

        int a = 0xf;
        System.out.printf("%x\n", ~a);// 输出fffffff0
        // %x代表以16进制输出
        // f对应10进制中的15

4. 按位异或 ^:

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

        int a = 0x1;
        int b = 0x2;
        System.out.printf("%x\n", a ^ b);// 输出3

注意：如果两个相同的数字^,则输出0

5. 移位运算

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

1. 左移 <<: 最左侧位不要了, 最右侧补 0.

        int a = 1;
        System.out.println(a<<1);// 输出2
        // 1：0001
        // 0010

2. 右移 >>: 最右侧位不要了, 最左侧补符号位(正数补0, 负数补1) 

        int a = 1;
        System.out.println(a>>1);// 输出0

3. 无符号右移 >>>: 最右侧位不要了, 最左侧补 0 

      int a = 0xffffffff;
        System.out.printf("%x\n", a >>> 1);
        // 1111 1111 1111 1111 1111 1111 1111 1111
        // 0111 1111 1111 1111 1111 1111 1111 1111
        // 7    f    f    f    f    f    f    f

注意没有无符号左移！！！

应用：

 <<1位相当于*2，>>1位相当于/2,所以可以用位运算符来进行数学运算（速度更快） 

<< n 位相当于*2^n，>> n 位相当于/2^n

        System.out.println(10<<1);// 输出20
        System.out.println(10>>1);// 输出5
        System.out.println(10<<2);// 输出40
        System.out.println(10>>2);// 输出2

6. 条件运算符 

条件运算符只有一个: 表达式1 ? 表达式2 : 表达式3

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

类似于C语言中的三目运算符，可以起到简化代码的效果（主要是可以简化简单的if-else语句）

        // 求两个整数的最大值
        int a = 10;
        int b = 20;
        // 三目运算符的结果必须被接收，否则会报错！！！
        int max = a > b ? a : b;
        System.out.println(max);// 输出20