二、运算符与程序控制结构

最新推荐文章于 2024-05-25 10:57:37 发布

肿么啦！

最新推荐文章于 2024-05-25 10:57:37 发布

阅读量255

点赞数

分类专栏： Java学习文章标签： java

本文链接：https://blog.csdn.net/weixin_46048220/article/details/128180584

版权

Java学习专栏收录该内容

5 篇文章 0 订阅

订阅专栏

一、运算符

是一种特殊的符号，用以表示数据的运算、赋值和比较等

（一）算数运算符

在这里插入图片描述
ArithmeticOperator.java

public static void main(String[] args) {
        System.out.println(10/4);   //2
        System.out.println(10.0/4); //2.5
        double d=10/4;              //2->double-->2.0
        System.out.println(d);

        // %:取模，取余
        // 公式：a%b=a-a/b*b
        // 10-10/3*3=10-3*3=1
        System.out.println(10%3);
        // -10-(-10)/3*3=-10-(-3)*3=-10-(-9)=-1
        System.out.println(-10%3);
        // 10-10/(-3)*(-3)=10-(-3)*(-3)=10-9=1
        System.out.println(10%-3);
        // -10-(-10)/(-3)*(-3)=-10-(-9)=-1
        System.out.println(-10%-3); 

        // ++:
        // 1、作为独立语句使用时，前++和后++都完全等价于i=i+1
        int i=10;
        i++;
        ++i;
        System.out.println("i="+i);     //i=12
        // 2、作为表达式使用：
        // 前++：++i先自增后赋值
        // 后++：i++先赋值后自增
        int j=8;
        int k=++j;  //等价于j = j + 1; k = j;
        int l=j++;
        System.out.println("k="+k+" l="+l+" j="+j);

        /*
        赋值的变量为自身的时候，规则使用临时变量：
        （1）temp=i；
        （2）i=i+1；
        （3）i=temp；
         */
        int x=1;
        x=x++;
        System.out.println(x);  //1

        /*
        （1）i=i+1；
        （2）temp=i；
        （3）i=temp；
         */
        int y=1;
        y=++y;
        System.out.println(y);  //2

        /**
         * 59天是*个星期零几天？
         */
        int days=59;
        int week=days/7;
        int leftdays=days%7;
        System.out.println("===="+week+'\t'+leftdays+"====");

        /**
         * 华氏温度转摄氏温度（5/9*(华氏温度-100))
         */
        double huaShi=104;
        double sheShi=5.0/9*(huaShi-100);   //使用5.0而非5
        System.out.println(sheShi); //2.2222222222222223
        System.out.println(5/9);    //0
        System.out.println(5.0/9);  //0.5555555555555556
}

（二）关系运算符（比较运算符）

1、运算结果都是boolean型，即true或false
2、关系表达式经常用在if结构的条件中或循环结构的条件中
在这里插入图片描述

（三）逻辑运算符

用于连接多个条件（多个关系表达式），最终结果是一个boolean值
在这里插入图片描述

| 和 || 同理

LogicOperator.java

public static void main(String[] args) {
        int age=30;
        if (age>20 && age<90){  //短路与，第一个条件为false，后面则不再执行
            System.out.println("ye");
        }
        if (age>20 & age<90){   //逻辑与，第一个条件为false，后面继续执行判断
            System.out.println("ye");
        }
        if (age>20 || age<90){  //短路或，第一个条件为true，后面不再继续执行判断，效率高
            System.out.println("ye");
        }
        if (age>20 | age<90){   //逻辑或，第一个条件为true，后面继续执行判断
            System.out.println("ye");
        }
}

逻辑取反和逻辑异或操作案例演示：InverseOperator.java

public static void main(String[] args) {
        // !操作是取反 T->F F->T
        System.out.println(60>20);      //T
        System.out.println(!(60>20));   //F

        // a^b 异或，a和b不同时，结果为true，否则为false
        boolean b=(10>1)^(3<5);    //F
        System.out.println(b);      
}

练习：
在这里插入图片描述

注意区分 = 和 == 。

（四）赋值运算符

1、定义：将运算后的值赋给指定的变量
2、分类：

