第七章运算符

作者：张子默

一、算术运算符

算术运算符	操作
`+`	加法运算，字符串连接运算
`-`	减法运算
`*`	乘法运算
`/`	除法运算
`%`	取模运算，两个数字相除取余数
`++` 、 `--`	自增自减运算符

Java中，整数使用以上运算符，无论怎么计算，也不会得到小数。

public static void main(String[] args) {
     int i = 1234;
     System.out.println(i/1000*1000);//计算结果是1000
 }

1、自增自减运算符

++

运算，变量自己增长1。反之，

--

运算，变量自己减少1，用法与

++

一致。

1）独立运算

变量在独立运算时， 前++ 和 后++ 没有区别。
变量 前++ ：例如 ++i 。
变量 后++ ：例如 i++ 。

2）混合运算

和其他变量放在一起， 前++ 和 后++ 就产生了不同。
变量 前++ ：变量a自己加1，将加1后的结果赋值给b，也就是说a先计算。a和b的结果都是2。

public static void main(String[] args) {
     int a = 1;
     int b = ++a;
     System.out.println(a);//计算结果是2
     System.out.println(b);//计算结果是2
 }

变量 后++ ：变量a先把自己的值1，赋值给变量b，此时变量b的值就是1，变量a自己再加1。a的结果是2，b的结果是1。

public static void main(String[] args) {
     int a = 1;
     int b = a++;
     System.out.println(a);//计算结果是2
     System.out.println(b);//计算结果是1
 }

2、 `+` 符号在字符串中的操作

+ 符号在遇到字符串的时候，表示连接、拼接的含义。
"a" + "b"的结果是"ab"，连接含义

public static void main(String[] args){
     System.out.println("5+5="+5+5);//输出5+5=55
 }

二、赋值运算符

赋值运算符就是将符号右边的值赋给左边的变量。

赋值运算符	操作
`=`	等于号
`+=`	加等于
`-=`	减等于
`*=`	乘等于
`/=`	除等于
`%=`	取模等

public static void main(String[] args){
     int i = 5;
     i+=5;//计算方式 i=i+5 变量i先加5，再赋值变量i
     System.out.println(i); //输出结果是10
 }

三、比较运算符

比较运算符是两个数据之间进行比较的运算符，运算结果都是布尔值

true

或

false

。

比较运算符	操作
`==`	比较符号两边数据是否相等，相等结果为true
`<`	比较符号左边的数据是否小于右边的数据，如果小于结果是true
`>`	比较符号左边的数据是否大于右边的数据，如果大于结果是true
`<=`	比较符号左边的数据是否小于或者等于右边的数据，如果小于或者等于结果是true
`>=`	比较符号左边的数据是否大于或等于右边的数据，如果大于或者等于结果是true
`!=`	不等于符号，如果符号两边的数据不相等，结果是true

public static void main(String[] args) {
     System.out.println(1==1);//true
     System.out.println(1<2);//true
     System.out.println(3>4);//false
     System.out.println(3<=4);//true
     System.out.println(3>=4);//false
     System.out.println(3!=4);//true
 }

四、逻辑运算符

逻辑运算符是用来连接两个布尔类型结果的运算符，运算结果都是布尔值

true

或者

false

逻辑运算符	操作
`&&` 短路与	1、两边都是true，结果是true 2、一边是false，结果是false 短路特点：符号左边是false，右边不再运算
`\|\|` 短路或	1、两边都是false，结果是false 2、一边是true，结果是true 短路特点：符号左边是true，右边不再运算
`!` 取反	1、!true结果是false 2、!false结果是true

public static void main(String[] args) {
     System.out.println(true && true);//true
     System.out.println(true && false);//false
     System.out.println(false && true);//false，右边不计算
     System.out.println(false || false);//falase
     System.out.println(false || true);//true
     System.out.println(true || false);//true，右边不计算
     System.out.println(!false);//true
 }

五、三元运算符

1、三元运算符格式

变量类型 变量名 = 条件判断 ? 表达式A : 表达式B;

2、三元运算符计算方式

条件判断结果是true，三元运算符整体结果为表达式A，赋值给变量。
条件判断结果是false，三元运算符整体结果为表达式B，赋值给变量。

