Java中基本类型转换和运算符

学习java的张三

已于 2022-02-10 12:58:22 修改

阅读量252

点赞数

分类专栏： #java学习文章标签： java 开发语言后端

于 2022-01-09 21:02:21 首次发布

本文链接：https://blog.csdn.net/qq_46235384/article/details/122398932

版权

#java学习专栏收录该内容

15 篇文章 0 订阅

订阅专栏

数据类型转换

小类型->大类型

小类型会自动提升成大类型

只有当a为int类型，b为long类型的时候，a+b才会先将int类型提升为long类型

public class Test {
    public static void main(String[] args) {
        //输出-2147483648
        int a = 1;
        int b = Integer.MAX_VALUE;
        long c = a + b;
        System.out.println(c);
        //输出2147483648
        int d = 1;
        long e = Integer.MAX_VALUE;
        long f = d + e;
        System.out.println(f);
    }
}

public class Test {
    public static void main(String[] args){
        int a = 10;
        double b = 1.0;
        char c = 'a';
        //输出108.0
        System.out.println(a + b + c);//a+b+c的类型是double
    }
}

当不同的数据类型进行算数运算/赋值时，小类型自动转换为大类型进行运算。

char->int ：根据Unicode编码（16进制编码）转换成整型。

大类型->小类型

需要强制类型转换

double a = 2.5;
int b = (int)a;

byte/char在存储时都会转换为int存储，因为byte/char是小于四字节的数据类型

byte存储范围：-128-127

可能会丢失精度，溢出

public class Test {
    public static void main(String[] args){
        int a = Integer.MAX_VALUE;
        long b = 1L;
        long c = a + b;
        int d = (int)c;
        //输出-2147483648
        System.out.println(d);
    }
}

int类型和byte类型转换

1. 若值在byte的保存范围内，可以直接赋值，否则编译出错

byte a = 100; // 编译通过
byte b = 200; // 编译报错, 提示 从int转换到byte可能会有损失

2.当进行byte变量之间运算时，JVM会将byte转换为int

  byte a = 10;
  byte b = 20;
  byte c = a + b;//编译出错
  byte d = (byte)(a+b);//需要进行强制类型转换

int类型和String类型转换

Web开发中，默认从输入框拿到的数据为String类型

String->int

public class Test {
    public static void main(String[] args){
        String str = "12345";
        int num = Integer.parseInt(str);
//输出12345
        System.out.println(num);
    }
}

报错：非纯数字组成的字符串转化为int

int->String

public class Test {
    public static void main(String[] args){
        int a = 10;
        //方法1，输出10
        String str1 = a + "";
        System.out.println(str1);
        //方法2，输出101
        String str2 = String.valueOf(a);
        System.out.println(str2+1);
    }
}

运算符

算数运算符

基本四则运算符 + - * / %

在进行/运算时，0不能作为除数

增量赋值运算符 += -= *= /= %=

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

public class Test {
    public static void main(String[] args){
        int a = 10;
        //输出10
        System.out.println(a++);//a++是先对a取值，然后赋值
        //输出12
        //此时a的值已经变成11，然后进行++a操作
        System.out.println(++a);//++a是先赋值，然后对a取值
        int b= 10;
        //输出11
        System.out.println(++b);
    }
}

关系运算符== != < > <= >=

关系运算符的表达式返回值都是 boolean 类型

public class Test {
    public static void main(String[] args){
        int a = 10;
        int b = 20;
        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
    }
}

逻辑运算符 && || !

逻辑运算符的操作数(操作数往往是关系运算符的结果)和返回值都是 boolean

逻辑与 &&

规则: 两个操作数都为 true, 结果为 true, 否则结果为 false
int a = 10;
int b = 20;
int c = 30;
//true
System.out.println(a < b && b < c);

逻辑或 ||

//规则: 两个操作数都为 false, 结果为 false, 否则结果为 true
int a = 10;
int b = 20;
int c = 30;
//true
System.out.println(a < b || b < c);

逻辑非 !