基本赋值运算符：=
复合赋值运算符：+=、-=、*=、/=、%=等
a += b; [ 等价 a = a + b ]
3、特点：
运算顺序从右到左
赋值运算符的左边只能是变量，右边可以是变量、表达式、常量值
复合赋值运算符会进行类型转换

AssignOperator.java

public static void main(String[] args) {
        int n1=10;
        n1/=4;

        // 复合赋值运算会进行类型转换
        byte b=3;
        b+=2;       //等价于：b=(byte)(b+2);
        // b=b+2;    报错：等价于b=5(int类型）
}

（五）三元运算符

1、语法：条件表达式？表达式1 ：表达式2；
2、运算规则：

如果条件表达式为true，运算后的结果是表达式1；
如果条件表达式为false，运算后的结果是表达式2；
TernaryOperator.java

public static void main(String[] args) {
        int a = 10;
        int b = 99;
        int result = a > b ? a++ : b--;
        System.out.println(result + " " + b); // 99 98
        int result1 = a > b ? (int).1 : (int).2;  //需要强转
        //int可以自动转换为double
        double result2 = a > b ? a : b + 2; 

        // 求最大值
        int max1 = a > b ? a : b;
        int max2 = c > max1 ? c : max1;
        System.out.println("最大数=" + max2);
        // 使用一条语句实现
        int max = (a > b ? a : b) > c ? (a > b ? a : b) : c;
        System.out.println("最大数=" + max);
}

注意：

表达式1和表达式2要为可以赋给接收变量的类型（或可以自动转换）
三元运算符可以转成if-else语句

（六）运算符优先级

在这里插入图片描述
标识符命名规范：

包名：所有字母小写
类名、接口名：单词首字母大写
变量名、方法名：首字母小写，后面单词首字母大写
常量名：全部字母大写

（七）二进制和位运算

在这里插入图片描述

public class BinaryTest {
    public static void main(String[] args) {
        int n1 = 0b1010;    // 二进制
        int n2 = 1010;      // 十进制
        int n3 = 001010;    // 八进制
        int n4 = 0x10101;   // 十六进制
        System.out.println("n1=" + n1); // 10
        System.out.println("n2=" + n2); // 1010
        System.out.println("n3=" + n3); // 520
        System.out.println("n4=" + n4); // 65793
    }
}

项目	Value
电脑	$1600
手机	$12
导管	$1

十进制	十六进制	八进制	二进制
0	0	0	0
1	1	1	1
2	2	2	10
3	3	3	11
4	4	4	100
5	5	5	101
6	6	6	110
7	7	7	111
8	8	10	1000
9	9	11	1001
10	A	12	1010
11	B	13	1011
12	C	14	1100
13	D	15	1101
14	E	16	1110
15	F	17	1111
16	10	20	10000
17	11	21	10001

（1）进制转换

A、其他进制转十进制

二进制转十进制
规则：从最低位（右边）开始，将每个位上的数提取出来，乘以2的（位数-1）次方，然后求和
eg：将0b1010转成十进制
0b1010=12^(1-1) + 1 * 2^(2-1) + 02^(3-1) + 1*2^(4-1) = 1+2+0+8=11
八进制转十进制
规则：从最低位（右边）开始，将每个位上的数提取出来，乘以8的（位数-1）次方，然后求和
eg：将0234转换为十进制数
0234=4 * 8^(1-1) + 3 * 8 ^(2-1) + 2* 8^(3-1)=4+24+128=156
十六进制转十进制
规则：从最低位（右边）开始，将每个位上的数提取出来，乘以16的（位数-1）次方，然后求和
eg：将0x23A转换为十进制数
0x23A=10 * 16^(1-1) + 3 * 16^(2-1) + 2* 16^(3-1)=10+48+512=570

B、十进制转其他进制

十进制转二进制
规则：将该数不断除以二，直到商为0为止，然后将每步得到的余数倒过来，就是对应的二进制
eg：将34转成二进制
34 17 8 4 2 1
2 2 2 2 2
0 1 0 0 0 1 —>0b0010 0010
十进制转八进制
规则：将该数不断除以八，直到商为0为止，然后将每步得到的余数倒过来，就是对应的八进制
eg：将131转成八进制
131 16 2
8 8
3 0 2 —>0203
十进制转十六进制
规则：将该数不断除以十六，直到商为0为止，然后将每步得到的余数倒过来，就是对应的十六进制
eg：将237转成十六进制
237 14
16
D E —>0xED

