ICode9

精准搜索请尝试: 精确搜索
首页 > 编程语言> 文章详细

day05_Java中的运算符

2022-06-25 09:31:33  阅读:139  来源: 互联网

标签:Java ++ System day05 运算符 int println out


在Java中提供了丰富的运算符

  • 其按照功能分:算术运算符、赋值运算符、比较运算符、逻辑运算、条件运算符
  • 按照操作数个数分:一元运算符(单目运算符)、二元运算符(双目运算符)、三元运算符 (三目运算符)

我们又称用运算符连接起来的式子就是表达式。下面我们来具体学习一下每个运算符的作用吧。

算数运算符

​代码示例

/*
被除数 ÷ 除数 = 商 ......    余数
 */
public class Demo01Operator {
    public static void main(String[] args) {
        int a = 10;
        int b = 4;

        // + - * 和我们小学的规则一样
        System.out.println(a + b); //14
        System.out.println(a - b);//6
        System.out.println(a * b);//40

        //2个整数相除,结果就是商,整数相除 不保留小数,如果想要显示小数 使用浮点类型计算
        System.out.println(a / b);//2

        //int * double / int ==> double /    int ==> double / double ==> double
        System.out.println((a * 1.0) / b);// 2.5
   /*
    %运算符: 取余数(模)运算符
    作用:
        1.判断数字的奇偶性:
            数字%2 结果是0 说明数字是偶数
            数字%2 结果不是0 说明数字是奇数

        2.判断一个数字是否能够被另外一个数字整除
            结果为0: 说明可以整除
            结果不为0: 说明不可以整除
    */
        //结果是0 说明10是偶数,结果是 1 说明11是奇数
        System.out.println(10 % 2);//0 
        System.out.println(11 % 2);//1
        
        //结果是0 说明100可以被25整除,否则说明100不可以被26整除
        System.out.println(100 % 25);//0 
        System.out.println(100 % 26);//22 
    }
}

注意事项:

  • Java中,整数使用以上运算符,无论怎么计算,也不会得到小数。
  • 整数操作只能得到整数,要想得到小数,必须有浮点数参与运算。
  • / 和%的区别:两个整数做除法,/取结果的商,%取结果的余数。取模的结果只和被除数的正负号相同。

案例:键盘录入一个三位数,将其拆分为个位、十位、百位后,打印在控制台

import java.util.Scanner;

public class Demo04Operator {
    public static void main(String[] args) {
        // 1:使用Scanner键盘录入一个三位数
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个三位数");
        int num = sc.nextInt();
        // 2:个位的计算:数值 % 10
        int ge = num % 10;                        // 123 % 10 = 3
        // 3:十位的计算:数值 / 10 % 10
        int shi = num / 10 % 10;                // 123 / 10 = 12        12 % 10 = 2
        // 4:百位的计算:数值 / 100
        int bai = num / 100;                    // 123 / 100 = 1
        // 5:将个位, 十位, 百位拼接上正确的字符串, 打印即可
        System.out.println("整数:"+num+" 个位为:" + ge);
        System.out.println("整数:"+num+" 十位为:" + shi);
        System.out.println("整数:"+num+" 百位为:" + bai);

    }
}

“+”号的两种用法

  • 第一种:对于+两边都是数值的话,+就是加法的意思。char类型参与算术运算,使用的是计算机底层对应的十进制数值。
  • 第二种:对于+两边至少有一边是字符串得话,+就是拼接的意思。字符串可以使用 +号, 跟任意数据类型拼接,结果就是字符串。当连续进行“+”操作时,从左到右逐个执行。

代码示例

