1 算术运算符介绍

Java支持5种算术运算符

1. 加法（+）
2. 减法（-）
3. 乘法（*）
4. 除法（/）：被除数 / 除数 = 商数 求商数
5. 取余（%）：被除数 / 除数 = 商数…余数 求余数

取余的应用场景

1. 判断一个数A，是否可以被另外一个数B整除，如果A对B进行取余运算，结果为0，那么就表示A能够被B整除
2. 判断一个数字A是奇数还是偶数，也就是拿这个数A对2进行取余运算，如果结果为0表示这个数是一个偶数，否则就是一个奇数

取余的公式：a % b = a - (a / b ) * b

2 算术运算符使用

1. 编辑ArithmeticOperator.java

package net.ittimeline.java.core.foundational.operator.arithmetic;

/**
 * 算术运算符使用
 *
 * @author tony 18601767221@163.com
 * @version 2024/10/16 9:17
 * @since Java21
 */
public class ArithmeticOperator {
    public static void main(String[] args) {
        System.out.println("1.算术运算符操作整数字面量");
        System.out.println("3 + 5 = " + (3 + 5));
        System.out.println("20 - 12 = " + (20 - 12));
        System.out.println("2 * 4 = " + (2 * 4));
        //被除数 / 除数 = 商数
        System.out.println("80 / 10 = " + (80 / 10));
        //操作数可以有多个
        System.out.println("12 / 5 * 5 = " + (12 / 5 * 5));
        //取余的公式： a % b = a - (a / b )* b
        //12 -(12 / 5) *5 =12 - 2 * 5 =12 - 10 = 2
        System.out.println("12 % 5 = " + (12 % 5));

        System.out.println("2. 算术运算符操作整数变量");
        int left = 20;
        int right = 3;
        //第一个%d会被left替换
        //第二个%d会被right替换
        //第三个%d会被left + right的结果替换
        System.out.printf("%d + %d = %d\n", left, right, (left + right));
        System.out.printf("%d - %d = %d\n", left, right, (left - right));
        System.out.printf("%d * %d = %d\n", left, right, (left * right));
        //被除数 / 除数 = 商数
        System.out.printf("%d / %d = %d\n", left, right, (left / right));
        System.out.printf("%d / %d * %d = %d\n", left, right, right, (left / right * right));
        //被除数 / 除数 = 商数...余数 求余数
        // %%表示%
        System.out.printf("%d %% %d = %d\n", left, right, (left % right));
    }
}

2. 运行ArithmeticOperator.java

程序运行结果

3 算术运算符使用注意事项

3.1 算术运算符使用注意事项1

在使用加法（+）时可能会遇到以下三种情况

1. 数字相加：如果+左右两边是数字就进行加法运算，数字在进行运算是，数据类型不一样是不能进行运算的，需要转成一样的才能运算。
2. 字符串相加：如果+左右两边有一边是字符串，那么就进行字符串拼接运算并产生一个新的字符串，如果有多个+操作时，会从左到右逐个执行
3. 字符相加：如果+左右两边都是是字符或者是字符+数字时，那么就按照字符的ASCII值进行加法运算

1. 编辑ArithmeticOperatorWarning1.java

package net.ittimeline.java.core.foundational.operator.arithmetic;

/**
 * 算术运算符使用注意事项1
 * 在使用加法（+）时可能会遇到以下三种情况
 * 1. 数字相加：如果+左右两边是数字就进行加法运算,数字在进行运算是,数据类型不一样是不能进行运算的,需要转成一样的才能运算。
 * 2. 字符串相加：如果+左右两边有一边是字符串,那么就进行字符串拼接运算并产生一个新的字符串,如果有多个+操作时,会从左到右逐个执行
 * 3. 字符相加：如果+左右两边都是是字符或者是字符+数字时,那么就按照字符的ASCII进行加法运算
 *
 * @author tony 18601767221@163.com
 * @version 2024/10/16 9:44
 * @since Java21
 */
