运算符(代码及操作)

MemoryHer

已于 2022-07-27 20:18:32 修改

阅读量822

点赞数 2

分类专栏： JavaEE 笔记文章标签： java 算法开发语言后端面试

于 2022-07-25 14:20:24 首次发布

本文链接：https://blog.csdn.net/MemoryTa/article/details/125974014

版权

笔记同时被 2 个专栏收录

11 篇文章 0 订阅

订阅专栏

JavaEE

10 篇文章 0 订阅

订阅专栏

运算符基础题

1.1 算术运算符

/*
    算术运算符：
       +： 求和
       -： 求差
       *： 求积
       /： 求商
       %： 求余数
 */

import java.util.Scanner;

public class Demo01 {
    public static void main(String[] args) {
        //+： 求和
        int a = 10;
        int b = 20;
        int c = a + b;
        System.out.println(c);
        //键盘录入两个整数，求和
        Scanner sc = new Scanner(System.in);//Alt+回车修正代码或者叫不全代码
        System.out.println("请输入第一个整数：");
        int num1 = sc.nextInt();
        System.out.println("请输入第二个整数：");
        int num2 = sc.nextInt();
        int num3 = num1+num2;
        System.out.println("两数的和是："+num3);

        //-： 求差
        int d = a - b;
        System.out.println(d);

        //*： 求积
        int e = a * b;
        System.out.println(e);
        System.out.println("--------------------");
        //数学中的除法 可以同时求商和求余数 10 ÷ 3 = 3 ...... 1 在java中要么求商要么求余数
        // /： 求商  整数相除叫取整
        int x = 10;
        int y = 3;
        int z = x / y;
        System.out.println(z); // 3
        // %： 求余数 除不尽都是余数
        int m = x % y;// 10%3
        System.out.println(m);// 1
        //我就想得到3.333333…怎么办？ 就要使用小数相除
        double n = 10.0 / 3;  //自动类型转换 把int类型的3，转成double类型的3.0
        System.out.println(n);

        //除不尽都是余数
        int h = 3%10;
        System.out.println(h); // 3
        int j = 10%20;
        System.out.println(j); //10

        int k = 6%10;
        System.out.println(k); //6
    }
}

1.2 字符的加操作

/*
    字符的加操作:


    提示：byte short char 三种类型的数据，在参与运算的时候，首先要转成int 类型的值，然后再参与运算


    ASCII码：
        ASCII (American Standard Code for Information Interchange)：
        美国信息交换标准代码是基于拉丁字母的一套电脑编码系统，主要用于显示现代英语和其他西欧语言。
        它是最通用的信息交换标准，并等同于国际标准 ISO/IEC 646。
        ASCII第一次以规范标准的类型发表是在1967年，最后一次更新则是在1986年，到目前为止共定义了128个字符

         'A' ==> int 类型的 65
         'a' ==> int 类型的 97
         '0' ==> int 类型的 48

 */
public class Demo02 {
    public static void main(String[] args) {
        char c = 'A';
        System.out.println(c + 1); //66

        // 'A' ==> int 类型的 65

        char d = 'a';
        System.out.println(d + 1); //98

        // 'a' ==> int 类型的 97

        char e = '0';
        System.out.println(e + 1); //49

        // '0' ==> int 类型的 48

        //如果有 更高的数据类型参与运算 向高类型转
        double f = 3.14;
        double s = c + f;
        System.out.println(s);

    }
}

1.3 字符串的加操作

/*
    字符串的加操作:
        拼接，遇到字符串才是拼接符
 */
public class Demo03 {
    public static void main(String[] args) {
        System.out.println("HelloWorld");
        System.out.println("Hello"+"World");
        System.out.println(1+99+"年黑马");

        System.out.println(1+2+3+4+5+"HelloWorld"+6+7+8+9);//15HelloWorld6789
        System.out.println(1+2+3+4+5+"HelloWorld"+(6+7+8+9));//15HelloWorld30
    }
}

1.4 自增自减运算符

/*
    自增自减运算符
        自增运算符：++
            对变量自增一
            自增运算符和变量单独使用的时候，无论在变量的前面还是在变量的后面都是对变量自增一
            自增运算符和其他变量参与运算时候 ++在变量的后面,先参与运算，然后再自增一
            自增运算符和其他变量参与运算时候 ++在变量的前面，先自增一，在参与运算
 */
public class Demo04 {
    public static void main(String[] args) {
        //自增运算符：++
        //自增运算符和变量单独使用的时候，无论在变量的前面还是在变量的后面都是对变量自增一
        int a = 10;
        //a++;
        ++a;
        System.out.println(a); //11
        //自增运算符和其他变量参与运算时候 ++在变量的后面,先参与运算，然后再自增一
        int b = 20;
        int c = b++;
        System.out.println(b); //21
        System.out.println(c); //20
        //自增运算符和其他变量参与运算时候 ++在变量的前面，先自增一，在参与运算
        int d = 30;
        int e = ++d;
        System.out.println(d); //31
        System.out.println(e); //31


    }
}

/*
    自减运算符：
        对变量自减一
 */