public class Demo02Operator {
    public static void main(String[] args) {
        
        //数学中的加法运算(数字相加,字符相加)
        System.out.println(5 + 5);// 10
        /*
            int + char ==> int + int ==> int
            需要:
                char ==> int 查看ASCII码表 'A'对应65
        */
        System.out.println(5 + 'A');// 70
        /*
            自动类型转换中:
                byte/short/char类型,只要参加运算,会自动转换为int类型
            char + char ==> int + int ==> int
            需要:
                char ==> int 查看ASCII码表 'A'对应65
                char ==> int 查看ASCII码表 'B'对应66
        */
        System.out.println('A' + 'B');// 131

        
        //字符串的拼接(把两个字符串连在一起),从左向右计算
        System.out.println("Hello" + "World"); //HelloWorld

        //先计算"5+5="+5: 此处+号代表字符串的连接 结果是"5+5=5"
        //然后"5+5=5"+5: 此处+号代表字符串的连接 结果是"5+5=55"
        System.out.println("5+5=" + 5 + 5);//5+5=55

        //()的优先级是比较高的,所以先计算5+5 结果10
        //然后"5+5="+10: 此处+号代表字符串的连接 结果是"5+5=10"
        System.out.println("5+5=" + (5 + 5));//5+5=10

    }
}

自增自减运算符

++ 运算,变量自己的值加1。反之,-- 运算,变量自己的值减少1,用法与++ 一致。只能操作变量,不能操作常量

单独使用(推荐使用)

变量在单独运算的时候,变量前++和变量后++,是没有任何区别的;

  • 变量前++ :例如 ++a
  • 变量后++ :例如 a++

代码示例

public static void main(String[] args) {
        // 定义一个int类型的变量a
        int a = 3;
        //++a;
        a++;
        // 无论是变量前++还是变量后++,结果都是4
        System.out.println(a);
    }

复合使用

和其他变量放在一起使用或者和输出语句放在一起使用,前++和后++就产生了不同。

  • 变量前++ :变量先自身加1,然后再取值。
  • 变量后++ :变量先取值,然后再自身加1。
public class Demo04Operator {
    public static void main(String[] args) {
        // 其他变量放在一起使用
        int x = 3;
        //int y = ++x;  y的值是4,x的值是4,

        // y的值是3,x的值是4
        int y = x++;

        System.out.println(x);//4
        System.out.println(y); //3


        // 和输出语句一起
        int z = 5;

        System.out.println(++z);//6
        System.out.println(z++);// 6
        System.out.println(z);//7

        int a = 1;
        //(1)先取a的值“1”放操作数栈(2)a再自增,a=2(3)再把操作数栈中的"1"赋值给a,a=1
        a = a++;
        System.out.println(a);//1

    }
}

实际开发中强烈建议不要写这样的代码

public static void main(String[] args) {
        int x = 4;
        /*
            表达式(x++)+(++x)+(x*10)是从左到右计算的
            先计算(x++): 因为++在后面,先使用x的值4,然后x的值增加,变成5
            4 + (++x)+(x*10)
            接着计算(++x): 因为++在前面,先把x的值增加1,x变成6,然后再使用6
            4 + 6+(x*10)
            接着计算x*10 -->  6*10 结果: 60
            4 + 6 + 10 结果: 70
        */
        int y = (x++) + (++x) + (x * 10);
        System.out.println(x);//6
        System.out.println(y);//70

    }

赋值运算符

  • 赋值运算符,就是将符号右边的值,赋给左边的变量。 所有的赋值运算符的左边一定是一个变量,不能是常量。

代码示例

/*
    基本赋值运算符: =
    复合赋值运算符:
        +=        a+=b        a=a+b
        -=        a-=b        a=a-b
        *=        a*=b        a=a*b
        /=        a/=b        a=a/b
        %=        a%=b        a=a%b
*/
public class Demo03Operator {
    public static void main(String[] args) {
        //基本赋值运算符
        int a = 10, b = 20;

        //复合赋值运算符:
        a += b;//a = a + b
        System.out.println(a);//30
        System.out.println(b);//20

        int c = 30, d = 20;
        c %= d;//c = c % d

        System.out.println(c);//10
        System.out.println(d);//20

        short s = 1;
        /*
            +=,-=,/=,*=,%= 运算结果的数据类型和左侧变量的数据类型不一致,隐藏强制类型转换
        */
        s += 1;//s = (short)(s + 1);
        System.out.println(s);//2

    }
}

注意事项:

  • 扩展赋值运算符在将最后的结果赋值给左边的变量前,都做了一步强制类型转换。  
  • 整数常量只要不超出所赋值的整数变量的取值范围,可以直接赋值,内部隐藏强制类型转换
  • 运算的顺序:把右边的整个表达式先算完,才会做最后的赋值操作。

