200-Java语言基础-Java编程入门-003

当前位置:

首页 > 编程开发 > Java教程 >

200-Java语言基础-Java编程入门-003 | Java运算符

一、字符和字符串参与运算

 1 public class JavaDemo {
 2   public static void main(String[] args) {
 3     System.out.println('a' + 1);            // 98，因为有ASCII，a字符对应的是int类型97
 4     System.out.println((char) ('a' + 1));   // b
 5    
 6     // 任何数据类型用 + 与字符串相连接都会产生新的字符串
 7     System.out.println("hello" + 'a' + 1);  // helloa1
 8     System.out.println('a' + 1 + "hello");  // 98hello
 9    
10     System.out.println("5 + 5 = " + 5 + 5); // 5 + 5 = 55
11     System.out.println("5 + 5 = " + (5 + 5)); // 5 + 5 = 10
12   }
13 }

二、char数据类型

Java语言中的字符char可以存储一个中文汉字吗?为什么呢?

Java语言采用的是Unicode编码。Unicode编码中的每个字符占用两个字节。中文也是占的两个字节
Java中的字符可以存储一个中文汉字

 1 public class JavaDemo {
 2   public static void main(String[] args) {
 3     char c = 'a';
 4     System.out.println(c);
 5     
 6     byte b = 100;
 7     char c1 = 97;         // 0 ~ 65535
 8     System.out.println(c1);
 9     
10     // char类型是否可以存储中文
11     char x = '中';
12     System.out.println(x);
13   }
14 }

三、运算符

什么是运算符

就是对常量和变量进行操作的符号

运算符的分类

算数运算符
赋值运算符
比较（关系或条件）运算符
逻辑运算符
三目（元）运算符

所有的程序开发都是一种数据的处理游戏，那么对于数字的处理一定会有所谓的操作模式，而这些操作模式就称为运算符，运算符是有优先顺序的。

对于程序开发而言，里面会提供大量的基础运算符，那么这些运算符也都会提供各自的优先顺序

四、算数运算符

在Java中数学运算都提供了标准的支持

+、-、*、/、%、++、--

 1 public class JavaDemo {
 2   public static void main(String[] args) {
 3     /*
 4     * a:+号在java中有三种作用,代表正号,做加法运算,字符串的连接符

 5     * b:整数相除只能得到整数。如果想得到小数，必须把数据变化为浮点数类型
 6     * c:/获取的是除法操作的商，%获取的是除法操作的余数

 7     * %运算符

 8             * 当左边的绝对值小于右边绝对值时,结果是左边

 9             * 当左边的绝对值等于右边或是右边的倍数时,结果是0
10             * 当左边的绝对值大于右边绝对值时,结果是余数

11       * %运算符结果的符号只和左边有关系,与右边无关

12       * 任何一个正整数%2结果不是0就是1可以用来当作切换条件
13     */
14     // 除/
15     System.out.println(10 / 3);            // 3 整数相除结果只能是整数
16     System.out.println(10 / 3.0);          // 3.3333333333333335 如果想得到小数，把其中一个 数变成小数，另一个在运算的时候会自动类型提升
17     // 模 %
18     System.out.println(3 % 5);             // 3 如果想得到小数，把其中一个  数变成小数，另一个在运算的时候会自动类型提升
19     System.out.println(5 % 5);
20     System.out.println(15 % 5);
21   }
22 }
23 // 简化运算符
24 public class JavaDemo {
25   public static void main(String[] args) {
26     int num = 20;
27     num = num + 10;
28     System.out.println(num);
29   }
30 }
31  
32 对于以上“ num = num + 10;”在内存小的时代就不适合了。所以才提供有一系列简化的运算符（+=、*=、-=、/=、%=）支持

33  
34 public class JavaDemo {
35   public static void main(String[] args) {
36     int num = 20;
37     num += 10;
38     System.out.println(num);
39   }
40 }

“++”、“--”这两种运算符有两类使用方式：

变量++（a++）、变量--（a--）：先将变量中的值取出做赋值操作，而后进行自增1或自减1；
++变量（++a）、--变量（--a）：先进行变量的自增1或自减1，而后进行结果赋值；

 1 // 实现自增与自减
 2 public class JavaDemo {
 3   public static void main(String[] args) {
 4     int x = 10 ;
 5     int y = 20 ;
 6     // 1、++ x：首先x的内容要先自增1，为11；

 7     // 2、y --：先进行计算，使用的内容是20，计算完成后自减
 8     int result = ++ x - y -- ;
 9     System.out.println("计算结果：" + result) ;   // -9
10     System.out.println("x = " + x) ;  // 11
11     System.out.println("y = " + y) ;  // 19
12   }
13 }