C、二进制转其他进制

二进制转八进制
规则：从低位开始，将二进制每三位一组，转成对应的八进制数即可（111=7）
eg：将0b11 010 101转成八进制
101–>5
010–>2
1 1–> 3
0b11 010 101—>0325
二进制转十六进制
规则：从低位开始，将二进制每四位一组，转成对应的十六进制数即可（1111=15）
eg：将0b1101 0101转成十六进制
0101—>5
1101—>D
0b1101 0101—>0xD5

D、其他进制转二进制

八进制转二进制
规则：将八进制数每一位，转成对应的一个3位的二进制数
eg：将0237转成二进制
7—>111
3—>011
2—>010
0237—>0b1001 1111
十六进制转二进制
规则：将十六进制数每一位，转成对应的一个4位的二进制数
eg：将0x23b转成二进制
B—>1011
3—>0011
2—>0010
0x23b—>0b0010 0011 1011

（2）原码、反码、补码

计算机由运算器、控制器、存储器、输入设备和输出设备组成。其中运算器只有加法运算器，没有减法运算器，所以计算机中不能直接做减法，其减法通过加法实现。现实世界中所有的减法可以当成加法，减去一个数可以看做加上这个数的相反数，但前提是要有负数的概念，所以要引入一个符号位。符号位在内存中存放在最左边一位，如果该位为0，则说明该数为正数；若为1，则说明该位为负数。
原码、补码、反码的产生过程就是为了解决计算机做减法和引入符号位的问题

运算规则（重点）

二进制的最高位是符号位：0表示整数，1表示负数（口诀：0->0 1->-）
正数的原码、反码、补码一样（三码合一）
负数的反码=它的原码符号位不变，其它位取反（0->1 1->0 ）
负数的补码=负数的反码+1，负数的反码=负数的补码-1
0的反码，补码都是0
java没有无符号数，即java中所有的数都是有符号的
在计算机运算的时候，都是以补码的方式来运算的
看运算结果的时候，要看他的原码

位运算符

按位与&：两位全为1，结果为1，否则为0
按位或|：两位有一个为1，结果为1，否则为0
按位异或^：两位一个位0，一个为1，结果为1，否则为0
按位取反~：0->1 1->0
算数右移>>：低位溢出，符号位不变，用符号位补溢出的高位
int a = 1 >> 2; // 00000001 => 00000000
本质：1 / 2 / 2 = 0
int b = 15 >> 2; // 00001111 => 00000011
本质：15 / 2 / 2 = 3
算数左移<<：符号位不变，低位补0
int a = 1 << 2; // 00000001 => 00000100 => 4
本质：1 * 2 * 2 = 4
int b = 4 << 3 // 00000100 => 0100000
本质：4 * 2 * 2 * 2 = 32
逻辑右移>>>（也叫无符号右移），低位溢出，高位补0
注意：没有<<<符号

public class BitOperator {
    public static void main(String[] args) {
        //1.先得到2的补码->
        // 2的原码 00000000 00000000 00000000 00000010
        // 2的补码 00000000 00000000 00000000 00000010
        //2.先得到3的补码->
        // 3的原码 00000000 00000000 00000000 00000011
        // 3的补码 00000000 00000000 00000000 00000011
        //3.按位&
        // 00000000 00000000 00000000 00000010
        // 00000000 00000000 00000000 00000011
        // 00000000 00000000 00000000 00000010  &运算后的补码
        // 运算后的原码也是00000000 00000000 00000000 00000010（正数三码合一）
        //原码结果就是2
        System.out.println(2&3);        //2

        //1.先得到-2的原码->
        // 10000000 00000000 00000000 00000010
        //2.得到-2的补码->要先得到反码，再将反码+1
        // 反码 11111111 11111111 11111111 11111101
        //3.-2的补码:11111111 11111111 11111111 11111110
        //4.~-2：00000000 00000000 00000000 00000001（运算后的补码）
        //因为运算后的补码为正数，则原码和补码相同：原码结果为1
        System.out.println(~-2);    //1

        //1.得到2的补码：00000000 00000000 00000000 00000010
        //2.~2操作：11111111 11111111 11111111 11111101（运算后的补码）
        //3.运算后的反码（补码-1）：11111111 11111111 11111111 11111100
        //4.运算后的原码（符号位不变，其他取反）：
        // 10000000 00000000 00000000 00000011=>-3
        System.out.println(~2);     //-3

        System.out.println(2|3);    //3
        System.out.println(2^3);    //1

        //a%b，当a是小数时，公式 = a - (int)a / b * b
        //-10.4 - (-10)/3 * 3 = -10.4 + 9 = -1.4000000000000004
        //注意：有小数参与的运算，得到的值为近似值
        System.out.println(-10.4%3);    //-1.4000000000000004

        int i = 66;
        //执行i = i + 1 => i = 67 => i + i = 134
        System.out.println(++i+i);  //134
    }
}

