/*
java中的运算符
1，算数运算符
正+负- 加+ 减-乘*除/ 取模%
自增（前）++a 先运算后取值 自增（后）a-- 先取值后运算
自减（前）–a 先运算后取值 自减（后）a-- 先取值后运算
字符串连接+
*/
class ArythmeticTest{
public static void main(String[] args) {
//除法 /
int num1 = 12;
int num2 = 5;
int result = num1 / num2;
System.out.println(result);//结果为2 ，因为是整数型
int result2 = num1 / num2 * num2;
System.out.println(result2);//结果10
double result3 = num1 / num2;
System.out.println(result3);//结果2.0,因为num1/num2的值是int型数值2,
double result4 = num1 / num2 + 0.0;//2.0 0.0为浮点型常量默认为double型, 2（int）+0.0（double）输出2.0（double）。
System.out.println(result4);
double result5 = num1 / (num2 + 0.0);//2.4 先计算括号，num2+0.0为double型，num1（int）/（num2+0.0）(double)为double型，输出2.4
System.out.println(result5);
double result6 = (num1 + 0.0) / num2 ;//2.4
System.out.println(result6);
double result7 = (double)num1 / num2;//2.4通过强转将num1转换为double型，再计算
System.out.println(result7);
double result8 = (double)(num1 / num2);//2.0 原理为通过+常量0.0或者强转double方法将参与除法运算的一个数值转为double型再运算，结果就 为double型
System.out.println(result8);
//取模运算
/*
取模运算的结果符号与被模数m有关，与m相同
实际应用中经常使用取模符号来判断变量能否被除尽。
*/
int m1 = 12;
int n1 = 5;
System.out.println("m1 % n1 = " + m1 % n1);//2
int m2 = -12;
int n2 = 5;
System.out.println("m2 % n2 = " + m2 % n2);//-2
int m3 = 12;
int n3 = -5;
System.out.println("m3 % n3 = " + m3 % n3);//2
int m4 = -12;
int n4 = -5;
System.out.println("m4 % n4 = " + m4 % n4);//-2
/*
前++ ，先自增1，再运算
后++ ，先运算，再自增1
*/
int a1 = 10;
int b1 = ++a1;
System.out.println("a1=" + a1 + ",b1=" +b1 );//输出a1=11,b1=11
int a2 = 10;
int b2 = a2++;
System.out.println("a2=" + a2 + ",b2=" +b2 );//输出a2=11,b2=10
int a3 = 10;
a3++;//先运算在自增，a3++在此处不涉及运算，只自增到11
int b3 = a3;
System.out.println("a3=" + a3 + ",b3=" +b3 );//输出a3=11,b3=11
int a4 = 10;
++a4;//先自增再运算
int b4 = a4;
System.out.println("a4=" + a4 + ",b4=" +b4 );//输出a4=11,b4=11
short s1 = 10;
//s1 = (short)(s1 + 1);正确
//s1 = s1 + 1;错误 应为int型
s1++;//等同于s1 = （short）（s1 + 1）;使用这种方式不会改变数据类型
System.out.println(s1);
byte byte1 = 127;
byte1++;//输出-128 ，自增不会改变数据类型，不会输出128，因为byte表示范围为-128到127，所以从头开始输出-128
byte1++;//输出-127
System.out.println(byte1);//输出-127
int i1 = 129;
byte byte2 = (byte)i1;
System.out.println(byte2);//输出-127，int型强转byte型也会有范围溢出的情况
/*
前-- ，先自减1，再运算
后-- ，先运算，再自减1
*/
int a5 = 10;
int b5 = --a5;
System.out.println("a5=" + a5 + ",b5=" +b5);//输出a1=9,b1=9
int a6 = 10;
int b6 = a6--;
System.out.println("a6=" + a6 + ",b6=" +b6);//输出a1=9,b1=10
int i2 = 21;
int i3 = i2--;//此时i2为21-1=20，i3为21
System.out.println(i3);//输出21
i3 = --i2;///此时，i2为20-1=19，先自减再运算
System.out.println(i3);//输出19
//给出一个整数，打印显示它的个位十位百位
//例如数字153的情况如下；个位：3，十位：5，百位：1
int i4 = 888;
int i5 = i4 / 100;
int i6 = i4 % 100 / 10;//也可以 i4 / 10 % 10
int i7 = i4 % 100 %10;//也可以 i4 % 10
System.out.println("个位=" + i7);
System.out.println("十位=" + i6);
System.out.println("百位=" + i5);
}
}
/*
运算符2
赋值运算符
符号=
当=号两侧类型数据不一致时，可以使用自动类型转换或使用强制
类型转换原则进行处理。
支持连续赋值
扩展赋值运算符：+= ， -= ， *= ， /= , %=
*/
class SetValueTest {
public static void main(String[] args) {
int i1,j1;//必须加","表示共同用int类型
i1 = j1 = 10;//可以连续赋值
i1 = 10;
j1 = 30;//不能写成i1 = 10，j1 = 30
int i2 = 10,j2 = 20;//可以这样写
//**********************************************
int num1 = 10;
num1 += 2;//代表num1 = num1 + 2
System.out.println(num1);//输出12
int num2 = 12;
num2 %= 5;//代表num2 = num2%5
System.out.println(num2);//输出2
byte b1 = 127;
b1 += 2;//使用+=不会改变变量的数据类型
System.out.println(b1);//输出-127，因为b1依然是byte型
//开发中如果希望变量实现+2的操作又不希望改变数据类型可以使用+=
//变量+2操作，方法一：num = num + 2;
//方法二： num += 2;(推荐，因为代码量少，且不会改变类型)
//方法三：num++; num++;(如果只增加1，推荐num++，因为代码量少)
int i3 = 1;
i3 *= 0.1;
System.out.println(i3);//输出0，因为是int型只取整数
i3++;//此处i3的初始值经过上一步运算已经为0
System.out.println(i3);//输出1
int m = 2;
int n = 3;
n *= m++;
System.out.println("m=" + m);//输出3
System.out.println("n=" + n);//输出6
int y = 10;
y +=(y++) + (++y);//等同于10+（10+12），(y++)=10, 因为先取值在运算，(++y)=11+1，因为上一步y已经变为11。
System.out.println(y);//输出 32
}
}
/*
运算符三 比较运算符
相等== 例子 4==3 结果false
不等于！= 例子4！=3 结果true
小于< 4<3 结果 false
大于> 4>3 结果 true
小于等于<= 4<=3 结果false
大于等于>= 4>=3 结果true
检查是否是类的对象 instanceof 例子 “Hello” instanceof String 结果true
注意：
比较运算的结果都是boolean型，只有true和false两种
运算符是"==",不能写成"="
< > <= >= 只能使用在数值类型的变量间比较
!= == 可以用在String类型的变量比较
*/
class CompareTest{
public static void main(String[] args) {
boolean b = 4==3;
System.out.println(b);
int i = 10;
int j = 20;
System.out.println(i == j);//输出false
System.out.println(i = j);//输出20，=是赋值符号
boolean b1 = true;
boolean b2 = false;
System.out.println(b1 == b2);//输出false
System.out.println(b2 = b1);//输出true
boolean b3 = false;
if(b3 == true){ //此处应该用 == ，如果写成=就是赋值b3为true
System.out.println("结果为真");
}else{
System.out.println("结果为假");
}
if(b3 = true){ //此处应该用 == ，如果写成=就是赋值b3为true
System.out.println("结果为真");
}else{
System.out.println("结果为假");
}
}
}
/*
运算符四 逻辑运算符
逻辑与& 短路与&& 逻辑或| 短路或|| 逻辑非! 逻辑异或^
a b a&b a&&b a|b a||b !a a^b
true true T T T T F F
true false F F T T F T
false true F F T T T T
false false F F F F T F
二进制中1代表true，0代表false
异或运算为两个变量相同为false，不同为true
逻辑运算的参与变量为boolean型
单与&和双与&&的运算结果相同，当左边符号为true时，二者都会执行符号右边的运算
当左边符号为false时，单与&两边都会运算，双语&&短路，右边不再运算
单或|与双或||的运算结果相同，当左边符号为false时，二者都会执行符号右边的运算
当左边符号为true时，单或|两边都会运算，双或||短路，右边不再运算
*/
class LogicTest {
public static void main(String[] args) {
boolean b1 = true;
int num1 = 10;
if(b1 & (num1++ > 0)){
System.out.println("Hello World!");// 输出
}else{
System.out.println("Hello China!");
}
System.out.println("num1 = " + num1);//输出11
boolean b2 = true;
int num2 = 10;
if(b2 && (num2++ > 0)){
System.out.println("Hello World!");//输出
}else{
System.out.println("Hello China!");
}
System.out.println("num2 = " + num2);//输出11
boolean b3 = false;
int num3 = 10;
if(b3 & (num3++ > 0)){
System.out.println("Hello World!");
}else{
System.out.println("Hello China!");//输出
}
System.out.println("num3 = " + num3);//输出11
boolean b4 = false;
int num4 = 10;
if(b4 && (num4++ > 0)){//num4++被短路，没有进行自增运算
System.out.println("Hello World!");
}else{
System.out.println("Hello China!"); //输出
}
System.out.println("num4 = " + num4);//输出10，因为短路，前面b4为false后，&&后面的表达式被短路不参与运算，num4没有自增1
//练习
int x1 = 1;
int y1 = 1;
if(x1++ == 2 & ++y1 == 2){ //x++ == 2 因为x是后++先取值为1不等于2所以是false，判断完后x再自增1为2，使用&运算，后面++y继续计算，y为2
x1 = 7;
}
System.out.println("x=" + x1 + ",y=" + y1);//x=2,y=2
int x2 = 1,y2 = 1;
if(x2++ == 2 && ++y2 == 2){ //x++ == 2 因为x是后++先取值为1不等于2所以是false，判断完后x再自增1为2,因为使用&&运算，后面被短路不再运算，y依然是1
x2 = 7;
}
System.out.println("x=" + x2 + ",y=" + y2);//x=2,y=1
int x3 = 1,y3 = 1;
if(x3++ == 1 | ++y3 == 1){ //x++ == 2 因为x是后++先取值为1等于1所以是true，判断完后x再自增1为2，执行大括号内赋值语句x为7，使用|运算，后面++y继续计算，y为2
x3 = 7;
}
System.out.println("x=" + x3 + ",y=" + y3);//x=7,y=2
int x4,y4;
x4 = 1;
y4 = 1;
if(x4++ == 1 || ++y4 == 1){ //x++ == 2 因为x是后++先取值为1等于1所以是true，判断完后x再自增1为2,执行大括号内赋值语句x为7，因为使用||运算，后面被短路不再运算，y依然是1
x4 = 7;
}
System.out.println("x=" + x4 + ",y=" + y4);//x=7,y=1
//if(){}使用方法为判断小括号内的Boolean值，如果是true就执行大括号内的命令，如果是false则不执行
//面试真题
boolean x5 = true;
boolean y5 = false;
short z = 42;
if(y5 == true);//小括号内为false，无影响
if((z++ == 42) && (y5 = true))z++;//z++ == 42 为true 后为 将y5 赋值为true 所以是true，总体为true
//System.out.println((z++ == 42) && (y5 = true)); //输出为false，会影响后面z数值所以注释掉
System.out.println("z=" + z);//输出z=44
//System.out.println((x5 = false) || (++z == 45));//输出为true
if((x5 = false) || (++z == 45))z++;//x5 = false 赋值为false，后为true，总体为true
System.out.println("z=" + z);//输出z=46
boolean x6 = true;
boolean y6 = false;
short z1 = 40;
if(y6 == true);//小括号内为false，无影响
if((z1++ == 40) && (y6 = true))z1++;//z1++ == 40 为true 后为 将y5 赋值为true 所以是true，总体为true
//System.out.println((z++ == 42) && (y6 = true)); //输出为false，会影响后面z1数值所以注释掉
System.out.println("z1=" + z1);//输出z1=42
//System.out.println((x6 = false) || (++z1 == 43));//输出为true
if((x6 = false) || (++z1 == 43))z1++;//x6 = false 赋值为false，后为true，总体为true
System.out.println("z1=" + z1);//输出z1=44
}
}
/*
运算符五 位运算符
左移 << 3<<2 结果 12
右移 >> 3>>2 结果 1
无符号右移 >>> 3>>2 结果 1
与运算 & 6&3 结果 2
或运算 | 6|3 结果 7
异或运算 ^ 6^3 结果 5
取反运算 ~ ~6 结果 -7
位移运算符操作的都是整数数据
& | ^ 是逻辑运算符还是位运算符根据前后变量类型判断
布尔型是逻辑运算，数值型是位运算
位运算针对底层二进制码做操作
左移两位相当于把二进制码后加两个0（不分正负），前面去掉两位
根据二进制转十进制的规律相当于对十进制数乘2的2次幂
在一定范围内（避免将1移动到最高位），每向左移移位相当于乘2（负数也是这个规律）
面试题；以最高效的方式计算 28
使用位移 2<<3 (22^3) 或者 8<<1 (8*2^1)
右移两位相当于把二进制码后面去掉两位，前面增加两位，补1还是补0取决原来的正负，正数用00补，负数用11补
无符号右移前面都用0来补位置
*/
import java.util.Scanner;
class BitMoveTest {
public static void main(String[] args) {
int i1 = 21;//21 二进制码为 0000 0000 0000 0000 0000 0000 0001 0101 （int为2个字Word4个字节byte32个bit）
int i2 = 21 << 2;// 左移两位后二进制码为 0000 0000 0000 0000 0000 0000 0101 0100
System.out.println("i1<<2=" + (21 << 2));//输出21*2^2=21*4=84
System.out.println("i1<<3=" + (21 << 3));//输出21*2^3=21*8=168
System.out.println("i1<<27=" + (21 << 27));//输出-1476395008, 因为1被最高位（第32位），变为负数
System.out.println("-i1<<2=" + (-21 << 2));//输出-21*2^2=21*4=-84
System.out.println("-i1<<3=" + (-21 << 3));//输出-21*2^3=21*8=-168
System.out.println("-i1<<27=" + (-21 << 27));//输出1476395008, 因为1被最高位（第32位），变为负数
int m = 12;
int n = 5;
System.out.println("m & n =" + (m & n));//输出4
System.out.println("m | n =" + (m | n));//输出13
System.out.println("m ^ n =" + (m ^ n));//输出9
System.out.println("m =" + (m ^ n ^ n));//输出12,m逻辑异或运算两次得到原数值
System.out.println("~ m =" + (~ m));//输出-13
System.out.println("m =" + (~ ~ m));//输出12
/*
0 0 0 0 1 1 0 0 12
& 0 0 0 0 0 1 0 1 5 二进制各位做逻辑与运算，1为true 0为false
0 0 0 0 0 1 0 0 4
0 0 0 0 1 1 0 0 12
| 0 0 0 0 0 1 0 1 5 二进制各位做逻辑或运算，1为true 0为false
0 0 0 0 1 1 0 1 13
0 0 0 0 1 1 0 0 12
^ 0 0 0 0 0 1 0 1 5 二进制各位做逻辑异或运算，1为true 0为false
0 0 0 0 1 0 0 1 9
~ 0 0 0 0 1 1 0 0 12 二进制包括符号位各位做取反运算，1变为0 ，0变为1
1 1 1 1 0 0 1 1 -13 -13的取反运算得到12
*/
//练习：交换两个变量的值
int num1 = 10;
int num2 = 20;
System.out.println("num1 =" + num1 + ",num2 = " + num2);
//方式1，使用临时变量,常用
int temp = num1;
num1 = num2;
num2 = temp;
System.out.println("num1 =" + num1 + ",num2 = " + num2);
//方式二，使用加法，不用定义临时变量，节省资源
//缺点：1,使用相加可能超出变量范围
// 2,只对数值型变量有用，其它类型不行
num1 = num1 + num2;
num2 = num1 - num2;
num1 = num1 - num2;
System.out.println("num1 =" + num1 + ",num2 = " + num2);
//方式三，使用位运算符，利用逻辑异或的性质 m = m ^ n ^ n n = m ^ n ^ m。使用m^n作为临时变量
//优点同方式二，且不会超出范围，缺点，只对数值变量适用。
num1 = num1 ^ num2;
num2 = num1 ^ num2;
num1 = num1 ^ num2;
System.out.println("num1 =" + num1 + ",num2 = " + num2);
//如何求一个0-255范围内的整数的十六进制，例如60的16进制表示形式为3c
//方法一，调用类直接求
String str1 = Integer.toBinaryString(60);
String str2 = Integer.toHexString(60);
System.out.println(str1);
System.out.println(str2);
//方法二，手写计算，综合利用位移运算，与二进制16进制的换算（二进制数每四位计算一个值为16进制的1位，从右到左）
Scanner scan = new Scanner(System.in);//创建Scanner实例
System.out.println("请输入0-255内的整数");
int i3 = scan.nextInt();//从键盘输入需要转换的整数
int i4 = i3 & 15;//15的二进制是00001111，参与&运算得出的结果就是i3的二进制的后四位
String a = (i4 > 9)?(char)(i4 -10 + 'A') +"" : i4 + "";//使用三元运算符判断16进制最后那位输出的是数字还是字符
//因为十六进制中没有10，第10为A， i4-10+'A'就可以输出C，前面也需要强转成char类型才能这样算。后面 + ""是为了转为String型
int temp1 = i3 >>> 4;// 无符号右移四位后就得到了i3的另外四位
int i5 = temp1 & 15;//原理同上
String b = (i5 > 9)?(char)(i5 -10 + 'A') +"" : i5 + "";//原理同上
if(i3 >= 0 && i3 <=255){
System.out.println("输入数字的16进制为" + b + "" + a);
}else{
System.out.println("输入的数字不在范围内");
}
}
}
/*
运算符六 三元运算符
涉及到1个变量的是单元运算符也叫单目运算符 例如位运算符 << >>> >>与自增 ++ 逻辑非！
涉及到两个变量的是双元运算符例如 + - 逻辑 & | ^
三元运算符说明涉及三个变量
1，结构 （条件表达式）？表达式1:表达式2
2 说明：条件表达式的结果为boolean型
根据表达式的结果，决定执行表达式1，还是表达式2;
如果表达式为 true ，执行表达式1；如果表达式为false，执行表达式2;
3 表达式1与表达式2必须为同种类型(或者可以统一为一种类型)
4 与if-else的关系
三元运算符可以用if语句表示，也就是三元一定可以改写为if但if不一定能改三元，if 的使用范围更广
当一个语句既可以用三元也可以用if的时候尽量用三元
三元运算符要求必须返回一个结果，if不用
if后面的代码块可以有多个语句，三元运算符不行
了解运算符的优先级
优先级就是表达式的运算顺序，表中上一行运算符优先于下一行
只有单目运算符，三元运算符，赋值运算符是从右向左运算的
一般使用中如果想对某部分优先运算可以加（），可以解决大部分问题
最高级 . () {} ; ,
R—L ++ – ~ !(date type) 单目运算符
L—R * / %
L—R + -
L—R << >> >>>
L—R < > <= >= instanceof
L—R == !=
L—R &
L—R ^
L—R |
L—R &&
L—R ||
R—L ()? ： 三元运算符
R—L = *= /= %=
+= -= <<= >>=
>>>= &= ^= |= 赋值运算符
*/
class TernaryOperatorTest {
public static void main(String[] args) {
//找到两个数中最大的
int m = 12;
int n = 5;
int max = (m > n)? m : n;
System.out.println(max);//输出12
double max2 = (m > n)?2 : 1.345;//可以编译
// max2 = (m > n)? 2 : "abc" 编译不通过，因为没办法统一类型
String maxStr = (m > n)? "m大":"n大";// 编译通过，都是String类型
System.out.println(maxStr);//输出m大
int m1 = 10;
int n1 = 10;
String maxStr2 = (m1 > n1)? "m1大":(m1 == n1)?"m1等于n1":"n1大";//三元运算符可以嵌套使用
System.out.println(maxStr2);//输出m1等于n1
//找到三个数中最大的
int n2 = 12;
int n3 = 30;
int n4 = 43;
int max3 = (n2 >= n3)? n2 : n3;
int max4 = (max3 >= n4)? max3 : n4;
System.out.println(max4);//输出30
//第二种嵌套写法
int max5 = (((n2 >= n3)? n2 : n3) >= n4)?((n2 >= n3)? n2 : n3) : n4;
System.out.println(max5);//输出30,不推荐这样写，因为代码复杂可读性不高，易错
//使用if-else 第一种
int max6;
if(n2 >= n3){
max6 = n2;
}else{max6 = n3;
}
if(n4>=max6){
max6 = n4;
}
System.out.println(max6);
//使用if-else 第二种
int max7;
if(n2 >= n3 && n2 >= n4){
max7 = n2;
}else if(n3 >= n2 && n3>= n4){
max7 = n3;
}else{
max7 =n4;
}
System.out.println(max7);
}
}
/*
关于进制与进制转换
1，所有数字在计算机底层都以二进制形式存在
2，常用进制二进制，十进制，八进制，16进制
二进制0-1以0b或者0B开头，八进制0-7以0开头，十六进制0-9 A-F（不分别大小写）以0x或0X开头
二进制转10进制计算为，123+1*22+121+0*20=8+4+2+0=14
源码，反码，补码
对于正数，三码合，一都一样
0的三码都是0
例子14（10），二进制为1110，
源码为8个bit ，00001110，第一位为符号位，代表正负，0为正，1为负
14的三码都为00001110
-14的源码为10001110
负数反码为除符号位不变，各个位置取反
-14的反码为11110001
负数补码为反码的基础上加1
-14的补码为11110010
补码的补码是源码
-69 补码为10111011，-69源码 为11000101
在计算机的底层都以补码的方式存储数据
127的源码为 01111111 -127的原码为11111111
-127的反码为10000000 -127的补码为10000001
-128的补码为10000000
所以在强制转换int 128 为byte时会是-128
528
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