五、赋值运算符

赋值运算符有哪些

基本的赋值运算符：=
- 把 = 右边的数据赋值给左边，左边必须是变量。
扩展的赋值运算符：+=,-=,*=,/=,%=
- += 把左边和右边做加法，然后赋值给左边。

六、比较（关系或条件）运算符

关系运算符的是要特征就是进行大小的比较处理，包括：大于（>）、小于（<）、大于等于（>=）、小于等于（<=）、不等（!=）、相等（==）。注意：=是进行赋值、==是进行关系运算

无论你的操作是简单还是复杂，结果是boolean类型。

在进行关系判断的时候特别需要注意的就是相等的判断问题，在Java中“=”表示的赋值运算、而内容相同的比较是“==”

 1 // 判断相等
 2 public class JavaDemo {
 3   public static void main(String[] args) {
 4     int x = 10 ;
 5     int y = 10 ;
 6     boolean flag = x == y ; // true
 7     System.out.println(flag) ;
 8   }
 9 }
10     进行关系运算的时候可以针对所有的基本数据类型，例如：也可以直接使用字符进行处理

11 // 在字符处理上使用关系运算
12 public class JavaDemo {
13   public static void main(String[] args) {
14     char c = '剑';
15     boolean flag = 21073 == c ; // true
16     System.out.println(flag) ; 
17   }
18 }
数据类型之间提供有转型支持，所以在进行判断的时候字符会自动转为int后进行数字的比较

七、逻辑运算符

 1 public class JavaDemo {
 2   public static void main(String[] args) {
 3     // &（逻辑与）、|（逻辑或）、^（逻辑异或）、！（逻辑非）
 4     // 逻辑与 & 并且and 遇到false则false
 5     int a = 10;
 6     int b = 20;
 7     int c = 30;
 8     System.out.println(a < b & b < c); // true & true = true
 9     System.out.println(a < b & b > c); // true & false = false
10     System.out.println(a > b & b < c); // false & true = false
11     System.out.println(a > b & b > c); // false & false = false
12     
13     // 逻辑 | 或or 遇true则true
14     System.out.println(a < b | b < c); // true | true = true
15     System.out.println(a < b | b > c); // true | false = true
16     System.out.println(a > b | b < c); // false | true = true
17     System.out.println(a > b | b > c); // false | false = false
18     
19     // 逻辑异或^ 两边相同为false，两边不同为true
20     System.out.println(a < b ^ b < c); // true ^ true = false
21     System.out.println(a < b ^ b > c); // true ^ false = true
22     System.out.println(a > b ^ b < c); // false ^ true = true
23     System.out.println(a > b ^ b > c); // false ^ false = false
24     
25     // 逻辑非 ！
26     System.out.println(!true);
27     System.out.println(!!true);
28   }
29 }

逻辑运算符 && 和 & 的区别：

最终结果一样
&&具有短路效果，左边是false，右边不执行。

逻辑运算符 || 和 | 的区别：

最终结果一样
|| 具有短路效果，左边是true，右边不执行。

 1 public class JavaDemo {
 2   public static void main(String[] args) {
 3     /*
 4     int a = 10;
 5     int b = 20;
 6     int c = 30;
 7     System.out.println(a < b && b < c); // true && true = true
 8     System.out.println(a < b && b > c); // true && false = false
 9     System.out.println(a > b && b < c); // false && true = false
10     System.out.println(a > b && b > c); // false && false = false
11     */
12     int x = 3;
13     int y = 4;
14     // System.out.println((++x == 3) & (++y == 4));    // false & false  = false
15     // System.out.println("x = " + x);    // 4
16     // System.out.println("y = " + y);    // 5
17     System.out.println("---------------------------------");
18     System.out.println((++x == 3) && (++y == 4));    // false & false =  false
19     System.out.println("x = " + x);    // x = 4
20     System.out.println("y = " + y);    // y = 4
21   }
22 }

八、位运算符