public class Demo05 {
    public static void main(String[] args) {
        int a = 10;
        //单独使用的时候，无论在变量的前面还是在变量后面，都是对变量自减一
        //--a;
        a--;
        System.out.println(a); // 9
        //参与运算的时候，--在变量的后面,先参与运算，再自减一
        int b = 20;
        int c = b--;
        System.out.println(b); // 19
        System.out.println(c); // 20
        //参与运算的时候，--在变量的前面，先自减一，在参与运算
        int d = 30;
        int e = --d;
        System.out.println(d);
        System.out.println(e);
    }
}

1.5 关系运算符

/*
    关系运算符:
        >
        >=
        <
        <=
        ==
        !=
        关系运算符的结果是布尔类型的值，是true或者false
 */
public class Demo06 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(a > b);//false
        System.out.println(a < b);//true
        a = 20;
        System.out.println(a == b);//true
        System.out.println(a >= b);//true
        System.out.println(a <= b);//true
        a = 21;
        System.out.println(a >= b);//true
        System.out.println(a <= b);//false

        System.out.println(a != b);//true

    }
}

1.6 逻辑运算符

/*
    逻辑运算符：
        & ：见false则false，只有两边同时为true结果才为true
        | ：见true则true ，只有两边同时为false结果才为false
        ^ : 相同为false 不同为true
        ! : 取反 true变false false变true
        提示：逻辑运算符两边放的是关系表达式，因为关系表达式的值是布尔类型的，所以逻辑运算符表达式的值，也是布尔类型的
 */
public class Demo07 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 30;
        // & ：见false则false，只有两边同时为true结果才为true
        System.out.println(a > b & a > c); //false & false ==> false
        System.out.println(a > b & a < c); //false & true  ==> false
        System.out.println(a < b & a > c); //true  & false ==> false
        System.out.println(a < b & a < c); //true  & true  ==> true
        System.out.println("-------------------------");
        //| ：见true则true ，只有两边同时为false结果才为false
        System.out.println(a > b | a > c); //false | false ==> false
        System.out.println(a > b | a < c); //false | true  ==> true
        System.out.println(a < b | a > c); //true  | false ==> true
        System.out.println(a < b | a < c); //true  | true  ==> true
        System.out.println("--------------------------");
        //^ : 相同为false 不同为true
        System.out.println(a > b ^ a > c); //false ^ false ==> false
        System.out.println(a > b ^ a < c); //false ^ true  ==> true
        System.out.println(a < b ^ a > c); //true  ^ false ==> true
        System.out.println(a < b ^ a < c); //true  ^ true  ==> false
        System.out.println("--------------------------");
        //！：取反的意思 true变false,false变true
        System.out.println(a > b);      //false
        System.out.println(!(a > b));   //true
        System.out.println(!!(a > b));  //false
        System.out.println(!!!(a > b)); //true
    }
}

1.7 短路的逻辑运算符

/*
    短路的逻辑运算符：
        &&:
            短路与，和逻辑与的运算规则是一样的，见false则false，具有短路的效果，如果左边表达式的值是false右边就表达式不运算
        ||:
            短路或，和逻辑或的运算规则是一样的，见true则true，具有短路的效果，如果左边表达式的值为true，右边表达式就不运算
 */
public class Demo08 {
    public static void main(String[] args) {
        //&:短路与，和逻辑与的运算规则是一样的，见false则false，具有短路的效果，如果左边表达式的值是false右边就表达式不运算
        int a = 10;
        int b = 20;
        /*System.out.println(a++ > 30 & b++ > 30); //false & false ==> false
        System.out.println(a); //11
        System.out.println(b); //21*/
        System.out.println(a++ > 30 && b++ > 30); //false & false ==> false
        System.out.println(a); //11
        System.out.println(b); //20
        //||:短路或，和逻辑或的运算规则是一样的，见true则true，具有短路的效果，如果左边表达式的值为true，右边表达式就不运算
        int c = 30;
        int d = 40;
        //System.out.println(c++ < 50 | d++ > 50); //true | false ==> true
        /*System.out.println(c); //31
        System.out.println(d); //41*/
        System.out.println(c++ < 50 || d++ > 50); //true | false ==> true
        System.out.println(c); //31
        System.out.println(d); //40
    }
}

1.8 赋值运算符

/*
    赋值运算符:
        =: 把右边的变量或者值，赋值给左边的变量


        +=:
            把左边的变量中的值和右边的变量或者值相加的和，重新赋值给左边的变量
        -=:
            把左边的变量中的值和右边的变量或者值相减的差，重新赋值给左边的变量
        *=:
            把左边的变量中的值和右边的变量或者值相乘的积，重新赋值给左边的变量
        /=:
            把左边的变量中的值和右边的变量或者值相除的商，重新赋值给左边的变量
        %=:
            把左边的变量中的值和右边的变量或者值相除的余数，重新赋值给左边的变量
        复合赋值运算符特点： 隐含了一个强制类型转换
 */