public class ArithmeticOperatorWarning1 {
    public static void main(String[] args) {
        //加法操作的三种情况
        System.out.println("1.数字相加");
        int left = 10;
        double right = 20.3;
        //int和double进行运算 int会自动提升为double 结果类型是double类型
        double result = left + right;
        // %d会被整数类型变量left的值替换
        // %.1f会被浮点类型变量right的值替换
        // %.1f会被浮点类型变量result的值替换
        System.out.printf("%d + %.1f  = %.1f\n", left, right, result);

        System.out.println("2.字符串拼接");
        //第一个加法表示数字相加,因为加法左右两边都是数字
        //第二个加法表示字符串拼接,因为加法右边有字符串
        System.out.println(1 + 99 + "年树人");
        String name = "tony";
        System.out.println("姓名是" + name);
        int age = 30;
        //age会被30替换
        System.out.println("年龄是" + age + "岁");
        double height = 180.00;
        //height会被180.00替换
        System.out.println("身高是" + height + "厘米");

        System.out.println("3.字符相加");
        // a的ASCII值是97
        System.out.println("1 + 'a' = " + (1 + 'a'));
        //0的ASCII值是48
        System.out.println("1 + '0' = " + (1 + '0'));
        //A的ASCII值是65
        System.out.println("1 + 'A' = " + (1 + 'A'));
        //a的ASCII值是97
        //b的ASCII值是98
        System.out.println("'a' + 'b ' = " + ('a' + 'b'));
    }
}

2. 运行ArithmeticOperatorWarning1.java

程序运行结果

3.2 算术运算符使用注意事项2

两个整数相加、相乘，结果超过了该类型的表示范围，就会发生溢出，导致结果不正确。在处理大数值时，可以考虑使用long类型

1. 编辑ArithmeticOperatorWarning2.java

package net.ittimeline.java.core.foundational.operator.arithmetic;

/**
 * 算术运算符使用注意事项2
 * 两个整数相加、相乘，结果超过了该类型的表示范围，就会发生溢出，导致结果不正确。在处理大数值时，可以考虑使用long类型
 *
 * @author tony 18601767221@163.com
 * @version 2024/10/16 9:46
 * @since Java21
 */
public class ArithmeticOperatorWarning2 {
    public static void main(String[] args) {
        int maxValue = 0x7fffffff;
        System.out.println("int所能存储的最大值是" + maxValue);
        //当两个整数相加、相乘，结果超过了该类型的表示范围，就会发生溢出。
        int intSum = maxValue + 1;
        //导致结果不正确
        System.out.println("intSum = " + intSum);
        //在处理大数值时，可以考虑使用long类型
        //方式1：将整数字面量1提升为long类型
        long longSumWay1 = maxValue + 1L;
        System.out.println("longSumWay1 = " + longSumWay1);
        //方式2：将maxValue强制转换为long类型
        long longSumWay2 = (long) maxValue + 1;
        System.out.println("longSumWay2 = " + longSumWay2);
    }
}

2. 运行ArithmeticOperatorWarning2.java

程序运行结果

3.3 算术运算符使用注意事项3

当两个整数进行除法运算的时候运算结果只会保留整数部分，丢弃小数部分，如果想要保留除法运算结果的小数部分，有如下两种方式

①可以使用强制类型转换将其中一个操作数转成double

②将其中一个操作数乘以1.0后再进行运算

1. 编辑ArithmeticOperatorWarning3.java

package net.ittimeline.java.core.foundational.operator.arithmetic;

/**
 * 算术运算符使用注意事项3
 * 当两个整数进行除法运算的时候运算结果只会保留整数部分，丢弃小数部分，如果想要保留除法运算结果的小数部分，有如下两种方式
 * ①可以使用强制类型转换将其中一个操作数转成double
 * ②将其中一个操作数乘以1.0后再进行运算
 *
 * @author tony 18601767221@163.com
 * @version 2024/10/16 9:48
 * @since Java21
 */
public class ArithmeticOperatorWarning3 {
    public static void main(String[] args) {
        // 12 / 5 = 2.4 但是运算结果只会保留整数部分，因此运算结果是2
        System.out.println("12 / 5 = " + (12 / 5));
        int left = 12;
        int right = 5;
        //将整数类型变量left提升为double类型后再进行运算，double和int运算结果的类型是double
        double result = (double) left / right;
        System.out.println("result = " + result);
        System.out.println("12 / (double)5= " + (12 / (double) 5));
        //将12*1.0再进行运算
        System.out.println("12 * 1.0 / 5 = " + (12 * 1.0 / 5));
    }
}

2. 运行ArithmeticOperatorWarning3.java

程序运行结果

3.4 算术运算符使用注意事项4

只要有小数参与算术运算，那么运算的结果可能是不精确的

1. 编辑ArithmeticOperatorWarning4.java

package net.ittimeline.java.core.foundational.operator.arithmetic;

/**
 * 算术运算符使用注意事项4
 * 只要有小数参与算术运算，那么运算的结果可能是不精确的
 * @author tony 18601767221@163.com
 * @version 2024/10/16 9:50
 * @since Java21
 */
