NaN自己都不等于自己的数:
public class Hello
{
publicstatic void main(String[] args)
{
//自己都不等于自己的数NaN;
double num = 0.0 / 0.0 ; //结果为NaN;
System.out.println(num==num);//结果为:false
}
}
算数运算符:
/*
需求：算数运算符：用来处理四则运算的符号；
*/
public classArithmeticOperatorsDemo
{
publicstatic void main(String[] args)
{
//操作数：
System.out.println(10+2);//结果为：12
System.out.println(10-2);//结果为：8
System.out.println(10*2);//结果为：20
System.out.println(10/2);//结果为：5
System.out.println("-----------------------");
//操作字符：
System.out.println('A'+'B');//结果为：131
//操作字符串：
System.out.println("Ameir_"+"yang");//结果为：Ameir_yang
//NaN，自己都不等于自己：
double number = 0.0 / 0.0 ; // 0.0 / 0.0 = NaN 记住NaN,因为这是唯一的一个'自己不等于自己'的数.
System.out.println(number==number); //结果为: false ;
// 当 0 为分母 的时候:
//System.out.println(100/0);//出现错误:Exceptionin thread "main" java.lang.ArithmeticException: 错误的原因: / by zero
//上面的System.out.println(100/0);修改为System.out.println(100.0/0);或者System.out.println(100/0.0);或者System.out.println(100.0/0.0);就不会报错 ,但是输出值为:Infinity 和 -Infinity.
System.out.println(100/0.0);// 输出结果是:Infinity;正无穷大;
System.out.println(-100/0.0);//输出结果是:-Infinity;负无穷大;
System.out.println(10/3);//输出结果为:3 ; 其原因是:/ 取得是整数部分 , 5取得是余数部分.
System.out.println(9876/1000*1000);//结果为:9000 ; 运算过程为: 9876/1000 =9(因为'/'取整) , 9 * 1000 = 9000 ;
}
}
/*
小结:
知识点:
(1): +,-,*,/运算都是从左往右进行运算.
(2): 数值'+': 直接运算就可以.
字符'+':先将字符对照Ascll码表转换成数值,然后再进行数值之间的相加.
字符串'+':字符串的'+'和数值,字符的不一样,因为字符串的'+'起的作用是连接作用 , 将字符串与其他类型的数值连接在一起.
(3): NaN: 0.0 / 0.0 = NaN 它是唯一一个自己不等于自己的数值 ; NaN是double类型的数值;
(4): 特殊情况(当0作为分母,参与运算的时候):
1):当一个正数除以 double类型数值:0.0时 , 得出的结果为:Infinity正无穷大.
2):当一个负数除以 double类型数值:0.0时 , 得出的结果为:-Infinity负无穷大.
(5):取整:/ ;
取余:% ;
*/
自增 (++), 自减 (--)以及前置和后置的面试问题
/*
需求:++ 和 -- 的问题: 前置++,--和 后值++,--的出现的一些题.
*/
public classArithmeticOperatorsDemo2
{
publicstatic void main(String[] args)
{
/*
++前置情况:
++a: 表示 a变量自身先加1 , 再运算 ;
++后置情况:
a++: 表示 a变量自身先加1,然后把递增1之前的原始值拿去做运算;
*/
inta1 = 5 ;
intb1 = ++a1 ;
System.out.println("a1="+a1+" b1="+b1);//结果为:a1:6b1:6 . 原因: a1先++,a1+1 = 5 + 1 = 6 , 不管怎么样 a1都自增1 , 最后a1 的值都是6 ,因为只要++,a1的值就会加1.当a1自增完毕之后,然后返回一个自增完成后的a1的值,并且将此值赋给b1. 所以最后 a1 = 6 , b1 = 6 ;
System.out.println("--------------------------------");
inta2 = 5 ;
intb2 = a2++ ;
System.out.println("a2="+a2+"b2="+b2);//结果为:a2:6b2:5 . 原因: a2先++ ,a2+1=5+1=6 , 不管怎么样 a2都要自增1,变成6,也就是说不管怎样最后a2的值都是6 , 当a2的值自增完成之后,然后会返回一个值,这个值是:a2自增之前的原来的数值.然后将这个是数值返回给b2参加赋值运算. 所以最后 a2 = 6 , b2 = 5 ;
//++ , --等自增的面试题.
//面试题1 ;
intnum1 = 1 ;
num1= num1 ++ ;
System.out.println(num1);
//结果为: 1 .
/*原因是:
第一步:num1 ++ = num1 + 1 ;
第二步:返回num1自增之前(运算之前)的值;
第三步:将返回的数值再赋给num1.
第四步:得出结果;
*/
intnum2 = 1;
num2= ++num2 ;
System.out.println(num2);
//结果为: 2 ;
/*
原因是:
第一步:++num2 = num2 + 1 ;
第二步:返回num2自增完成(运算完)的数值;
第三步:将返回的数值再赋给num2.
第四步:得出结果;
*/
//面试题2:
inti = 5 ;
i++ ; //i自己++,不管是前置++,还是后置++,最后i都增加1;
System.out.println(i); //结果为:6
++i;//i自己++,不管是前置++,还是后置++,最后i都增加1;
System.out.println(i);//结果为:7
inta = ++i ;
System.out.println(a);//结果为:8;
System.out.println(i);//结果为:8;
intb = i++ ;
System.out.println(b);//结果为:8;
System.out.println(i);//结果为:9;
}
}
/*
小结:
知识点:
(1)前置++: 先进行++运算,运算完成之后,返回的是运算完之后(自增完)的数值;
b = ++a(原) ;
第一步:a(原) + 1 = a(后);
第二步:返回: a(后) ;
第三步:赋值: b = a(后);
后置++: 先进行++运算,运算完成之后,返回的是运算之前,自增之前的数值;
b = a++(原) ;
第一步:a(原) + 1 = a(后) ;
第二步:返回:a(原) ;
第三步:赋值:b= a(原) ;
*/
赋值运算符:(= += -= *= %= /= ^=) 这些赋值运算符号的用法,(编辑器不报错的一些原因),还有+=自带隐式数据类型转换;
/*
需求:赋值运算符:(= += -= *= %= /= ^=) 这些赋值运算符号的用法;
*/
public classAssigningOperatorDemo
{
publicstatic void main(String[] args)
{
//'='赋值
Stringname;
name= "Ameir_yang" ;
System.out.println(name);
intage = 20 ;
System.out.println(age+"岁");
//'+='赋值
intnumber = 5 ;
number+= 10 ;
System.out.println(number);
shortnumber1 = 5 ;
number1+= 10 ;
//十进制数如果不进行特殊说明的话， 默认为 int 类型 。所以10为int类型，而不是short类型，number1 为 short 类型， 10为int类型 ， 所以是 大转小 ， 需要进行强制转换 ，short number1 = (short)(number1+10);
//所以 number1 +=10 这句话等价于 : short number1 =(short)(number1+10) ;
//同时说明了一点: '+=' 等类似的赋值运算符都含有隐式强制转换.(理解为偷偷地在底层进行了一次强制转换)
System.out.println(number1);
inti = 1 ;
i+= 1 ;
System.out.println(i);
i= 2 ;
i-=1 ;
System.out.println(i);
i= 3 ;
i*= 2 ;
System.out.println(i);
i= 4 ;
i/= 2 ;
System.out.println(i);
i= 5 ;
i^= 2 ;
System.out.println(i);
}
}
/*
小结：
（1）举个例子:
byte number = 5 ; //这一步不会报错: number为byte类型 , 5为int类型 , 又因为5在byte的取值范围中,所以编译器不会报错,而是在底层进行一次悄悄的转换;
number += 5 ; //number为byte类型变量,5为int类型的变量, 因为+=自带隐式数据类型转换,所以 number+=5 == byte number = (byte)(number+5) number + 5 为 int 类型,因为number为byte类型,会被自动转换成int类型,然后int类型赋值给byte类型的number,所以int类型再被强制转换成byte类型赋给number.
System.out.println(number); //输出结果为:10;
*/
需要: 比较运算符 ( == , != , >= , <= , > , <),这些比较运算符的结果都是boolean类型的true/false.
/*
需要: 比较运算符 ( == , != , >= , <= , > , <) ,这些比较运算符的结果都是boolean类型的true/false.
*/
public classComparisonOperatorDemo
{
publicstatic void main(String[] args)
{
//注意:'='是赋值符号,'=='是比较符号.
boolean b1 = 4 == 4 ;//这句话的意思是: 4==4 返回的结果为 true , 然后返回的结果true再给b1赋值.
System.out.println(b1);//true
System.out.println(4!=4);//false
System.out.println(3!=4);//true
System.out.println(100>5);//true
System.out.println(5<100);//true
System.out.println(100>100);//false
System.out.println(100>=100);//true
System.out.println(100<=100);//true
}
}
/*
小结:注意:'='是赋值符号,'=='是比较符号.
*/
三元运算符在分页业务逻辑中使用:
/*
需求:三元运算符在分页业务逻辑中使用:
给出一共有46条数据,要求每一页最多10条数据,计算:一共多少页?
*/
public classPageDemo
{
publicstatic void main(String[] args)
{
int totalCount = 46 ; //总数据;
int pageSize = 10 ; //一页的数据数量;
//计算总页数
intsumNumber = totalCount % pageSize == 0? totalCount / pageSize : totalCount /pageSize + 1;
System.out.println(sumNumber); //结果为:5页;
//翻页:上一页和下一页
//(1)翻到上一页;
int pagenumber = 7 ; //当前所在的页数.
int pagenumber1 = pagenumber - 1 > 1 ?pagenumber - 1 : 1 ; //如果当前页数向前翻一页,所翻到的页数大于最小页数1,那么就返回当前页数减1,如果当前页数向前翻一页,所翻到的页数的数值小于等于最小页数1,那么就返回最小页数1,因为如果等于1,说明正好翻到第一页,如果小于1,那么说明之前就在第一页,不能再往后翻页了.(当前页数 - 1 与最小页数 1 作比较,如果大于最小页数 1 ,那么就说明前面一页不是第一页,可以继续往前面翻页,所以返回当前页数-1 ,如果当前页数-1<=最小页数1 ,说明 不能再往前面翻页了,所以返回最小页数 1. )
System.out.println(pagenumber1);
//(2)翻到下一页;
intpagemax = 10 ;
intpagenumber2 = 7 ;
int pagenumber3 = pagenumber2 + 1 < pagemax ?pagenumber2 + 1 : pagemax ; //当前页数 + 1 与最大页数pagemax作比较,如果小于最大页数pagemax,那么就说明后面一页不是最后一页,可以继续往后面翻页,所以返回当前页数+1,如果当前页数+1>=最大页数pagemax,说明不能再往后面翻页了,所以返回最大页数 pagemax.
System.out.println(pagenumber3);
}
}
/*
小结:
(1)判断书页的临界状态,如:第一页和最后一页,往前翻页不能小于 第一页 , 往后翻页不能大于最后一页. 往前翻一页就 当前页数 减 1 , 往后翻页 就 当前页数 + 1 ;
*/
三元运算符的使用方法
/*
需求: 三元运算符的使用方法;
*/
public classTernaryOperatorDemo
{
publicstatic void main(String[] args)
{
//四舍五入 ;
doublenumber = 3.67 ;
intnum = (int)number ;
doubleber = number - (double)num ;
intnumber1 = ber > 0.5 ? num + 1 : num ;
System.out.println(number1);
//最大值和最小值;
inta = 20 ;
intb = 30 ;
intMax = a > b ? a : b ;
System.out.println(Max);
//奇数偶数判断;
intnumber3 = 17 ;
String str = number3 % 2 ==0? "偶数": "奇数" ;
System.out.println(str);
}
}
/*
小结:
(1)四舍五入:
需求:现在给一个小数，需要求出其四舍五入之后的结果，怎么完成该功能？
1:获取3.49的整数部分--3;
2:获取3.49的小数部分--3.49-3 --> 0.49
3:把0.49和0.5做比较
0.49>= 0.5 --> 3 + 1
0.49< 0.5 --> 3
三元运算符,三目运算符.
数据类型 变量= boolean表达式? 值1 : 值2;
如果:boolean表达式结果为true, 三元运算表达式结果就是值1;
:boolean表达式结果为false,三元运算表达式结果就是值2;
(2)判断奇数偶数:判断一个数的奇偶,只需要判断除以2之后的余数是否为0,不能直接判断余数是否为1.
*/
位运算符号: & , | , ^ 的运算.
public class Father
{
publicstatic void main(String[] args)
{
//位运算符号: & ;
System.out.println(5&3);//结果为:1
/*
5的二进制为: 00000101 ;
3的二进制为: 00000011 ;
进行'&' 操作的三种情况: 1 & 1 = 1 , 0 & 1 = 0 , 0 & 0 = 0 (1为正确,0为错误)
00000101
& 00000011
---------------
00000001----> 十进制: 1
*/
//位运算符号: | ;
System.out.println(5|3);//结果为:7
/*
5的二进制为: 00000101 ;
3的二进制为: 00000011 ;
进行'|' 操作的三种情况: 1 | 1 = 1 , 0 | 1 = 1 , 0 | 0 = 0 (1为正确,0为错误)
00000101
| 00000011
---------------
00000111----> 十进制: 7
*/
//位运算符号: ^ ;
System.out.println(5^3);//结果为:6
/*
5的二进制为: 00000101 ;
3的二进制为: 00000011 ;
进行'^' 操作的三种情况: 1 ^ 1 = 0 , 0 ^ 1 = 1 , 0 ^ 0 = 0 (1为正确,0为错误)
00000101
^ 00000011
---------------
00000110----> 十进制: 6
*/
System.out.println(~5);
/*
'~'的意思为全部位上都取反:
如:5的二进制为:00000101
全部位上取反之后: 11111010 是一个负数
原码:11111010;
反码:10000101;
补码:10000110;--> 十进制:-6
(因为计算机看的是数字的补码) 一个十进制数通过迭代除以2的方式算出来二进制数,这个二进制数不管是正数的还是负数的求出来都是补码,只不过正数的不用再算原码了.
(如果是正数直接看原码就行,因为正数的原码=补码=反码)
(如果是负数,那么就应该换算成补码,这样计算机才能查看十进制数)
*/
}
}
(1) 十进制通过迭代除以2的方法求出来二进制,所得的二进制是原码,不是补码. 正数的补码=原码=反码 , 但是负数的不相等,补码=原码取反加一.通过这种方式再求出负数的补码.
(2)计算机只识别二进制的补码,不识别二进制的原码和反码.
>> , << , >>> 移位操作符号;
(解释一)
public class Father
{
publicstatic void main(String[] args)
{
//不管是正数 , 负数 , 左移 ,右移都是对二进制数的补码进行操作的.
//一.正数的移位
//移位运算
// "<<" 左移
System.out.println(2<<3);//结果为16
System.out.println(16>>3);//结果为2
/*
(1)"<<" 左移
2 向左移动3 位:
运算过程:
2的二进制:00000000_00000000_00000000_00000010;
左移3位:(把最前面三位"000"挤掉,然后在从最后面补上"000")
移动之后:00000_00000000_00000000_00000010000(16的补码)
又因为16为正数,所以16的原码=补码=反码;
计算机只识别补码: 00000_00000000_00000000_00000010000 --->十进制为16;
(2)">>" 右移
16 向右移动 3位 :
16的二进制:00000_00000000_00000000_00000010000
右移3位:(把最后面3位挤掉,然后在从最前面补上与移位之前二进制符号位相同符号的3位.)
先挤掉后三位:00000_00000000_00000000_00000010
又因为移位之前的符号位为 0 ,所以最前面补0: 00000000_00000000_00000000_00000010 ----> 十进制: 2
*/
//二.负数的移位:
System.out.println(-16>>3);//结果为-2
/*
-16的二进制数为:10000_00000000_00000000_00000010000(原码)
16二进制数:
原码:10000_00000000_00000000_00000010000
反码:11111_11111111_11111111_11111101111
补码:11111_11111111_11111111_11111110000
右移3位: (把最后面3位挤掉,然后在从最前面补上与移位之前二进制符号位相同符号的3位.)
先挤掉后三位:11111_11111111_11111111_11111110
又因为移位之前的符号位为 1 ,所以最前面补1: 11111111_11111111_11111111_11111110 -----> -2的补码;
*/
}
}
/*
<<：将操作数的二进制码整体左移指定位数，左移之后的空使用“0”来补充。
>>：将操作数的二进制码整体右移指定位数，右移之后的空使用“符号位”来补充：
若是正数使用“0”补充；
若是负数使用“1”补充；（操作负数：取反，求补，操作，取反，求补）
>>>：将操作数的二进制码整体右移指定位数，右移之后的空位使用“0”来补充。
*/
解释二:
/*
需求: 位运算:'&' , '|' , '^' 的用法 ;
移位运算:"<<" , ">>" , ">>>" 的用法;
*/
public class Hello
{
publicstatic void main(String[] args)
{
//位运算
//3 与 5
//(1)'&'运算
System.out.println(5& 3);
/*运算过程: 换算
5的二进制:00000101;(原码) -----> 00000101;(补码)
换算 因为正数的 原码=补码=反码.
3的二进制:00000011;(原码) -----> 00000011;(补码)
5的补码 00000101
3的补码 00000011
&
----------------------
00000001(数字1的原码补码反码)---->结果为: 1 ;
*/
//(2)'|'的运算
System.out.println(5 | 3);
/*运算过程: 换算
5的二进制:00000101;(原码) -----> 00000101;(补码)
换算 因为正数的 原码=补码=反码.
3的二进制:00000011;(原码) -----> 00000011;(补码)
5的补码 00000101
3的补码 00000011
|
----------------------
00000111(数字7的原码反码补码)------>结果为: 7
*/
//(3)'^'的运算
System.out.println(5^ 3);
/*运算过程: 换算
5的二进制:00000101;(原码) -----> 00000101;(补码)
换算 因为正数的 原码=补码=反码.
3的二进制:00000011;(原码) -----> 00000011;(补码)
5的补码 00000101
3的补码 00000011
^
----------------------
00000110(数字6的原码补码反码)---->结果为: 6
*/
//移位运算
//(1) 2左移3位
System.out.println(2 << 3); //结果为:16
/*
int 类型为32位;
2的二进制:00000000_00000000_00000000_00000010;(原码)
2 : 原码= 反码 = 补码 = 00000000_00000000_00000000_00000010
计算机只识别补码.
00000000_00000000_00000000_00000010向左移动3位:去除前三位,在最后面加三位0,得到:00000_00000000_00000000_00000010000 -> 16的原码;
*/
//(2) 16右移3位;
System.out.println(16 >> 3);//结果为2 ;
/*
16的二进制为:00000_00000000_00000000_00000010000
向右移动3位,去除后三位,然后再从前三位添加三位与符号位相同符号,得到:00000000_00000000_00000000_00000010 --> 2的原码;
*/
//(3) -16 右移 3 位
System.out.println(-16>> 3);
/*
-16的二进制为:10000_00000000_00000000_00000010000(原码)
负数的原码不等于补码;
补码= 原码 取反加一 ;
-16 : 原码: 10000_00000000_00000000_00000010000;
反码:11111_11111111_11111111_11111101111;
补码:11111_11111111_11111111_11111110000;
-16的补码向右移动3位,去除最后面的三位,再从最前面添加三位与符号位相同的符号:11111111_11111111_11111111_11111110-------> -2的原码;
*/
}
}
/*
小结:
(1)移位补齐:
1)左移: 缺的位置上补'0' ;
2)右移: 缺的位置上补'符号位的值',如果符号位为1,那么就补1,如果为0,就补0;
(2)移位:一个十进制数向左向右移位,计算机是操作的这个十进制数的补码,操作完成之后,得出的是另一个数的原码.
一个十进制数number:
第一步:先求出number的原码;
第二步:通过原码求出补码;
第三步:计算机操作number的补码,进行移位操作.
第三步:移位完成,得到另一个数的原码.
第四步:通过原码,求出另一个数.
(3) 计算机是对 十进制数 的 二进制补码 进行 移位操作 的.
*/
扫一扫
370
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