位运算指的是可以直接进行二进制数据的计算处理，主要有：位与（&）、位或（|）、位异或（^）、反码（~）、

  1 public class JavaDemo {
  2   public static void main(String[] args) {
  3     /*
  4     * &,|,^,~ 的用法

  5     * &:有0则0
  6     * |:有1则1
  7     * ^:相同则0，不同则1
  8     * ~:按位取反
  9     */
 10     System.out.println(6 & 3);             // 010 - 2
 11     System.out.println(6 | 3);             // 111 - 7
 12     System.out.println(6 ^ 3);             // 101 - 5
 13     System.out.println( ~ 6);              // -5
 14   }
 15 }
 16 /*
 17     110
 18 &   011
 19 ----------
 20     010
 21     
 22     
 23     110
 24 |   011
 25 ----------
 26     111
 27     
 28     
 29     110
 30 ^   011
 31 ----------
 32     101
 33     
 34     
 35     00000000 00000000 00000000 00000110    6的原码反码补码都是本身

 36     11111111 11111111 11111111 11111001    对6取反
 37 -   00000000 00000000 00000000 00000001
 38 ---------------------------------------
 39     11111111 11111111 11111111 11111000    反码
 40     10000000 00000000 00000000 00000111    原码（-7）

 41 */
 42     位异或运算符的特点

 43 public class JavaDemo {
 44   public static void main(String[] args) {
 45     /*
 46          * 位异或运算符的特点

 47      * ^的特点：一个数据对另一个数据位异或两次，该数本身不变。

 48      */
 49     // System.out.println(5 ^ 10 ^ 10); // 5
 50     // System.out.println(5 ^ 10 ^ 5); // 5
 51     
 52     /*
 53        * 请自己实现两个整数变量的交换（不需要定义第三方变量）

 54      */
 55     int x = 5;
 56     int y = 10;
 57    
 58     // 需要第三方变量
 59     /*
 60     int temp;
 61     temp = x;
 62     x = y;
 63     y = temp;
 64     */
 65     
 66     // 不需要定义第三方变量,有可能超出int取值范围
 67     /*
 68     x = x + y;        // 5 + 10 = 15
 69     y = x - y;        // 15 - 10 = 5
 70     x = x - y;        // 15 - 5 = 5 
 71     */
 72     // 不需要第三方变量
 73     x = x ^ y;        // 5 ^ 10
 74     y = x ^ y;        // 5 ^ 10 ^ 10     y = 5
 75     x = x ^ y;        // 5 ^ 10 ^ 5
 76     System.out.println("x = " + x + "---" + "y = " + y);
 77   }
 78 }
 79  
 80 public class JavaDemo {
 81   public static void main(String[] args) {
 82     /*
 83      * >>,>>>,<<的用法:
 84      *  <<:左移  左边最高位丢弃，右边补齐0
 85      *  >>:右移  最高位是0，左边补齐0;最高为是1，左边补齐1
 86      *  >>>:无符号右移 无论最高位是0还是1，左边补齐0
 87           *  最有效率的算出2 * 8的结果

 88      */
 89     
 90     // 左移，向左移动几位就是 乘以2的几次幂
 91     System.out.println(12 << 1);
 92     System.out.println(24 << 2);
 93    
 94     // 右移，向右移动几位就是除以2的几次幂
 95     System.out.println(12 >> 1);
 96     System.out.println(12 >> 2);
 97     
 98     System.out.println(12 >>> 2);
 99     
100     // 最有效率的算出2 * 8的结果
101     System.out.println(2 << 3);
102   }
103 }

九、三元运算符的基本用法

在进行程序开发的时候三目（赋值）运算符使用的非常多，而且合理运用三目运算可以避免一些大范围的程序编写。三目运算的赋值运算处理，它需要设置一个逻辑关系的判断之后才可以进行的赋值操作。基本语法如下：

关系运算？关系满足时的内容：关系不满足时的内容

 1 // 判断两个数字的大小，将最大值保存
 2 public class JavaDemo {
 3   public static void main(String[] args) {
 4     int x = 20;
 5     int y = 10;
 6     // 判断两个数的最大是，如果x大于y就将x赋值给max,反之y赋值给max
 7     int max = x > y ? x : y;
 8     System.out.println(max) ;
 9   }
10 }

三目运算本身也可以进行嵌套处理，也就是说在赋值语句位置上可以进一步编写三目运算

 1 // 三目运算的嵌套，将三个数字中的最大值保存下来
 2 public class JavaDemo {
 3   public static void main(String[] args) {
 4     int x = 20;
 5     int y = 10;
 6     int z = 30;
 7     // 判断两个数的最大是，如果x大于y就将x赋值给max,反之y赋值给max
 8     int max = (x > y) ? (x > z ? x : z ) : (y > z ? y : z);
 9     System.out.println(max) ;
10   }
11 }
12     虽然允许进行嵌套处理，但是程序的可读性变得很差，根据实际的情况确定是否使用

出处：https://www.cnblogs.com/sftp/p/14504061.html

栏目列表

首页 > 编程开发 > Java教程 >

200-Java语言基础-Java编程入门-003 | Java运算符