public class ArithmeticOperatorWarning4 {
    public static void main(String[] args) {
        //①计算结果精确
        System.out.println("1.1 + 1.1 = " + (1.1 + 1.1));
        //②计算结果不精确
        System.out.println("1.1 + 1.01 = " + (1.1 + 1.01));
        System.out.println("1.1 - 1.01 = " + (1.1 + 1.01));
        System.out.println("操作数是浮点类型字面量：2.0 - 1.1 = " + (2.0 - 1.1));
        double left = 2.0;
        double right = 1.1;
        double result = left - right;
        System.out.println("操作数是浮点类型变量：2.0 - 1.1 = " + result);
    }
}

2. 运行ArithmeticOperatorWarning4.java

程序运行结果

3.5 算术运算符使用注意事项5

除法运算时除数不能是0，否则会发生ArithmeticException算术异常

1. 编辑ArithmeticOperatorWarning5.java

package net.ittimeline.java.core.foundational.operator.arithmetic;

/**
 * 算术运算符使用注意事项5
 * 除法运算时除数不能是0，否则会发生ArithmeticException算术异常
 *
 * @author tony 18601767221@163.com
 * @version 2024/10/16 9:51
 * @since Java21
 */
public class ArithmeticOperatorWarning5 {
    public static void main(String[] args) {
        int left = 20;
        int right = 0;
        int result = left / right;
        System.out.println("result = " + result);
    }
}

2. 运行ArithmeticOperatorWarning5.java

程序运行结果

3.6 算术运算符使用注意事项6

取余运算结果的符号（正号、负号）与被除数相同

1. 编辑ArithmeticOperatorWarning6.java

package net.ittimeline.java.core.foundational.operator.arithmetic;

/**
 * 算术运算符使用注意事项6
 * 取余运算结果的符号（正号、负号）与被除数相同
 *
 * @author tony 18601767221@163.com
 * @version 2024/10/16 9:52
 * @since Java21
 */
public class ArithmeticOperatorWarning6 {
    public static void main(String[] args) {
        //被除数 / 除数 = 商数...余数
        //取余（求余数）的结果正负号和被除数（被模数）是一样的
        System.out.println("1.取余运算,被除数的符号是负号");
        int left = -12;
        int right = 5;
        int result = left % right;
        //格式化输出算术运算计算结果
        //第一个%d会被left的值替换
        //第二个%d会被right的值替换
        //第三个%d会被result的值替换
        //%%表示%
        System.out.printf("%d %% %d = %d\n", left, right, result);

        System.out.println("2.取余运算,被除数的符号是正号");
        left = 12;
        right = -5;
        result = left % right;
        //%%表示%
        System.out.printf("%d %% %d = %d\n", left, right, result);

        System.out.println("3.取余运算,被除数的符号是负号");
        left = -12;
        right = -5;
        result = left % right;
        //%%表示%
        System.out.printf("%d %% %d = %d\n", left, right, result);
    }
}

2. 运行ArithmeticOperatorWarning6.java

程序运行结果

4 算术运算符案例

4.1 数值拆分

需求：键盘输入一个三位整数，将其拆分为个位、十位、百位后，打印输出

分析：如何获取个位、十位、百位甚至是千位、万位

个位：数值 / 1 % 10
十位：数值 / 10 % 10
百位：数值 / 100 % 10
千位：数值 / 1000 % 10
万位：数值 / 10000 % 10

1. 编辑NumericalSplit.java

package net.ittimeline.java.core.foundational.operator.arithmetic;

import java.util.Scanner;

/**
 * 数值拆分
 * 分析：获取个位、十位、百位甚至是千位、万位的方法
 * 个位：数值 / 1 % 10
 * 十位：数值 / 10 % 10
 * 百位：数值 / 100 % 10
 * 千位：数值 / 1000 % 10
 * 万位：数值 / 10000 % 10
 *
 * @author tony 18601767221@163.com
 * @version 2024/10/16 9:54
 * @since Java21
 */
public class NumericalSplit {
    public static void main(String[] args) {
        //创建Scanner对象
        //System.in表示标准输入,也就是键盘输入
        //Scanner对象可以扫描用户从键盘输入的数据
        Scanner scanner = new Scanner(System.in);
        //提升用户从键盘输入一个三位整数：大于等于100,小于1000的整数
        System.out.println("请输入一个三位整数：大于等于100,小于1000的整数");
        int number = scanner.nextInt();
        //获取三位整数的个位、十位、百位
        int unit = number / 1 % 10;
        int decade = number / 10 % 10;
        int hundred = number / 100 % 10;
        System.out.printf("你输入的整数是%d\n其中个位数是%d,十位数是%d,百位数是%d\n",
                number, unit, decade, hundred);
        //关闭Scanner
        scanner.close();
    }
}