public static void main(String[] args) {
    int i = (1==2 ? 100 : 200);
    System.out.println(i);//200
    int j = (3<=4 ? 500 : 600);
    System.out.println(j);//500
}

六、实例

算术运算符

/*
运算符：进行特定操作的符号，例如：+
表达式：用运算符连起来的式子叫做表达式。例如：20 + 5。又例如：a + b

四则运算：
加：+
减：-
乘：*
除：/

取模(取余数)：%

首先计算得到表达式的结果，然后再打印输出这个结果。
复习一下小学二年级的除法公式：
被除数 / 除数 = 商 ... 余数

对于一个整数的表达式来说，除法用的是整除，整数除以整数，结果仍然是整数。只看商不看余数。
只有对于整数的除法来说，取模运算符才有余数的意义。

注意事项：
    一旦运算当中由不同类型的数据，那么结果将会是数据类型范围大的那种。
 */
public class Demo04Operator {
    public static void main(String[] args) {
        // 两个常量之间可以进行数学运算
        System.out.println(20 + 30); // 50

        // 两个变量之间也可以进行数学运算
        int a = 20;
        int b = 5;
        System.out.println(a - b); // 15

        // 变量和常量之间可以混合使用
        System.out.println(a * 10); // 200

        int x = 10;
        int y = 3;

        int result = x / y;
        System.out.println(result); // 3

        int result2 = x % y;
        System.out.println(result2); // 1

        // int + double --> double + double --> double
        double result3 = x + 2.5;
        System.out.println(result3); // 12.5
    }
}

+ 符号的用法

package com.zzm.day02;

/**
 * 用途：
 * 时间：2021/5/13 15:12
 * 创建人：张子默
 */

/*
四则运算当中的加号"+"有常见的三种用法：

1.对于数值来说，那就是加法。
2.对于字符char类型来说，在计算之前，char会被提升为int，然后再计算。char类型字符和int类型数字之间的对照关系表：ASCII、Unicode
3.对于字符串String(首字母大写，并不是关键字)来说，加号代表字符串连接操作。任何数据类型和字符串进行连接的时候，结果都会变成字符串。
 */
public class Demo05Plus {
    public static void main(String[] args) {
        // 字符串类型的变量基本使用
        // 数据类型 变量名称 = 数据值;
        String str1 = "Hello";
        System.out.println(str1); // Hello

        System.out.println("Hello" + " World"); // Hello World

        String str2 = "Java";
        System.out.println(str2 + 20); // Java20

        // 优先级问题
        // String + int + int
        // String       + int
        // String
        System.out.println(str2 + 20 + 30); // Java2030
        System.out.println(str2 + (20 + 30)); // Java50
        System.out.println(20 + 30 + str2); // 50Java
    }
}

自增自减运算符

package com.zzm.day02;

/**
 * 用途：
 * 时间：2021/5/13 15:28
 * 创建人：张子默
 */

/*
自增运算符：++
自减运算符：==

基本含义：让一个变量涨一个数字1，或者让一个变量降一个数字1
使用格式：写在变量名之前或者写在变量名之后。例如：++num，也可以num++
使用方式：
    单独使用：不和其他任何操作混合，自己独立成为一个步骤。
    混合使用：和其他操作混合，例如与赋值操作混合或者与打印操作混合等。
使用区别：
    在单独使用的时候，前++和后++没有任何区别，也就是说：++num;和num++;是完全一样的。
    在混合使用的时候，有【重大区别】
        如果是【前++】，那么变量【立刻马上+1】，然后拿着结果进行使用。       【先加后用】
        如果是【后++】，那么首先使用变量本来的数值，【然后再让变量+1】。      【先用后加】
注意事项：
    只有变量才能使用自增、自减运算符。常量不可发生改变，所以不能用。
 */