public class Demo09 {
    public static void main(String[] args) {
        // =: 把右边的变量或者值，赋值给左边的变量
        int a = 10;
        int b = a;
        // +=:把左边的变量中的值和右边的变量或者值相加的和，重新赋值给左边的变量
        a += 10;
        System.out.println(a); // 20

        // -=:把左边的变量中的值和右边的变量或者值相减的差，重新赋值给左边的变量
        int c = 30;
        c -= 20; //c = c-20;
        System.out.println(c);

        // *=:把左边的变量中的值和右边的变量或者值相乘的积，重新赋值给左边的变量
        int d = 40;
        d *= 5;
        System.out.println(d); //200

        // /=:把左边的变量中的值和右边的变量或者值相除的商，重新赋值给左边的变量
        int e = 50;
        e /= 5;
        System.out.println(e); //10

        //%=:把左边的变量中的值和右边的变量或者值相除的余数，重新赋值给左边的变量
        int f = 60;
        f %= 8;
        System.out.println(f); //4

        //复合赋值运算符特点： 隐含了一个强制类型转换

        short s = 10;
        s += 10;// s = (short) (s+10);
        System.out.println(s); //20
    }
}

1.9 三元运算符

/*
    三元运算符:
        格式：
            条件表达式/关系表达式 ? 表达式1 ： 表达式2
        运算规则：
            1.先判断 条件表达式/关系表达式 的值
            2.如果 条件表达式/关系表达式 的值为true 选择表达式1的值作为此三元表达式最终的值
            3.如果 条件表达式/关系表达式 的值为false 选择表达式2的值作为此三元表达式最终的值
 */
public class Demo10 {
    public static void main(String[] args) {
        //定义两个变量，求最大值
        int a = 30;
        int b = 20;

        int max = a > b ? a : b;

        System.out.println("max = " + max);

    }
}

习题

2.1 求两个数的最大值

import java.util.Scanner;

/*
    键盘录入两个数字，求最大值
        分析：
            1.键盘录入
                导包
                    import java.util.Scanner
                创建对象
                    Scanner sc = new Scanner(System.in);
                接收数据
                    int num1 = sc.nextInt();
                    int num2 = sc.nextInt();
             2.求最大值
                使用三元运算符求最大值
                int max = num1>num2?num1:num2;
            3.打印最大值
                sout(max)
 */
public class Demo01 {
    public static void main(String[] args) {
        //创建对象
        Scanner sc = new Scanner(System.in);
        //接收数据
        System.out.println("请输入第一个数字：");
        int num1 = sc.nextInt();
        System.out.println("请输入第二个数字：");
        int num2 = sc.nextInt();
        //使用三元运算符求最大值
        int max = num1 > num2 ? num1 : num2;
        //打印最大值
        System.out.println("max = " + max);
    }
}

2.2 求一个数字各个位上的数字

import java.util.Scanner;

/*
    需求：键盘录入一个三位数，将其拆分为个位、十位、百位后，打印在控制台
        分析:
            1.键盘录入
                导包 import java.util.Scanner
                创建对象 Scanner sc = new Scanner(System.in);
                接收数据 int num = sc.nextInt();
            2.将其拆分为个位、十位、百位后
            3.打印

            123  拿到各位 123÷10 = 12 ...... 3
                 个位数字：123%10 = 3
                 十位数字：123/10%10 = 2
                 百位数字：123/100 = 1
 */
public class Demo02 {
    public static void main(String[] args) {
        //创建对象
        Scanner sc = new Scanner(System.in);
        //接收数据
        System.out.println("请输入一个三位数：");
        int num = sc.nextInt();
        //将其拆分为个位、十位、百位后
        //个位数字：123%10 = 3
        int ge = num%10;
        //十位数字：123/10%10 = 2
        int shi = num/10%10;
        //百位数字：123/100 = 1
        int bai = num/100;
        //3.打印
        System.out.println("个位上数字："+ge);
        System.out.println("十位上数字："+shi);
        System.out.println("百位上数字："+bai);

    }
    /*
        1234
        个位 1234%10 = 4
        十位 1234/10%10 = 3
        百位 1234/100%10 = 2
        千位 1234/1000 = 1
        12345
        千位 12345/1000%10 = 2
        万位 12345/10000%10 = 1

        求各个位上的数字公式：
            个位 num/1%10
            十位 num/10%10
            百位 num/100%10
            千位 num/1000%10
            万位 num/10000%10
            ......


     */
}

2.3 求三个数的最大值

import java.util.Scanner;

/*
    案例：求三个整数的最大值
        需求：键盘录入三个整数，找出最大值并打印在控制台


 */
public class Demo03 {
    public static void main(String[] args) {
        //使用 Scanner 键盘录入三个整数
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一个整数：");
        int num1 = sc.nextInt();
        System.out.println("请输入第二个整数：");
        int num2 = sc.nextInt();
        System.out.println("请输入第三个整数：");
        int num3 = sc.nextInt();
        //用三元运算符获取前两个整数的最大值，并用临时变量保存起来。
        int tempMax = num1 > num2 ? num1 : num2;
        //用三元运算符，让临时最大值，和第三个整数，进行比较，并记录结果
        int max = tempMax > num3 ? tempMax : num3;
        //打印结果
        System.out.println("max= "+max);
    }
}