//规则: 操作数为 true, 结果为 false; 操作数为 false, 结果为 true(这是个单目运算符, 只有一个操作数)
int a = 10;
int b = 20;
//false
System.out.println(!(a < b));

短路求值

//&& 和 || 遵守短路求值的规则
System.out.println(10 > 20 && 10 / 0 == 0); // 打印 false
System.out.println(10 < 20 || 10 / 0 == 0); // 打印 true

计算 10 / 0 会导致程序抛出异常，但是上面的代码却能正常运行，说明 10 / 0 并没有真正被求值

1. 对于 && ，如果左侧表达式值为 false, 则表达式的整体的值一定是 false, 无需计算右侧表达式 .

2. 对于 ||，如果左侧表达式值为 true, 则表达式的整体的值一定是 true, 无需计算右侧表达式

& 和 | (不推荐）

和 && 以及 || 相比，& 和 | 不支持短路求值

System.out.println(10 > 20 & 10 / 0 == 0); // 程序抛出异常
System.out.println(10 < 20 | 10 / 0 == 0); // 程序抛出异常

位运算符 & | ~ ^

Java 中对数据的操作的最小单位不是字节，而是二进制位

位操作表示 按二进制位运算 ，计算机中都是使用二进制来表示数据的 (01 构成的序列 )，按位运算就是在按照二进制位的

按位与 &

// 如果两个二进制位都是 1, 则结果为 1, 否则结果为 0.
        int a = 10;
        int b = 20;
        //0
        System.out.println(a & b);

进行按位运算 , 需要先把 10 和 20 转成二进制 , 分别为 1010 和 10100

按位或 |

 // 如果两个二进制位都是 0, 则结果为 0, 否则结果为 1.
        int a = 10;
        int b = 20;
        //30
        System.out.println(a | b);

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

按位取反 ~

// 按位取反 ~: 如果该位为 0 则转为 1, 如果该位为 1 则转为 0
        int a = 0xf;
        //fffffff0
        System.out.printf("%x\n", ~a);

按位异或 ^

// 如果两个数字的二进制位相同, 则结果为 0, 相异则结果为 1.
        int a = 0x1;
        int b = 0x2;
        //3
        System.out.printf("%x\n", a ^ b);

移位运算<< >> >>>

注意

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

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

左移 <<

// 左移 <<: 最左侧位不要了, 最右侧补 0.
        int a = 0x10;
        // 运行结果(十六进制)20
        System.out.printf("%x\n", a << 1);

右移 >>

 // 最右侧位不要了, 最左侧补符号位(正数补0, 负数补1)
int a = 0x10;
        // 运行结果(十六进制) 8
        System.out.printf("%x\n", a >> 1);
        int b = 0xffff0000;
        // 运行结果(十六进制) ffff8000
        System.out.printf("%x\n", b >> 1);

无符号右移 >>>

//最右侧位不要了, 最左侧补 0.
        int a = 0xffffffff;
        // 运行结果(十六进制)7fffffff
        System.out.printf("%x\n", a >>> 1);

条件运算符（三目运算符）

表达式1 ? 表达式2 : 表达式3

// 求两个整数的最大值
        int a = 10;
        int b = 20;
        int max = a > b ? a : b;
        //20
        System.out.println(max);

运算符的优先级

同一优先级的运算符，运算次序由结合方向所决定
！ > 算术运算符 > 关系运算符 > && > || > 赋值运算符

关键字

1.定义访问权限修饰符的关键字：private protected public

2.定义类、函数、变量修饰符的关键字：abstract final static synchroized

3.定义类与类之间关系的关键字：extends implements

4.定义建立实例及引用实例、判断实例的关键字：new this super instanceof

5.用于异常处理的关键字：try catch finally throw throws

6.用于包的关键字：package import

学习java的张三

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java中基本类型转换和运算符

目录数据类型转换小类型->大类型大类型->小类型int类型和byte类型转换int类型和String类型转换String->intint->String运算符算数运算符关系运算符== != < > <= >=逻辑运算符&& || !位运算符& | ~ ^移位运算<< >> >>>条件运算符（三目运算符）...
复制链接

扫一扫