二、程序控制结构

（一）顺序控制

程序从上到下逐行执行，中间没有任何判断和跳转。

（二）分支控制（if、else、switch）

分类：

1. 单分支-if：

![在这里插入图片描述](https://img-blog.csdnimg.cn/f15fcce198a44bb99288961bbf05ee51.jpeg#pic_center)

public class If01 {
    public static void main(String[] args) {
        Scanner myScanner = new Scanner(System.in);
        System.out.println("请输入年龄");
        int age = myScanner.nextInt();
        if (age > 18){
            System.out.println("成年");
        }
        System.out.println("程序继续");
    }
}

在这里插入图片描述

2. 双分支 if - else：

在这里插入图片描述

public class If02 {
    public static void main(String[] args) {
        Scanner myScanner = new Scanner(System.in);
        System.out.println("请输入年龄");
        int age = myScanner.nextInt();
        if (age > 18){
            System.out.println("成年");
        } else {
            System.out.println("未成年");
        }
        System.out.println("程序继续");
    }
}

在这里插入图片描述

3. 多分支 if - else if - else ：

在这里插入图片描述

注意：
1.多分支可以没有else，如果所有的条件表达式都不成立，则一个执行入口都没有
2.如果有else，当所有条件表达式都不成立时，默认执行else代码块

public class If03 {
    public static void main(String[] args) {
        Scanner myScanner = new Scanner(System.in);
        System.out.println("请输入信用分(1~100)");
        int grade = myScanner.nextInt();
        if (grade <= 100 && grade >= 0){
            if (grade == 100){
                System.out.println("信用极好");
            } else if(grade > 80 && grade <= 99) {
                System.out.println("信用优秀");
            } else if(grade >= 60 && grade <= 80) {
                System.out.println("信用一般");
            } else {
                System.out.println("信用差");
            }
        } else {
            System.out.println("输入不合法，请重新输入！！");
        }
        System.out.println("程序继续");
    }
}

4. 嵌套分支

在这里插入图片描述

import java.util.Scanner;

public class NestedIf {
    public static void main(String[] args) {
        /*
        参加比赛，初赛成绩大于8.0则进入决赛
        否则淘汰。根据性别分为男子组、女子组
        接收字符：char gender = scanner.next().charAt(0)
         */
        Scanner myScanner = new Scanner(System.in);
        System.out.println("输入成绩");
        double score = myScanner.nextDouble();
        if (score > 8.0){
            System.out.println("进入决赛，输入性别");
            char gender = myScanner.next().charAt(0);
            if (gender == '男'){
                System.out.println("进入男子组");
            } else if (gender == '女'){
                System.out.println("进入女子组");
            } else {
                System.out.println("输入有误");
            }
        } else {
            System.out.println("淘汰");
        }
    }
}

5. switch分支结构

在这里插入图片描述

import java.util.Scanner;

public class Switch01 {
    public static void main(String[] args) {
        /*
        a:周一；b:周二；c:周三； ……
         */
        Scanner sc = new Scanner(System.in);
        System.out.println("输入一个字符（a-g）");
        char c1 = sc.next().charAt(0);
        switch (c1){
            case 'a':
                System.out.println("1");
                break;
            case 'b':
                System.out.println("2");
                break;
            case 'c':
                System.out.println("3");
                break;
            case 'd':
                System.out.println("4");
                break;
            case 'e':
                System.out.println("5");
                break;
            case 'f':
                System.out.println("6");
                break;
            case 'g':
                System.out.println("7");
                break;
            default:
                System.out.println("无匹配");
        }
        System.out.println("退出了switch，继续执行程序");
    }
}

注意事项：

表达式数据类型应和case后的常量类型一致，或者是可以自动转成可以相互比较的类型，比如输入的是字符，而常量是int

char c = 'a';
        switch (c){
            case 'a':
                System.out.println("ok1");
                break;
            case 20:
                System.out.println("ok2");
                break;
            default:
                System.out.println("ok3");
        }
        String s = "20";
        switch (s){
            case "a":
                System.out.println("ok1");
                break;
            case "20":
                System.out.println("ok2");
                break;
            default:
                System.out.println("ok3");
        }

switch（表达式）中表达式的返回值必须是（byte、short、int、char、enum、String）

double d = 1.1;
        //Incompatible types. 
        // Found: 'double', required: 'char, byte, short, int,
        // Character, Byte, Short, Integer, String, or an enum'
        switch (d){    //不兼容的类型，double转成int可能会精度丢失
            case 1.1:
                System.out.println("ok1");
                break;
            case 2.1:
                System.out.println("ok2");
                break;
            default:
                System.out.println("ok3");
        }

case子句中的值必须是常量或常量表达式（如：‘b’+1），不可以是变量
default子句是可选的，当没有匹配的case时，执行default。如果没有default子句，又没有匹配任何常量，则没有输出
break语句用来在执行完一个case分支后使程序跳出switch语句块；如果没有写break，程序会一直执行到下一个有break语句的case分支，如果一直没有break，程序会一直执行到switch结尾

public class SwitchDetail {
    public static void main(String[] args) {
        double score = 88.5;
        if( score >= 0 && score <= 100){
            switch ( (int)(score / 60) ){
                case 1:
                    System.out.println("合格");
                    break;
                default:
                    System.out.println("不合格");
            }
        } else {
            System.out.println("输入有误");
        }
    }
}

（三）循环控制（for、while、do while、多重循环）

1. for循环

基本语法：
for( 循环变量初始化；循环条件；循环变量迭代){
循环操作（可以多条语句）；
}
在这里插入图片描述

public class For1 {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            System.out.println("hello " + i);
        }
        System.out.println("i = " + i);
    }
}