public class Demo06Operator {
    public static void main(String[] args) {
        int num1 = 10;
        System.out.println(num1); // 10
        ++num1; // 单独使用，前++
        System.out.println(num1); // 11
        num1++; // 单独使用，后++
        System.out.println(num1); // 12
        System.out.println("===============");

        // 与打印语句混合的时候
        int num2 = 20;
        // 混合使用，先++，变量立刻马上变成21，然后打印结果21
        System.out.println(++num2); // 21
        System.out.println(num2); // 21
        System.out.println("===============");

        int num3 = 30;
        // 混合使用，后++，首先使用变量本来的30，然后再让变量+1得到31
        System.out.println(num3++); // 30
        System.out.println(num3); // 31
        System.out.println("===============");

        int num4 = 40;
        // 和赋值操作混合
        int result1 = --num4; // 混合使用，前--，变量立刻马上-1变成39，然后将结果39交给result1变量
        System.out.println(result1); // 39
        System.out.println(num4); // 39
        System.out.println("===============");

        int num5 = 50;
        // 混合使用，后--，首先把本来的数字50交给result2，然后我自己再-1变成49
        int result2 = num5--;
        System.out.println(result2); // 50
        System.out.println(num5); // 49
        System.out.println("===============");

        int x = 10;
        int y = 20;
        // 11 + 20 = 31
        int result3 = ++x + y--;
        System.out.println(result3); // 31
        System.out.println(x); // 11
        System.out.println(y); // 19

        // 30++; // 错误写法！常量不可以使用++或者--
    }
}

赋值运算符

package com.zzm.day02;

/**
 * 用途：
 * 时间：2021/5/13 16:52
 * 创建人：张子默
 */

/*
赋值运算符分为：

基本赋值运算符：就是一个"="，代表将右侧的数据交给左侧的变量。
    int a = 30;

复合赋值运算符：
    +=      a += 1      相当于     a = a + 1
    -=      b -= 4      相当于     b = b - 4
    *=      c *= 5      相当于     c = c * 5
    /=      d /= 6      相当于     d = d / 6
    %=      e %= 7      相当于     e = e % 7

注意事项：
    只有变量才能使用赋值运算符，常量不能进行赋值。
    复合赋值运算符其中隐含了一个强制类型转换
 */
public class Demo07Operator {
    public static void main(String[] args) {
        int a = 10;
        // 按照公式进行翻译：a = a + 5;
        // a = 10 + 5;
        // a = 15;
        // a本来是10，现在重新赋值得到15
        a += 5;
        System.out.println(a); // 15

        int x = 10;
        // x = x % 3;
        // x = 10 % 3;
        // x = 1;
        // x本来是10，现在重新赋值得到1
        x %= 3;
        System.out.println(x); // 1

        // 50 = 30; // 常量不能进行赋值，不能写在赋值运算符的左边。错误写法！

        byte num = 30;
        // num = num + 5;
        // num = byte + int;
        // num = int + int;
        // num = int;
        // num = (byte) int;
        num += 5;
        System.out.println(num); // 35
    }
}

比较运算符

package com.zzm.day02;

/**
 * 用途：
 * 时间：2021/5/13 17:50
 * 创建人：张子默
 */

/*
比较运算符：
大于：     >
小于：     <
大于等于： >=
小于等于： <=
相等：     ==      【两个等号连写才是相等，一个等号代表的是赋值】
不相等：   !=

注意事项：
    比较运算符的结果一定是一个boolean值，成立就是true，不成立就是false
    如果进行多次判断，不能连着写
    数学当中的写法，例如：1 < x < 3
    程序当中【不允许】这种写法。
 */
public class Demo08Operator {
    public static void main(String[] args) {
        System.out.println(10 > 5); // true

        int num1 = 10;
        int num2 = 12;
        System.out.println(num1 < num2); // true

        System.out.println(num2 >= 100); // false
        System.out.println(num2 <= 12); // true
        System.out.println("===============");

        System.out.println(10 == 10); // true
        System.out.println(20 != 25); // true
        System.out.println(20 != 20); // false

        int x = 2;
        // System.out.println(1 < x < 3); // 错误写法！编译报错！不能连着写！
    }
}

逻辑运算符

package com.zzm.day02;

/**
 * 用途：
 * 时间：2021/5/13 18:59
 * 创建人：张子默
 */