例如:

        int j = 1;
        j += ++j * j++;//相当于  j = j + (++j * j++);
        System.out.println(j);//5

关系运算符

  • 关系运算符又可以叫比较运算符,是两个数据之间进行比较的运算,运算结果一定是boolean值true或者false

代码示例 

​
public class Demo05Operator {
    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); // false
        System.out.println(a >= b); // false 
        System.out.println(a < b); // true
        System.out.println(a <= b); // true 
        // 关系运算的结果肯定是boolean类型,所以也可以将运算结果赋值给boolean类型的变量
        boolean flag = a > b;
        System.out.println(flag);// 输出false
    }
}

​

注意事项:

  • 其中>,<,>=,<=不支持boolean,String类型。==和!=支持boolean和String。
  • 千万不要把“==”误写成“=”,"=="是判断是否相等的关系,"="是赋值。

逻辑运算符

逻辑运算符,是用来连接两个布尔类型结果的运算符(!除外),运算结果一定是boolean值true或者false。逻辑运算符作用: 用于整合多个比较表达式的条件

代码示例

public class Demo6Operator {
    public static void main(String[] args) {
        int a = 3;
        int b = 4;
        int c = 5;

        ////& “与”,并且的关系,只要表达式中有一个值为false,结果即为false
        System.out.println((a > b) & (a > c));  //false
        System.out.println((a > b) & (a < c));  //false
        System.out.println((a < b) & (a > c)); //false
        System.out.println((a < b) & (a < c)); //true

        // | “或”,或者的关系,只要表达式中有一个值为true,结果即为true
        System.out.println((a > b) | (a > c)); //false
        System.out.println((a > b) | (a < c)); //true
        System.out.println((a < b) | (a > c)); //true
        System.out.println((a < b) | (a < c)); //true


        // ^ 异或;相同为false,不同为true
        System.out.println((a > b) ^ (a > c)); //false
        System.out.println((a > b) ^ (a < c));//true
        System.out.println((a < b) ^ (a > c));//true
        System.out.println((a < b) ^ (a < c));  //false


        // ! 非;非false则true,非true则false
        System.out.println(!false);   //true
        System.out.println(!true); //false
    }
}

短路逻辑运算符

在逻辑与运算中,只要有一个表达式的值为false,那么结果就可以判定为false了,没有必要将所有表达式的值 都计算出来,短路与操作就有这样的效果,可以提高效率。同理在逻辑或运算中,一旦发现值为true,右边的表达式将不再参与运算。

&& 和& 区别:

  • &&和&结果一样,&&有短路效果,左边为false,右边不执行;&左边无论是什么,右边都会执行。

|| 和 | 区别:

  • ||和|结果一样,||有短路效果,左边为true,右边不执行;|左边无论是什么,右边都会执行。

代码示例

/*
逻辑运算符的短路效果
    1.短路的逻辑运算符
        (1)短路逻辑与&&: 左侧为false,右边不计算
        (2)短路逻辑或||: 左侧为true,右侧不计算
    2.特点:
        (1)短路逻辑与&&: 和&结果是相同的,但是&&可以提高效率
        (2)短路逻辑与||: 和|结果是相同的,但是||可以提高效率
 */