hello 0
hello 1
hello 2
hello 3
hello 4
i = 5

public class For1 {
    public static void main(String[] args) {
        int i = 0;
        for (; i < 5; ) {
            System.out.println("hello " + i);
            i++;
        }
        System.out.println("i = " + i);
    }
}

hello 0
hello 1
hello 2
hello 3
hello 4
i = 5

2. while循环

基本语法：
while( 循环条件 ){
循环体（语句）；
循环变量迭代；
}
在这里插入图片描述

public class While1 {
    public static void main(String[] args) {
        int i = 1;
        while (i != 4){
            System.out.println(i);
            i++;
        }
    }
}

1
2
3

3. do…While循环控制

基本语法
循环变量初始:
do{
循环体(语句)
循环变量迭代
}while(循环条件);
说明:
1.do while 是关键字
1.也有循环四要素,只是位置不一样
2.先执行，再判断，也就是说，一定会执行一次
3.最后有一个分号 ;
在这里插入图片描述

public class DoWhile1 {
    public static void main(String[] args) {
        int i = 0;
        do {
            System.out.println(i);
            i++;
        } while (i < 3);
    }
}

0
1
2

注意：
1.循环条件是返回一个布尔值的表达式
2.do…while循环是先执行再判断，因此至少执行一次

public class DoWhile1 {
    public static void main(String[] args) {
        char answer = ' ';
        Scanner sc = new Scanner(System.in);
        do {
            System.out.println("打一顿");
            System.out.println("还钱吗？y/n");
            answer = sc.next().charAt(0);
            System.out.println(answer);
        } while (answer != 'y');
        System.out.println("不打了");
    }
}

打一顿
还钱吗？y/n
n
n
打一顿
还钱吗？y/n
y
y
不打了

4.嵌套循环

在这里插入图片描述