/*
与(并且)       &&      全都是true，才是true；否则就是false
或(或者)       ||      至少一个是true，就是true；全都是false，才是false
非(取反)       !       本来是true，变成false；本来是false，变成true

与"&&"，或"||"，具有短路效果：如果根据左边已经可以判断得到最终结果，那么右边的代码不再执行，从而节省一定的性能。

注意事项：
    逻辑运算符只能用于boolean值。
    与、或需要左右各有一个boolean值，但是取反只要有唯一的一个boolean值即可。
    与、或两种运算符，如果有多个条件，可以连续写。
        两个条件：条件A && 条件B
        多个条件：条件A && 条件B && 条件C

TIPS：
    对于1 < x < 3的情况，应该拆成两个部分，然后使用与运算符连接起来。
    int x = 2;
    1 < x && x < 3
 */
public class Demo09Operator {
    public static void main(String[] args) {
        System.out.println(true && false); // false

        // true && true --> true
        System.out.println(3 < 4 && 10 > 5); // true
        System.out.println("===============");

        System.out.println(true || false); // true
        System.out.println(true || true); // true
        System.out.println(false || false); // false
        System.out.println("===============");

        System.out.println(true); // true
        System.out.println(!true); // false
        System.out.println("===============");

        int a = 10;
        // false && ...
        System.out.println(3 > 4 && ++a < 100); // false
        System.out.println(a);
        System.out.println("===============");

        int b = 20;
        // true || ...
        System.out.println(3 < 4 || ++b < 100); // true
        System.out.println(b);
    }
}

三元运算符

package com.zzm.day02;

/**
 * 用途：
 * 时间：2021/5/13 19:27
 * 创建人：张子默
 */

/*
一元运算符：只需要一个数据就可以进行操作的运算符。例如：取反!、自增++、自减--
二元运算符：需要两个数据才可以进行操作的运算符。例如：加法+、赋值=
三元运算符：需要三个数据才可以进行操作的运算符

格式：
    数据类型 变量名称 = 条件判断 ？ 表达式A : 表达式B;

流程：
    首先判断条件是否成立：
        如果成立为true，那么将表达式A的值赋值给左侧的变量；
        如果不成立为false，那么将表达式B的值赋值给左侧的变量；
    二者选其一。

注意事项：
    必须同时保证表达式A和表达式B都符合左侧数据类型的要求。
    三元运算符的结果必须被使用。
 */
public class Demo10Operator {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;

        // 数据类型 变量名称 = 条件判断 ？ 表达式A : 表达式B;
        // 判断a > b是否成立，如果成立将a的值赋值给max；如果不成立将b的值赋值给max，二者选其一
        int max = a > b ? a : b; // 最大值的变量
        System.out.println("最大值：" + max); // 20

        // int result = 3 > 4 ? 2.5 : 10; // 错误写法！

        System.out.println(a > b ? a : b); // 正确写法！

        // a > b ? a : b; // 错误写法！
    }
}

2021-09-19第七章运算符

第七章运算符

作者：张子默

一、算术运算符

1、自增自减运算符

2、 `+` 符号在字符串中的操作

二、赋值运算符

三、比较运算符

四、逻辑运算符

五、三元运算符

1、三元运算符格式

2、三元运算符计算方式

六、实例

继续阅读

Java小案例——随机数猜测随机数猜测

nginx location中斜线的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的简单使用

neo4j之cypher使用文档

GitHub连夜封杀！这份阿里 10W 字内部 Java 字面试手册到底有多强？

spark/scala关于【资源文件】加载方法概述外部文件加载方案测试资源文件打包入jar包中小结

mybatis_入门程序Mybatis入门

AOP编程_Android优雅权限框架(1)概念基础，2021金三银四前言正文大纲正文

Effective Java 8:通用程序设计

OOM三种类型

工厂模式-三种类型

【递归】高效率求2的n次幂

express 搭建后台构建工程目录结构

win10本地scala和spark安装安装scala安装spark

scala (3) Function 和 Method

2021-09-19第七章 运算符

第七章 运算符

作者：张子默

一、算术运算符

1、自增自减运算符

2、 + 符号在字符串中的操作

二、赋值运算符

三、比较运算符

四、逻辑运算符

五、三元运算符

1、三元运算符格式

2、三元运算符计算方式

六、实例

继续阅读

2021-09-19第七章运算符

第七章运算符

2、 `+` 符号在字符串中的操作