1 package com.wfd360.day02;
2
3
4 import org.junit.Test;
5
6 import java.math.BigInteger;
7
8 /**
9 * 1.算术运算符[掌握]
10 * <p>
11 * 2.自增自减[掌握]
12 * <p>
13 * 3.赋值运算[掌握]
14 * <p>
15 * 4.比较运算符[掌握]
16 * <p>
17 * 5.逻辑运算符[掌握]
18 * <p>
19 * 6.位运算符[了解]
20 * <p>
21 * 7.三目运算符[掌握]
22 */
23
24 public class Demo01 {
25 /**
26 * 1.算术运算符[掌握]
27 * 1)加法（+） 加法 正号 字符串拼接
28 * 2)减法（-） 减法 负号
29 * 3)乘法 （*） 乘法
30 * 4)除法(/) 除法
31 * 整数（小数）相除的例子
32 * 10/3 =3； 10.0/3=3.33333…
33 * 0/0
34 * 0.0/0.0
35 * 结果是NaN ,任何的NaN都不等于自己（面试题）
36 * 1.0/0.0
37 * Infinity,表示无穷大
38 */
39 @Test
40 public void test() {
41 int i1 = 3 + 2 - 5 * 6;
42 int i2 = 10 / 3; // 3
43 // 3.0 代表整数相除，将运算结果，转变为double
44 double d1 = 10 / 3;
45 System.out.println("d1=" + d1);
46 //double d2 = 10 / 3.0; // 3.3333333333333335
47 double d2 = 10.0 / 3; // 3.3333333333333335
48 System.out.println("d2=" + d2);
49 // 0/0 报错 java.lang.ArithmeticException: / by zero
50 //int i3=0/0;
51 // System.out.println("i3="+i3);
52 // 结果是NaN ,任何的NaN都不等于自己（面试题）
53 double d3 = 0.0 / 0;
54 System.out.println(" d3=" + d3);
55 double d4 = 1.0 / 0; // Infinity,表示无穷大
56 System.out.println(" d4=" + d4);
57 }
58
59 /**
60 * 取模(%) ， 取余数
61 * 案例：假设大学的一个寝室可以住6个人，那么计算1024个大学生一共需要多少个寝室？ （本质就是生产中经常用到的分页算法）
62 */
63 @Test
64 public void test2() {
65 int n = 6;
66 int m = 1024;
67 //取余数
68 int y = m % n;
69 System.out.println("y=" + y);
70 //=====================
71 //如果余数为零那么，一共需要的寝室数=m/n;
72 //如果余数 不 为零那么，一共需要的寝室数=（m/n）+1;
73 }
74
75 /**
76 * 2. 自增自减[掌握]
77 * ++（自增） --（自减）
78 * 自增自减只能够用于 变量，不能用于常量
79 * 自增自减运算的优先级 比 算术运算符 高
80 */
81 @Test
82 public void test3() {
83 //===========基本使用==================
84 int i = 3; // 表示把3赋值给变量i
85 i++; //表示变量i的值加1，i的值变成4
86 ++i; //表示变量i的值加 1，i的值变成5
87 System.out.println("i=" + i);
88 }
89
90 /**
91 * 面试题1
92 */
93 @Test
94 public void test4() {
95 int i = 3;
96 int j = i++; // 先复制，在运输算
97 // i等于多少，j等于多少？
98 System.out.println("i=" + i);// 4
99 System.out.println("j=" + j);// 3
100 }
101
102 /**
103 * 面试题2
104 */
105 @Test
106 public void test5() {
107 int i = 3;
108 int j = ++i; // 先运算，在赋值
109 // i等于多少，j等于多少？
110 System.out.println("i=" + i);// 4
111 System.out.println("j=" + j);// 4
112 }
113
114 /**
115 * 面试题3
116 */
117 @Test
118 public void test6() {
119 int i = 3;
120 i = ++i; // 先运算，在赋值
121 // i等于多少，j等于多少？
122 System.out.println("i=" + i); // 4
123 int j = 3;
124 j = j++;
125 System.out.println("j=" + j); // 3
126 }
127
128 /**
129 * 面试题3
130 * 破题关键点：
131 * i++是先赋值在执行 自增
132 * ++i 是先执行自增 在赋值
133 */
134 @Test
135 public void test7() {
136 int i = 3;
137 // 3(4) 4(5) 5(6)
138 int a = i++ + i++ + i++;
139 // 7 8 9
140 int b = ++i + ++i + ++i;
141 //请问 a=? b=? i=?
142 System.out.println("a=" + a);
143 System.out.println("b=" + b);
144 System.out.println("i=" + i);
145 }
146
147 /**
148 * 3. 赋值运算[简单，与平时的数学逻辑一样]
149 * = += -= *= /= %=
150 * 1)赋值符号的运算顺序？
151 * 从右到左，把符号右边的值赋值到左边的变量中
152 * 2）上面 后五个分别看成是一个整体： 例如 += 看成是一个符号，不要看成两个；
153 */
154 @Test
155 public void test8() {
156 //请先在每行的后面给出i的值，然后用断点观察i值得变换
157 int i = 3;
158 i += 2;// 表示把2 累加到变量 i 中
159 i -= 1; // 表示把-1 累加到变量 i 中
160 i *= 3; // 等价 i=i*3; 划重点：等价不是等于
161 i /= 3; // 等价 i=i/3;
162 i %= 3; // 等价 i=i%3;
163 System.out.println("i=" + i);
164 }
165
166 /**
167 * 超级面试题
168 */
169 @Test
170 public void test9() {
171 short s = 3;
172 s += 2; //正常
173 System.out.println("s=" + s);
174 //===========================
175 short s2 = 3;
176 // 语法错误，结果值是int，int不能自动转换为short
177 // s2 = s2+2;
178 }
179
180 /**
181 * 4.比较运算符[掌握]
182 * == != > < >= <= instanceof
183 * 规律：比较运算的结果是一个布尔类型的值（true 或false）；
184 * 举例：
185 * 定义一个布尔表达式，打印输出
186 * 特别说明：instanceof 是判断一个对象是否属于某种类型
187 * 是否可以用于我们之前学习的基本数据类型
188 */
189 @Test
190 public void test10() {
191 System.out.println(1 == 2); //false
192 System.out.println(1 <= 2); //true
193 // instanceof
194 //是否可以用于我们之前学习的基本数据类型 ==> 不可以
195 // System.out.println( 1 instanceof int);
196 System.out.println("爱老虎油" instanceof String); // true
197 }
198
199 /**
200 * 5.逻辑运算符[掌握]
201 * & | && || ^ ！
202 * 是应用于多个条件的组合判断。
203 * 示例说明：
204 * 例如小明参加2个学科的考试 java php
205 * 1)java 和 php 同时考100分，奖励 欧洲十日游
206 * 伪代码描述：java==100 并且 php==100
207 * 2)java 和php，只要有一门考100分，奖励 奖励棒棒糖一个
208 * 伪代码描述：java==100 或者 php==100
209 * <p>
210 * 逻辑运算的两边结果值都必须是什么类型？ 布尔
211 * <p>
212 * & ：两边都为true ，结果为true
213 * | ： 只要有一边为true，结果为true
214 * && ： 两边都为true ，结果为true
215 * || : 只要有一边为true，结果为true
216 * ^ : 两边不一样，结果为true ，否则为false，举个例子打印一下
217 * ！ ： 逻辑非，举个例子打印一下
218 */
219 @Test
220 public void test11() {
221 int java = 100;
222 int php = 100;
223 int c = 90;
224 int mysql = 80;
225 // || : 只要有一边为true，结果为true
226 System.out.println(java == 100 || php == 100); //true
227 System.out.println(java == 100 || c == 100); //true
228 System.out.println(mysql == 100 || c == 100); //false
229 // && 两边都为true ，结果为true
230 System.out.println(java == 100 && php == 100); //true
231 System.out.println(java == 100 && c == 100); //false
232 // 逻辑非
233 System.out.println(java != 100); //false
234 System.out.println(c != 100); // true
235
236 // ^ : 两边不一样，结果为true ，否则为false，举个例子打印一下 (用的很少)
237 System.out.println(java == 100 ^ php == 100); //false
238 System.out.println(mysql == 100 ^ c == 100); //false
239 System.out.println(java == 100 ^ c == 100); //true
240 }
241
242 /**
243 * && || 和 & | 区别？
244 * 1) & | 既可以充当逻辑运算，也可以是位运算符，怎么区分是逻辑运算还是位运算？
245 * 根据表达式的结果是否为 布尔类型 来判断
246 * 2)双与 双或 具有短路行为 什么意思？
247 * 举个例子 上面小明的考试的成绩 要求是两科都为100分，看到第一科低于100分之后没有必要再看第二科成绩
248 * 代码表示：Java = 100 && php = 100 （java只考了5分）
249 * 如果逻辑运算左边的值能够确定整个逻辑运算表达式的值，那么右边就不执行了，短路了。
250 * && 何时短路 ？ 左边表达式结果为false
251 * || 何时短路 ？ 左边表达式结果为true
252 * 思考：如何验证短路行为？
253 * 提示：
254 * 右边表达式用 自增自减，例如 ++i = 5
255 * 或者使用一个编译正常，运行报错的表达式，例如 1/0
256 */
257 @Test
258 public void test12() {
259 int java = 5;
260 int php = 100;
261
262 // 区分 && 与 &
263 System.out.println(java == 100 && (++php) == 100); // php=100 &&具有短路行为，左边为false时，不在执行右边
264 System.out.println(java == 100 & (++php) == 100); // php=101
265
266 php = 100;
267 // 区分 || 与 |
268 System.out.println(php == 100 || (++java) == 100); // java=5 ||具有短路行为，左边为true时，不在执行右边
269 System.out.println(php == 100 | (++java) == 100); // java=6
270 System.out.println("java=" + java + " php=" + php);
271 }
272
273 /**
274 * 面试错误题
275 * 例如：判断一个整数的变量 a里面的数据 在0-100之间
276 * 正确写法： a>0 && a<100
277 * 错误写法: 0< a < 100 (java没有这种语法，不支持)
278 */
279 @Test
280 public void test13() {
281 int a = 10;
282 System.out.println(a > 0 && a < 100);
283
284 //System.out.println(0 < a < 100); 错误
285 }
286
287 /**
288 * 十进制转成二进制
289 * String s = Integer.toBinaryString(n) //将十进制数转成字符串，例如n=5 ，s = "101"
290 * <p>
291 * 将字符串转成整形
292 * int a = Integer.valueof("1002"); //当然s只能是数字类的字符串
293 */
294 @Test
295 public void test14() {
296 //十进制转成二进制
297 String s = Integer.toBinaryString(5);
298 System.out.println("s=" + s);
299 //二进制转变为十进制
300 BigInteger bi = new BigInteger("011", 2); //转换为BigInteger类型
301 int a = Integer.parseInt(bi.toString());
302 System.out.println("a=" + a);
303 }
304
305 /**
306 * 6.位运算符[了解]
307 * & | ^ ~ << >> >>>
308 * 位运算就是 二进制的位进行运算。
309 * 示例：比如计算 125+176 ，从数学的角度是怎么计算的？
310 * 同理，位运算也类似，比如 3&4
311 * <p>
312 * 可以把1看成是true,把0看成是false
313 * & :与 位运算，两边为1，结果为1
314 * | :或 位运算，有一个为1，结果为1
315 * ^ : 异或，两边不一样，就为1，否则为0
316 * ~ : 取反，1变成0 ,0 变成1
317 * << : 向左位移动，例如1<<3
318 * >> : 向右位移动，例如8>>2
319 * >>>: 无符号向右移动
320 * <p>
321 * 注意：
322 * 正数的补码，反码，原码 都一样；
323 * 负数的反码：符号为不变，其他位取反;
324 * 负数的补码：它的反码+1;
325 */
326 @Test
327 public void test15() {
328 // & :与 位运算，两边为1，结果为1
329 System.out.println(20 & 30); //得到的是十进制数
330 System.out.println("20的二进制：" + Integer.toBinaryString(20));
331 System.out.println(" &");
332 System.out.println("30的二进制：" + Integer.toBinaryString(30));
333 System.out.println("----------------------------------------");
334 System.out.println(" " + Integer.toBinaryString(20 & 30));
335 }
336
337 @Test
338 public void test16() {
339 // | :或 位运算，有一个为1，结果为1
340 System.out.println(20 | 30); //得到的是十进制数
341 System.out.println("20的二进制：" + Integer.toBinaryString(20));
342 System.out.println(" |");
343 System.out.println("30的二进制：" + Integer.toBinaryString(30));
344 System.out.println("----------------------------------------");
345 System.out.println(" " + Integer.toBinaryString(20 | 30));
346 }
347
348 @Test
349 public void test17() {
350 //<< : 向左位移动，例如1<<3 , 左位易的本质运算是，假设 a<<b ,相当于数学中的运算 a乘以2的b次方
351 System.out.println(2 << 3); //得到的是十进制数
352 System.out.println("2的二进制：000" + Integer.toBinaryString(2));
353 System.out.println(" <<3");
354 System.out.println("----------------------------------------");
355 System.out.println(" " + Integer.toBinaryString(2 << 3));
356 }
357
358 /**
359 * 注意：
360 * 正数的补码，反码，原码 都一样；
361 * 负数的反码：符号为不变，其他位取反;
362 * 负数的补码：它的反码+1;
363 */
364 @Test
365 public void test18() {
366 //~ : 取反，1变成0 ,0 变成1
367 System.out.println(~(-5)); //得到的是十进制数
368 System.out.println("原码：00000000000000000000000000000" + Integer.toBinaryString(5));
369 System.out.println("反码：" + Integer.toBinaryString(-5));
370 System.out.println("补码：00000000000000000000000000000" + Integer.toBinaryString(~(-5)));
371 }
372
373 /**
374 * 7.三目运算符[掌握]
375 * 语法格式： X ? Y : Z
376 * 1)上面的三目运算整体看成是一个表达式，应该有一个结果值
377 * 2)X ? 布尔类型的值或者结果为布尔类型的表达式
378 * 3)Y Z ? 一般来说数据类型相同的值或者表达式
379 * 4)运算的规则？
380 * X 为true，就是 Y 的结果值 ( 冒号前面的表达式的值)
381 * X为false，就是Z的结果值 ( 冒号后面的表达式的值)
382 * x ? y : z
383 * <p>
384 * 注意： 不要受 ？ 和 : 的干扰，它们只是一个固定语法格式而已
385 */
386 @Test
387 public void test19() {
388 //举例：找出两个整型变量中的最大值
389 int a = 6;
390 int b = 7;
391 int c = a > b ? a : b;
392 System.out.println("c=" + c);
393 //举例 判断一个数是 奇数 还是 偶数
394 int i = 9;
395 System.out.println(i % 2 == 0 ? "偶数" : "奇数");
396 }
397
398 }