public class MulForExercise {
    public static void main(String[] args) {
        /*
        统计3个班的成绩情况，每个班5名学生
        求出各班平均分即所有班级的平均分
        统计三个班及格人数
         */
        Scanner myScanner = new Scanner(System.in);
        double totalScore = 0;  // 累计所有同学的总分
        int passNum = 0;        // 及格的学生
        int stuNum = 5;         // 每个班学生人数
        int claNum = 3;         // 班级个数
        for (int i = 1; i <= claNum; i++) {
            double sumScore = 0;    // 一个班级的总分
            for (int j = 1; j <= stuNum; j++) {
                System.out.println("请输入第" + i + "个班的第" + j + "个学生的成绩");
                double score = myScanner.nextDouble();
                if (score >= 60){
                    passNum++;
                }
                sumScore += score;
            }
            System.out.println("第" + i + "个班———总分为：" + sumScore + "； 平均分：" + sumScore/stuNum + "；");
            totalScore += sumScore;
        }
        System.out.println("三个班的总分：" + totalScore + "；及格人数："
                + passNum + "；平均分：" + totalScore/(stuNum*claNum));
    }
}

打印空心金字塔和空心菱形

public class HollowPyramid {
    public static void main(String[] args) {
        /*
        打印三角形
        *
        **
        ***
        ****
         */
        for (int i = 1; i < 5; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
        /*
        打印金字塔：
           *        // 第一层 有1个*    3个空格
          ***       // 第二层 有3个*    2个空格
         *****      // 第三层 有5个*    1个空格
        *******     // 第四层 有7个*    0个空格
        *数 = 2 * 当前层数 - 1
        空格数 = 总层数 - 当前层数
        以下代码不考虑金字塔左侧的空格，打印结果如下：
        *
        ***
        *****
        *******
         */
        for (int i = 1; i < 5; i++) {
            //输出*
            for (int j = 1; j <= 2 * i - 1; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
        /*
        考虑空格
         */
        for (int i = 1; i < 5; i++) {
            //输出空格
            for (int j = 1; j < 5 - i; j++) {
                System.out.print(" ");
            }

            //输出*
            for (int j = 1; j <= 2 * i - 1; j++) {
                System.out.print("*");
            }
            System.out.println();
        }

        /*
        打印空心金字塔
           *        // 第一层 有1个*    当前行的第一个和最后一个位置是*
          * *       // 第二层 有3个*    当前行的第一个和最后一个位置是*
         *   *      // 第三层 有5个*    当前行的第一个和最后一个位置是*
        *******     // 第四层 有7个*    全部输出*
         */
        int totalLevel = 4;     //层数
        for (int i = 1; i <= totalLevel; i++) {
            //输出空格
            for (int j = 1; j <= totalLevel - i; j++) {
                System.out.print(" ");
            }

            //输出*
            for (int j = 1; j <= 2 * i - 1; j++) {
                if (j == 1 || j == 2 * i - 1 || i == totalLevel){
                    System.out.print("*");
                }else {
                    System.out.print(" ");
                }
            }
            System.out.println();
        }
    }
}

（四）break

在这里插入图片描述

public class Break1 {
    public static void main(String[] args) {
        /*
        1-100以内的数求和，求出 当和 第一次大于20的当前数
         */
        int sum = 0;    //累积和
        int i = 1;
        for (; i <= 100; i++) {
            sum += i;   // 累积
            if (sum > 20){
                break;
            }
        }
        System.out.println("和>20 当前数i = " + i);

        /*
        实现登录验证，有3次机会，如果用户名为”张三“，密码为
        “666”提示登录成功，否则显示还有几次机会
         */
        Scanner myScanner = new Scanner(System.in);
        String name = "";
        String pwd = "";
        int chance = 3;     // 输入用户名和密码的机会
        for (int j = 0; j < 3; j++) {
            System.out.println("请输入名字");
            name = myScanner.next();
            System.out.println("请输入密码");
            pwd = myScanner.next();
            // 进行比对
            // 字符串的比较方法：equls(Object anObject)
            if ("张三".equals(name) && "666".equals(pwd)){
                System.out.println("登录成功，欢迎你：" + name);
                break;
            }
            chance--;
            System.out.println("用户名或密码错误，剩余登录机会：" + chance + "次！！！");

        }
    }
}

Java中，使用"“比较字符串时，判断的是两个字符串是否存放在相同的位置。如果两个字符串存放在相同的位置，那么它们就是相同的，使用”"比较的结果也就是True。但Java虚拟机并不总是使两个相同的字符串共享一个位置，它可能会存放多个相同的拷贝在不同的位置。
简言之，==比较的是内存地址，equals()比较值

（五）continue

在这里插入图片描述

public class Continue1 {
    public static void main(String[] args) {
        int i = 1;
        while (i <= 3){
            i++;
            if (i == 2){
                continue;
            }
            System.out.println("i = " + i);
        }
    }
}

i = 3
i = 4

continue出现在多层嵌套语句块中时，也可以通过标签指明跳过哪一层语句块

（六）return

表示跳出所在的方法，如果return写在main方法，则退出程序

public class Return1 {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            if (i == 2){
                System.out.println("hi");
                return;
            }
            System.out.println("hello");
        }
        System.out.println("helloWorld");
    }
}

hello
hello
hi
因为return，程序停止，System.out.println(“helloWorld”)未执行 => 没有输出helloWorld

package programcontrolstructure;

/*
A有100,000元
1）当现金>500,00时，每天花5%
2）当现金<=500,00时，每天花1000
计算A可以花多少天
 */
public class EX1 {
    public static void main(String[] args) {
        double money = 100000;
        int count = 0;
        while (money >= 1000){
            if (money > 50000){
                money *= 0.95;
                count++;
            }else{
                money -= 1000;
                count++;
            }
        }
        System.out.println("可以花" + count + "天");
    }
}

/*
判断一个数是否为水仙花数（水仙花数是指一个3位数，其各个位上
数字立方和等于其本身。如：153 = 1*1*1 + 3*3*3 + 5*5*5
 */
public class EX2 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个三位数：");
        int num = scanner.nextInt();
        int num1 = num / 100;
        int num2 = num % 100 /10;
        int num3 = num % 10;
        if (num1 * num1 * num1 + num2 * num2 * num2 + num3 * num3 * num3 == num){
            System.out.println(num + "是水仙花数");
        }else {
            System.out.println(num + "不是水仙花数");
        }

    }
}