2. 运行NumericalSplit.java

程序运行结果

4.2 整数反转

需求：键盘输入一个三位整数，使用算术运算符实现三位整数反转，例如678反转以后就是876
分析：

① 参考数值拆分案例获取三位整数的个位、十位、百位

② 三位数反转的计算公式：个位 * 100 + 十位 * 10 + 百位

1. 编辑NumericalReversal.java

package net.ittimeline.java.core.foundational.operator.arithmetic;

import java.util.Scanner;

/**
 * 整数反转
 * 分析：
 * ① 参考数值拆分案例获取三位整数的个位、十位、百位
 * ② 三位数反转的计算公式：个位 * 100 + 十位 * 10 + 百位
 * @author tony 18601767221@163.com
 * @version 2024/10/16 9:59
 * @since Java21
 */
public class NumericalReversal {
    public static void main(String[] args) {
        //创建Scanner对象
        //System.in表示标准输入,也就是键盘输入
        //Scanner对象可以扫描用户从键盘输入的数据
        Scanner scanner = new Scanner(System.in);
        //提升用户从键盘输入一个三位整数：大于等于100,小于1000的整数
        System.out.println("请输入一个三位整数：大于等于100,小于1000的整数");
        int number = scanner.nextInt();
        //获取三位整数的个位、十位、百位
        int unit = number / 1 % 10;
        int decade = number / 10 % 10;
        int hundred = number / 100 % 10;
        //计算反转后的结果
        int reversalNumber = unit * 100 + decade * 10 + hundred;
        System.out.printf("你输入的整数是%d,反转以后的结果是%d\n", number, reversalNumber);
        //关闭Scanner
        scanner.close();
    }
}

2. 运行NumericalReversal.java

程序运行结果

4.3 温度转换

需求：根据用户输入的华氏温度转换成对应的摄氏温度，华氏温度转换为摄氏温度的公式是 5 / 9 *(华氏温度 - 32 )

分析：华氏温度转换为摄氏温度的公式中5 / 9在Java的运算结果是0，0乘以任何数都是0，应该将5 / 9 换成 5.0 / 9

1. 编辑Fahrenheit2CentigradeDegree.java

package net.ittimeline.java.core.foundational.operator.arithmetic;

import java.util.Scanner;

/**
 * 温度转换
 * 需求：根据用户输入的华氏温度转换成对应的摄氏温度,华氏温度转换为摄氏温度的公式是 5 / 9 *(华氏温度 - 32 )
 * 分析：华氏温度转换为摄氏温度的公式中5 / 9在Java的运算结果是0,0乘以任何数都是0,应该将5 / 9 换成 5.0 / 9
 *
 * @author tony 18601767221@163.com
 * @version 2024/10/16 10:06
 * @since Java21
 */
public class Fahrenheit2CentigradeDegree {
    public static void main(String[] args) {
        //创建Scanner对象
        //System.in表示标准输入,也就是键盘输入
        //Scanner对象可以扫描用户从键盘输入的数据
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入加利福尼亚州的死亡谷在1913年7月10日记录到的高温");
        //加利福尼亚州的死亡谷在1913年7月10日记录到了53.9°C（129°F）的高温,这是官方认可的世界最高气温记录
        double fahrenheit = scanner.nextDouble();
        double centigradeDegree = 5.0 / 9 * (fahrenheit - 32);
        System.out.println("华氏温度" + fahrenheit + "转换为摄氏温度的结果是" + centigradeDegree);
        //格式化输出 %.1f 表示保留小数点后1位数
        System.out.printf("华氏温度%.1f转换为摄氏温度的结果是%.1f\n", fahrenheit, centigradeDegree);

        //关闭Scanner
        scanner.close();
    }
}

2. 运行Fahrenheit2CentigradeDegree.java

程序运行结果

4.4 天数换算

需求：根据用户输入的天数换算成星期数，例如用户输入59天是8个星期零3天

分析：

用户输入的天数 / 7 计算的结果就是星期数

用户输入的天数 % 7计算的结果就是剩下的天数

① 求星期数 59 / 7= 8

②求天数 59 % 7 = 3

1. 编辑DaysConversionWeek.java

