【原】Java学习笔记004 - 运算符

 package cn.temptation;
 
 public class Sample01 {
     public static void main(String[] args) {
         // 运算符：对常量 或是 变量进行操作的符号
         // 分为：算术运算符、赋值运算符、比较运算符、逻辑运算符、位运算符
 
         // 1、算术运算符：+、-、*、/、%、++、--
         int i = 7;
         int j = 2;
 
         System.out.println(i + j);        //
         System.out.println(i - j);        //
         System.out.println(i * j);        // 14
         // int类型的变量 和 int类型的变量做除法，得到的结果是int类型
         System.out.println(i / j);        // 3
 
         // 要求：就想得到3.5的结果，怎么办？
         // 下面的写法不会得到3.5的结果，只会得到3.0的结果，因为只是声明了一个double类型的变量来接收int类型变量和int类型变量相除的结果
         // 对于相除的结果没有内容上的影响
         double result = i / j;
         System.out.println(result);                // 3.0
         System.out.println((double)(i / j));    // 3.0
 
         // 做一个尝试：使用double类型的字面量常量 和 int类型的字面量常量做除法，会得到double类型的字面量常量
         //                 即int类型的字面量常量在做除法时进行了类型提升
         System.out.println(7.0 / 2);            // 3.5
 
         // 类型的提升：把int类型的变量先和double类型的字面量常量1.0做乘法，让结果为double类型，再除以int类型的变量，得到的是double类型的结果
         System.out.println(i * 1.0 / j);        // 3.5
 
         System.out.println(i % j);                //
     }
 }

 package cn.temptation;
 
 public class Sample02 {
     public static void main(String[] args) {
         // 减号 - 还可以做负号
         byte i = 1;
         // Type mismatch: cannot convert from int to byte
         // byte j = -i;
         byte j = (byte) -i;
         System.out.println(i);
         System.out.println(j);
 
         byte x = -128;
         byte y = (byte) -x;
         System.out.println(x);        //    -128
         System.out.println(y);        //  -128
 
         /*
          * x：        -128（没有超出byte范围）
          * -x：        128（int类型）：0000 0000 0000 0000 0000 0000 1000 0000
          * 因为强制类型转换为byte类型的变量y，所以要做截取
          *
          * 补码：    1000 0000        符号位的1表明是负数
          * 反码：    1111 1111
          * 原码：    1000 0000
          */
 
         // 产生异常：java.lang.ArithmeticException: / by zero
 //        int k = 123 / 0;
 //        System.out.println(k);
 
         // 产生异常：java.lang.ArithmeticException: / by zero
 //        int k = 0 / 0;
 //        System.out.println(k);
 
 //        double k = 123.45 / 2;
 //        System.out.println(k);        // 61.725
 //
 //        double m = 123.45 / 0;
 //        System.out.println(m);        // Infinity（正无穷大）
 //
 //        double n = -123.45 / 0;
 //        System.out.println(n);        // -Infinity（负无穷大）
 //
 //        double result1 = 0.0 / 0;
 //        System.out.println(result1);        // NaN（Not a Number  不是一个数）
 //
 //        double result2 = -0.0 / 0;
 //        System.out.println(result2);        // NaN（Not a Number  不是一个数）
 
 //        float k = 123.45F / 2;
 //        System.out.println(k);        // 61.725
 //
 //        float m = 123.45F / 0;
 //        System.out.println(m);        // Infinity（正无穷大）
 //
 //        float n = -123.45F / 0;
 //        System.out.println(n);        // -Infinity（负无穷大）
 //
 //        float result1 = 0.0F / 0;
 //        System.out.println(result1);        // NaN（Not a Number  不是一个数）
 //
 //        float result2 = -0.0F / 0;
 //        System.out.println(result2);        // NaN（Not a Number  不是一个数）
 
         int result1 = 11 % 4;
         System.out.println(result1);        //
 
         double result2 = 11.0 % 3;
         System.out.println(result2);        // 2.0
 
         double result3 = 11.0 % 3.5;
         System.out.println(result3);        // 0.5
 
         // 产生异常：java.lang.ArithmeticException: / by zero
 //        int result4 = 11 % 0;
 //        System.out.println(result4);
 
         double result5 = 11.0 % 0;
         System.out.println(result5);        // NaN（Not a Number  不是一个数）
     }
 }

 package cn.temptation;
 
 public class Sample03 {
     public static void main(String[] args) {
         // ++ 自增运算符                  -- 自减运算符
         int i = 2;
         System.out.println(i);        // 2
 
         // 1、单独使用自增运算符：不论++放在需要自增的变量的后面还是前面，都会在操作后让变量的值自增1
         // 自增运算符放在需要自增的变量的后面
         // i++;
         // 自增运算符放在需要自增的变量的前面
 //        ++i;
 
 //        System.out.println(i);        // 3
 
         // 2、非单独使用自增运算符
         // 下句语句一上来先把i的值赋值给j，然后i自己做自增（先赋值再自增）
 //        int j = i++;        // j = 2, i = 3
         // 下句语句一上来先i自己做自增，然后把i的值（自增后的值）赋值给j（先自增再赋值）
         int j = ++i;        // j = 3, i = 3
 
         System.out.println("j的值为：" + j);
         System.out.println("i的值为：" + i);
     }
 }

 package cn.temptation;
 
 public class Sample04 {
     public static void main(String[] args) {
         // 关于自增的一道题
         int i = 2;
         int j = 3;
 
         j = i++;
 
         System.out.println("i的值为：" + i);    //
         System.out.println("j的值为：" + j); // 2
 
 //        j = i++ + ++i+i*4;
         // 上句等价于
         j = (i++) + (++i) + (i * 4);
         /*
          * 计算过程：
          * i++这个表达式，此时i为3，首先是赋值，再让i自增，所以这个表达式(i++)的结果为3，i操作后的值为4
          * ++i这个表达式，此时i为4，首先让i自增，再赋值，所以i操作后的值为5，这个表达式(++i)的结果为5
          * i * 4这个表达式，此时i为5，进行乘法，所以这个表达式(i*4)的结果为20
          *
          * 最后三个表达式的结果相加：3 + 5 + 20 = 28
          */
 
         System.out.println(j);
     }
 }

 package cn.temptation;
 
 public class Sample05 {
     public static void main(String[] args) {
         // 加号 + 的用法：
         /*
          * 1、作为算术运算符的加号
          * 2、作为正数的符号 +
          * 3、作为字符串的连接符号
          */
         int result = 1 + 2;
         System.out.println(result);
 
         int x = +99;
         System.out.println(x);
 
         System.out.println("北京" + 2008);
     }
 }

 package cn.temptation;
 
 public class Sample06 {
     public static void main(String[] args) {
         // 2、赋值运算符：=、+=、-=、*=、/=、%=
 
         // Java中的一个等号 = 表示的是将等号（赋值号）右侧的内容赋值给等号（赋值号）左侧的变量，习惯上称之为赋值号
 
         int i = 2;
         // 完整描述：把整型的字面量常量2 赋值给 整型类型的变量i
         // 赋值号左侧的部分称为声明
         // 赋值号右侧的部分称为赋值
         System.out.println(i);
 
         // 一行语句中声明多个变量
         int x, y;
 
         // 下句语句先把123赋值给变量y，再将y赋值给x，所以最后x和y的值均为123
         x = y = 123;
 
         System.out.println(x);
         System.out.println(y);
 
         // 以+=为例，表示的是将赋值号（+=）左侧的变量 和 右侧的内容按照=之前的运算符进行相应的运算，操作后的结果再赋值给左侧的变量
         int j = 3;
         System.out.println(j);        // 3
         // j += 4;
         // 上句等价于
         j = j + 4;
         System.out.println(j);        // 7
 
 //        byte k = 5;
 //        // Type mismatch: cannot convert from int to byte
 //        k = k + 3;
 //        System.out.println(k);
 
         // 对于非默认数据类型的数据，使用带有算术运算符的赋值运算符时，会自动进行强制类型转换
         byte k = 5;
 //        k += 3;
         // 上句等价于
         k = (byte) (k + 3);
         System.out.println(k);
     }
 }

 package cn.temptation;
 
 public class Sample07 {
     public static void main(String[] args) {
         // 3、比较运算符：==、!=、>、<、>=、<=
 
         // Java中使用 == 表示相等（内容相等）
         // 比较的结果必然是一个boolean类型的值
         int i = 2;
         int j = 3;
         int k = 2;
 
 //        System.out.println(i == j);        // false
 //        System.out.println(i == k);        // true
 //        System.out.println(i + j == j + k);            // true
         // 上句等价于
 //        System.out.println((i + j) == (j + k));        // true
 
         System.out.println(i != j);        // true
         System.out.println(i != k);        // false
 
         System.out.println(i > j);        // false
         System.out.println(i < j);        // true
         System.out.println(i >= j);        // false
         System.out.println(i <= j);        // true
 
         System.out.println(k <= k);        // true
     }
 }

 package cn.temptation;
 
 public class Sample08 {
     public static void main(String[] args) {
         // 逻辑运算符：&、|、!、^、&&、||
         // 参与运算的变量或表达式的值均为boolean类型
 
         /*
          * &：逻辑与，有一个是false得到的结果就是false
          * |：逻辑或，有一个是true得到的结果就是true
          * !：逻辑非，颠倒黑白
          * ^：逻辑异或，类似吸铁石
          */
 //        System.out.println(true & true);        // true
 //        System.out.println(true & false);        // false
 //        System.out.println(false & true);        // false
 //        System.out.println(false & false);        // false
 
 //        System.out.println(true | true);        // true
 //        System.out.println(true | false);        // true
 //        System.out.println(false | true);        // true
 //        System.out.println(false | false);        // false
 
 //        System.out.println(!true);                // false
 //        System.out.println(!false);            // true
 
 //        System.out.println(true ^ true);        // false
 //        System.out.println(true ^ false);        // true
 //        System.out.println(false ^ true);        // true
 //        System.out.println(false ^ false);        // false
 
         /*
          * &&：逻辑与（聪明与/短路与）如果参与运算的第一个变量或表达式为false，得到的结果就是false，其他的变量或表达式就不去执行；如果多个逻辑与参与运算，以此类推
          * ||：逻辑或（聪明或/短路或）如果参与运算的第一个变量或表达式为true，得到的结果就是true，其他的变量或表达式就不去执行；如果多个逻辑或参与运算，以此类推
          */
 //        System.out.println(true && true);        // true
 //        System.out.println(true && false);        // false
 //        // eclipse会显示警告：Dead code（位于后一个变量或表达式上）
 //        System.out.println(false && true);        // false
 //        // eclipse会显示警告：Dead code（位于后一个变量或表达式上）
 //        System.out.println(false && false);    // false
 
         // eclipse会显示警告：Dead code（位于后一个变量或表达式上）
         System.out.println(true || true);        // true
         // eclipse会显示警告：Dead code（位于后一个变量或表达式上）
         System.out.println(true || false);        // true
         System.out.println(false || true);        // true
         System.out.println(false || false);    // false
 
         // 在实际的开发中，常用的是：!、^、&&、||
     }
 }

 package cn.temptation;
 
 public class Sample09 {
     public static void main(String[] args) {
         // 结合自增 和 逻辑运算符的一道题
         int i = 2;
         int j = 3;
 
         System.out.println((++i == 2) && (j++ == 3));        // false
         // 因为++i先自增再赋值，表达式++i的结果为3，所以++i == 2这个表达式的结果为false
         // 又因为使用聪明与，第一个表达式为false，后续的表达式不会执行，所以i = 3， j = 3
 
         // 问：最终显示i和j的值为多少？
         System.out.println(i);            //
         System.out.println(j);            //
     }
 }

 package cn.temptation;
 
 public class Sample10 {
     public static void main(String[] args) {
         // 位运算符：&、|、~、^、>>、>>>、<<
         /*
          * 规则：（在二进制中）操作的是补码
          * &：位与，进行操作的两个数的同一位上，有一个是0，该位运算的结果就是0
          * |：位或，进行操作的两个数的同一位上，有一个是1，该位运算的结果就是1
          * ~：位非，进行操作的数按位取反
          * ^：位异或，进行操作的两个数的同一位上，两个相同为0，两个不同为1
          */
 //        System.out.println(2 & 3);        // 2
 //        System.out.println(2 | 3);        // 3
 //        System.out.println(~2);            // -3
 //        System.out.println(2 ^ 3);        //
         /*
          * 2：0000 0010
          * 3：0000 0011
          *
          * 2
          * 原码：0000 0000 0000 0000 0000 0000 0000 0010
          * 反码：0000 0000 0000 0000 0000 0000 0000 0010
          * 补码：0000 0000 0000 0000 0000 0000 0000 0010
          *
          * ~2：（操作补码）
          * 补码：1111 1111 1111 1111 1111 1111 1111 1101
          * 反码：1111 1111 1111 1111 1111 1111 1111 1100
          * 原码：1000 0000 0000 0000 0000 0000 0000 0011
          */
 
         // 位异或^的用法：
         // 规律：一个数连续两次和另一个数做位异或运算，得到其本身的值
         // 可以应用在简单的加密解密中，连续两次进行位异或的那个数可以设置为密钥
         System.out.println(2 ^ 3 ^ 3);        //
 
         /*
          * <<：左移，左边的高位删除，右边的低位补0
          * >>：右移，因为左侧的最高位是符号位，所以要区分是0还是1：左侧的最高位是0，左侧补0；左侧的最高位是1，左侧补1
          * >>>：无符号右移，不论左侧的最高位是0还是1，左侧补0
          */
         System.out.println(2<<1);            //
         System.out.println(2>>1);            //
         System.out.println(-2>>1);            // -1
         System.out.println(-2>>>1);            //
         /*
          * -2：
          * 原码：1000 0000 0000 0000 0000 0000 0000 0010
          * 反码：1111 1111 1111 1111 1111 1111 1111 1101
          * 补码：1111 1111 1111 1111 1111 1111 1111 1110
          *
          * 右移1位操作（操作补码）
          * 补码：1111 1111 1111 1111 1111 1111 1111 1111
          * 反码：1111 1111 1111 1111 1111 1111 1111 1110
          * 原码：1000 0000 0000 0000 0000 0000 0000 0001
          *
          * 无符号右移1位操作（操作补码）
          * 补码：0111 1111 1111 1111 1111 1111 1111 1111
          * 反码：0111 1111 1111 1111 1111 1111 1111 1111
          * 原码：0111 1111 1111 1111 1111 1111 1111 1111
          */
     }
 }

 package cn.temptation;
 
 public class Sample11 {
     public static void main(String[] args) {
         // 依据参与运算的元素个数分类：
         // 1、一元运算符：!、~
         // 2、二元运算符：+、-、*、/、%、&、|、&&、||、^等等
         // 3、三元运算符：由两个符号组成的复合运算符       ? :
 
         // 三元运算符：只有一个
         // 格式：(比较表达式) ? (比较表达式为真值时，执行的内容) : (比较表达式为假值时，执行的内容);
 
         int i = 2;
         int j = 3;
         int result = ((i > j) ? i : j);
         System.out.println(result);
     }
 }

 package cn.temptation;
 
 public class Sample12 {
     public static void main(String[] args) {
         // 需求：取得给定的两个数字中较大的一个（使用三元运算符来做）
 //        int x = 28;
 //        int y = 17;
 //        int max = (x > y) ? x : y;
 //        System.out.println(max);
 
         // 需求：取得给定的三个数字中最大的一个（使用三元运算来做）
         /*
          * 思路：
          * 1、要获取三个数字中最大的，先拿出两个数字比一比，先找出这两个数字中较大的一个
          * 2、拿着比较出来的较大的那个数字再和剩下的那个数字做比较，如果剩下的那个数字比它大，那么剩下的那个数字就是最大的
          *         否则，比较出来的较大的那个数字就是最大的
          */
         int a = 5;
         int b = 4;
         int c = 6;
 
         // 分步操作
 //        // 1、要获取三个数字中最大的，先拿出两个数字比一比，先找出这两个数字中较大的一个
 //        int temp = (a > b) ? a : b;
 //        // 2、拿着比较出来的较大的那个数字再和剩下的那个数字做比较
 //        int max = (temp > c) ? temp : c;
 //        System.out.println("最大的数字为：" + max);
 
         // 如果就要在一行语句中写，如何实现？需要使用三元运算符的嵌套
         // 如下写法，在实际开发中不要这样写，可读性很差，纯炫技耳！
         int max = (a > b) ? ((a > c) ? a : c) : ((b > c) ? b : c);
         System.out.println("最大的数字为：" + max);
     }
 }

 package cn.temptation;
 
 import java.util.Scanner;
 
 public class Sample13 {
     public static void main(String[] args) {
         // 需求：通过键盘的录入，把输入的数据赋值给变量（交互操作的需求）
 
         // 创建一个扫描器对象
         Scanner input = new Scanner(System.in);
         System.out.println("输入一个数字：");
         // 接收用户的键盘的录入，并赋值给声明的变量
         int i = input.nextInt();
         // 扫描器对象使用完毕后，关闭
         input.close();
 
         System.out.println("用户通过键盘录入的数字为：" + i);
     }
 }

 package cn.temptation;
 
 import java.util.Scanner;
 
 public class Sample14 {
     public static void main(String[] args) {
         // 需求：通过键盘录入三个数字，比较获取其中最大的一个
 
         // 声明三个变量来接收键盘录入的三个数字
         Scanner input = new Scanner(System.in);
         System.out.println("输入第一个数字：");
         int i = input.nextInt();
         System.out.println("输入第二个数字：");
         int j = input.nextInt();
         System.out.println("输入第三个数字：");
         int k = input.nextInt();
         input.close();
 
         // 分步操作
         int temp = (i > j) ? i : j;
         int max = (temp > k) ? temp : k;
         System.out.println("输入的数字：" + i + "," + j + "," + k + "中，最大的数字为：" + max);
     }
 }