/*
输出小写的a-z以及大写的Z-A
 */
public class EX4 {
    public static void main(String[] args) {
        char c;
        for (c = 'a'; c <= 'z' ; c++) {
            System.out.print(c + " ");
        }
        System.out.println();
        for (c = 'Z'; c >= 'A' ; c--) {
            System.out.print(c + " ");
        }
    }
}

a b c d e f g h i j k l m n o p q r s t u v w x y z
Z Y X W V U T S R Q P O N M L K J I H G F E D C B A

/*
求出1 - 1/2 + 1/3 - 1/4 …… 1/100的和
 */
public class EX5 {
    public static void main(String[] args) {
        double count = 0;
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0){
                count -= 1.0 / i;
            }else {
                count += 1.0 / i;
            }
        }
        System.out.println(count);
    }
}

陷阱：
在Java中，int类型除以任何比它小的int类型的数，运算结果都是0
在上一案例中，i为int类型，所以当 1（int类型）除以 i 的结果永远为0，所以应当将 1 改为 1.0（double类型）或者将 i 定义为double类型

package programcontrolstructure;
/*
求1 + (1+2) + (1+2+3) + (1+2+3+4) +……+ (1+2+3……100)
 */
public class EX6 {
    public static void main(String[] args) {
        int sum = 0;
        int total = 0;
        for (int i = 1; i <= 100; i++) {
            sum +=i;
            total += sum;
        }
        System.out.println(total);
    }
}

171700

肿么啦！

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
二、运算符与程序控制结构

一、运算符（一）算数运算符（二）关系运算符（比较运算符）（三）逻辑运算符（四）赋值运算符（五）三元运算符（六）运算符优先级（七）二进制和位运算（1）进制转换（2）原码、反码、补码二、程序控制结构（一）顺序控制（二）分支控制（if、else、switch）1. 单分支-if：2. 双分支 if - else：3. 多分支 if - else if - else ：4. 嵌套分支5. switch分支结构（三）循环控制（for、while、do while、多重循环）1
复制链接

扫一扫