package net.ittimeline.java.core.foundational.operator.arithmetic;

import java.util.Scanner;

/**
 * 天数换算
 * 需求：根据用户输入的天数换算成星期数,例如用户输入59天是8个星期零3天
 * 分析：
 * 用户输入的天数 / 7 计算的结果就是星期数
 * 用户输入的天数 % 7计算的结果就是剩下的天数
 *
 * @author tony 18601767221@163.com
 * @version 2024/10/16 10:10
 * @since Java21
 */
public class DaysConversionWeek {
    public static void main(String[] args) {
        //创建Scanner对象
        //System.in表示标准输入,也就是键盘输入
        //Scanner对象可以扫描用户从键盘输入的数据
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入天数");
        int days = scanner.nextInt();
        //天数换算为星期数（几周）
        int week = days / 7;
        //天数换算为星期数（几周）后剩下的天数
        int remainingDay = days % 7;
        System.out.printf("%d天转换为星期的结果是%d个星期零%d天\n", days, week, remainingDay);
        //关闭Scanner
        scanner.close();
    }
}

2. 运行DaysConversionWeek.java

程序运行结果

4.5 小时换算

需求：根据用户输入的小时换算成多少天零多少小时，例如用户输入12小时换算成0天零12小时，用户输入89小时换算成3天零17小时

分析：

用户输入的小时 / 24计算的结果就是天数

用户输入的小时 % 24计算的结果就是剩下的小时

① 89 / 24 = 3

② 89 % 24 = 17

1. 编辑HoursConversionDays.java

package net.ittimeline.java.core.foundational.operator.arithmetic;

import java.util.Scanner;

/**
 * 小时换算
 * 需求：根据用户输入的小时换算成多少天零多少小时,例如用户输入12小时换算成0天零12小时,用户输入89小时换算成3天零17小时
 * 分析：
 * 用户输入的小时 / 24计算的结果就是天数
 * 用户输入的小时 % 24计算的结果就是剩下的小时
 * ① 89 / 24 = 3
 * ② 89 % 24 = 17
 *
 * @author tony 18601767221@163.com
 * @version 2024/10/16 10:22
 * @since Java21
 */
public class HoursConversionDays {
    public static void main(String[] args) {
        //创建Scanner对象
        //System.in表示标准输入,也就是键盘输入
        //Scanner对象可以扫描用户从键盘输入的数据
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入小时数");
        int hours = scanner.nextInt();

        //用户输入的小时 / 24计算的结果就是天数
        int days = hours / 24;
        //用户输入的小时 % 24计算的结果就是小时
        int remainingHours = hours % 24;
        System.out.printf("你输入的小时数是%d小时,换算成%d天零%d小时\n", hours, days, remainingHours);

        //关闭Scanner
        scanner.close();
    }
}

2. 运行HoursConversionDays.java

程序运行结果

4.6 秒数换算

需求：根据用户输入的秒数计算出对应的时分秒，假设用户输入的秒数是3800，3800秒对应的时间是1时3分20秒

分析：如何转换小时、分钟、秒数？

小时=输入的秒数/3600
分钟=输入的秒数%3600/60
秒钟=输入的秒数%60

1. 编辑SecondConversionTime.java

package net.ittimeline.java.core.foundational.operator.arithmetic;

import java.util.Scanner;

/**
 * 秒数换算
 * 需求：根据用户输入的秒数计算出对应的时分秒，假设用户输入的秒数是3800，3800秒对应的时间是1时3分20秒
 * 分析：如何转换小时、分钟、秒数？
 * <p>
 * 转换小时、分钟、秒数的方法
 * 小时=输入的秒数/3600
 * 分钟=输入的秒数%3600/60
 * 秒钟=输入的秒数%60
 *
 * @author tony 18601767221@163.com
 * @version 2024/10/16 10:24
 * @since Java21
 */
public class SecondConversionTime {
    public static void main(String[] args) {
        //创建Scanner对象
        //System.in表示标准输入，也就是键盘输入
        //Scanner对象可以扫描用户从键盘输入的数据
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入秒数");
        int inputSecond = scanner.nextInt();

        int hours = inputSecond / 3600;
        int minutes = inputSecond % 3600 / 60;
        int seconds = inputSecond % 60;
        System.out.printf("你输入的秒数是%d秒，对应的时间是%d小时%d分钟%d秒\n",
                inputSecond, hours, minutes, seconds);
        //关闭Scanner
        scanner.close();
    }
}

2. 运行SecondConversionTime.java

程序运行结果