public class Demo08Operator {
    public static void main(String[] args) {

        int a = 2;
        /*
            整个表达式(3>5)&&(++a>2)从左向右计算
            先计算表达式3>5结果为false
            因为两个表达式使用&&连接,左侧为false,已经决定了最终的结果为false,
            不管右侧表达式(++a>2)的结果是true还是false,都无法改变&&的最终结果,
            所以右侧表达式(++a>2)不进行计算
         */
        System.out.println((3 > 5) && (++a > 2));//false
        System.out.println(a);//2: 说明++a没有计算,&&右侧的表达式没有执行

        int b = 2;
        /*
            整个表达式(3>5)&(++b>2)从左向右计算
            先计算表达式3>5结果为false
            因为两个表达式使用&连接,左侧为false,虽然已经决定了最终的结果为false,
            但是右侧表达式(++b>2)仍然要进行计算,所以b的值最终是3
         */
        System.out.println((3 > 5) & (++b > 2));//false
        System.out.println(b);//3: 说明++b进行计算,&右侧的表达式执行了

        System.out.println("-------------------");
        int c = 2;
        /*
            整个表达式(3<5)||(++c>2)从左向右计算
            先计算表达式3<5结果为true
            因为两个表达式使用||连接,左侧为true,已经决定了最终的结果为true,
            不管右侧表达式(++c>2)的结果是true还是false,都无法改变||的最终结果,
            所以右侧表达式(++c>2)不进行计算
         */
        System.out.println((3 < 5) || (++c > 2));//true
        System.out.println(c);//2: 说明++c没有计算,||右侧的表达式没有执行

        int d = 2;
        /*
            整个表达式(3<5)|(++d>2)从左向右计算
            先计算表达式3<5结果为true
            因为两个表达式使用|连接,左侧为true,虽然已经决定了最终的结果为true,
            但是右侧表达式(++d>2)仍然要进行计算,所以d的值最终是3
         */
        System.out.println((3 < 5) | (++d > 2));//true
        System.out.println(d);//3: 说明++d进行计算,|右侧的表达式执行了

    }
}

三元运算符

语法格式:

  • 数据类型 变量名称 = 布尔表达式1 ? 表达式2 : 表达式3;

执行流程:

  1. 计算布尔表达式1的结果,看是true还是false
  2. 如果布尔表达式1的结果为true,就把表达式2的结果赋值给左侧的变量
  3. 如果布尔表达式1的结果为false,就把表达式3的结果赋值给左侧的变量

执行流程图解:

代码示例

/*
一座寺庙里住着三个和尚,已知他们的身高分别为150cm、210cm、165cm,请用程序实现获取这三个和尚的最高身高。
 */
public class Demo08Operator {
    public static void main(String[] args) {
        //1:定义三个变量用于保存和尚的身高,单位为cm,这里仅仅体现数值即可。
        int h1 = 150;
        int h2 = 210;
        int h3 = 165;
        //2:用三元运算符获取前两个和尚的较高身高值,并用临时身高变量保存起来。
        int temp = h1 > h2 ? h1 : h2;
        //3:用三元运算符获取临时身高值和第三个和尚身高较高值,并用最大身高变量保存。
        int max = temp > h3 ? temp : h3;
        //4:输出结果
        System.out.println("这三个和尚中身高最高的是:" + max + "cm");
    }
}

位运算(了解)

效率很高,但是可读性不好。因为它是基于二进制补码直接运算的。关于&,|,^,看左右两边的操作数是boolean值,还是整数,来决定是逻辑运算符还是位运算符。常见的有以下几种位运算符

左移:<<

  • 运算规则:<<几位,就乘以2的几次方
  • 二进制补码左移n位,右边补0

右移:>>

  • 运算规则:>>几位,就除以2的几次方
  • 二进制补码右移n位,左边补0还是1,看最高位

无符号右移:>>>

  • 运算规则:二进制补码右移n位,左边补0,对于负数来说,移完后,变为正数

运算符优先级

我们遵循一个原则:

  • 表达式不要写太复杂,可以分为多行
  • 实际开发中都是使用小括号来调整运算优先级

标签:Java,++,System,day05,运算符,int,println,out
来源: https://www.cnblogs.com/wurengen/p/16410770.html

本站声明: 1. iCode9 技术分享网(下文简称本站)提供的所有内容,仅供技术学习、探讨和分享;
2. 关于本站的所有留言、评论、转载及引用,纯属内容发起人的个人观点,与本站观点和立场无关;
3. 关于本站的所有言论和文字,纯属内容发起人的个人观点,与本站观点和立场无关;
4. 本站文章均是网友提供,不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属;如您发现该文章侵犯了您的权益,可联系我们第一时间进行删除;
5. 本站为非盈利性的个人网站,所有内容不会用来进行牟利,也不会利用任何形式的广告来间接获益,纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

专注分享技术,共同学习,共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有