Java【第二篇】基本语法之--进制、运算符

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

进制

生活中的进制：七进制（一周）、十二进制（12小时制）、二十四进制（24小时制）、六十进制（分钟）

对于整数，有四种表示方式：
二进制（binary）：0,1 ，满 2 进 1.以 0b 或 0B 开头。
十进制（decimal）：0-9 ，满 10 进 1.
八进制（octonary）：0-7 ，满 8 进1. 以数字 0 开头表示。
十六进制（hex）：0-9 及 A-F，满 16 进1. 以 0x 或 0X开头表示。此处的A-F不区分大小写。

int a = 10;
int b = 0b10; // 二进制以0b开头
int c = 010; // 八进制以0开头
int d = 0X10; // 十六进制以0x开头 System.out.println(a); // 10
System.out.println(b); // 2
System.out.println(c); // 8
System.out.println(d); // 16

所有数字在计算机底层都以二进制形式存在。

二进制数分为两种：
无符号二进制，只能存储正整数
有符号二进制，可以存储正数和负数，最高位为符号位，0表示正数，1表示负数

计算机以补码的形式保存所有的整数，验证：

// 计算机内部是使用补码来存储和表示值
System.out.println(0b00000000000000000000000000000101); // 5
System.out.println(0b11111111111111111111111111111011); // -5

正数的补码与其原码相同；负数的补码是在其反码的末位加1。

原码：直接将一个数值换成二进制数。

反码：是对原码按位取反，只是最高位（符号位）保持不变。

原码
原始二进制值
反码
正数：反码和原码相同，如5的反码 00000000 00000000 00000000 00000101
负数：符号位不变，其余各位取反，如5的反码 11111111 11111111 11111111 11111010
补码
正数：补码和原码相同，如5的补码 00000000 00000000 00000000 00000101
负数：反码+1，如5的补码 11111111 11111111 11111111 11111011

Java整数常量默认是int类型，当用二进制定义整数时，其第32位是符号位；当是long类型时，二进制默认占64位，第64位是符号位

byte 的范围：-128 ~ 127

byte范围：-128 - 127
1的原码（补码）：
0000 0001-1的原码：
1000 0001
反码：
1111 1110
补码：
1111 1111127的原码（补码）：
0111 1111-127的原码：
1111 1111
反码：
1000 0000
补码：
1000 0001

最小负数-128补码：1000 0000

进制的基本转换

十进制二进制互转
十进制转成二进制除以2取余数
二进制转成十进制乘以2的幂数

15 = 1 * 2^0 + 1 * 2^1 + 1 * 2^2 + 1 * 2^3

14：0b1110

类似的方法，可以进行下面的互转
二进制八进制互转
二进制十六进制互转
十进制八进制互转
十进制十六进制互转

算术运算符

前缀自增自减和后缀自增自减的区别：
前缀自增自减
先进行自增或自减，然后再执行表达式
后缀自增自减
先执行表达式，然后再进行自增或自减

int x = 1;
System.out.println(++x); // 2，先加1,再输出
int y = 1;
System.out.println(y++); // 1，先输出，再加1

注意：

如果对负数取模，可以把模数负号忽略不记，如：5%-2=1。但被模数是负数就另当别论。
对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。例如：int x=3510;x=x/1000*1000; x的结果是？
“+”除字符串相加功能外，还能把非字符串转换成字符串.例如（将字符串与数值相加时会进行拼接）：

System.out.println("5+5="+5+5); // 打印结果是：5+5=55
System.out.println("" + d + e); // 借助空字符串，实现将数字拼接

赋值运算符

符号：=
扩展赋值运算符： +=, -=, *=, /=, %=

不支持如下写法：

int a=b=c=1;

比较运算符（关系运算符）

注1：比较运算符的结果都是boolean型，也就是要么是true，要么是false。
注2：比较运算符“==”不能误写成“=” 。

System.out.println(1<2<3); // 不支持此写法
System.out.println('a'<'b'); // 可以用于字符的比较，比较的是ascii码

逻辑运算符

逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3 && x<6 。
“&”和“&&”的区别：
单&时，左边无论真假，右边都进行运算；
双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算，System.out.println(false && 1/0>1); // 除数为0，执行不会报错，说明右侧未执行

和“||”的区别同理，双或时，左边为真，右边不参与运算。
异或( ^ )与或( | )的不同之处是：对于 ^ 而言，当左右都为true时，结果为false。【两边不同为true，相同为false】

位运算符

针对二进制的位进行运算，需要将值转换为二进制后进行按位运算

位运算符和逻辑运算符的区别：
逻辑运算符是针对布尔值进行运算
位运算符是针对二进制数的位进行运算

与：两位都为1，则为1，否则为0
或：只要有一个1，则为1，否则为0
非：如果为1，则为0，如果为0，则为1
异或：如果两位相同，则为0，否则为1
左移：将二进制的所有位都向左移指定的位数，末尾补0
右移：将二进制的所有位都向右移指定的位数，高位补符号位
无符号右移：将二进制的所有位都向右移指定的位数，高位补0

三元运算符（也称为三目运算符、条件运算符）

一目运算符 i++

二目运算符 a+b

格式：(条件表达式)?表达式1：表达式2；
如果条件为true，运算后的结果是表达式1执行结果；
如果条件为false，运算后的结果是表达式2执行结果；

类型兼容，意思是冒号两边的类型是此处定义的String
String res = a > 3? "1>3":true;

package com.uncleyong;public class TestOperator {
public static void main(String[] args) {
//取模
int r = 10 % 3;
System.out.println(r); // 1 //自增
int i = 10; //i++: 先取 i 值, 在运算(i = i + 1)
int j = i++;
System.out.println(j);
System.out.println(i); int m = 100;
//++m: 先运算(m = m + 1), 后取值
int n = ++m;
System.out.println(n);
System.out.println(m); //+：字符串相加
String str = "abc";
String str2 = "def"; String str3 = str + str2; //abcdef
System.out.println(str3); //如果对负数取模，可以把模数负号忽略不记
System.out.println(10 % -3); // 1
//如果被模的数是负数, 则先对其绝对值进行取模运算, 结果在加上一个负号
System.out.println(-10 % 3); // -1 System.out.println(-10 % -3); // -1 //整数之间做除法时，只保留整数部分而舍弃小数部分
int x=3510;
x= x / 1000 * 1000;
System.out.println(x); // 3000 //+ 除字符串相加功能外，还能把非字符串转换成字符串
String str4 = "1";
System.out.println(str4 + 100); // 1100 //逻辑运算符
int a = 10;
int b = 20; // &: 与运算符, 当且仅当两边都为真时, 表达式的结果为 true
System.out.println(a > 5 & b < 30); // true
System.out.println(a > 15 & b < 30); // false
System.out.println(a > 5 & b < 20); // false // |: 或运算符, 当且仅当两边都为假时, 表达式结果为 false
System.out.println(a > 5 | b < 30); // true
System.out.println(a > 15 | b < 3); // false
System.out.println(a > 5 | b < 20); // true // ^: 异或运算符, 当且仅当两边的表达式的结果不同时为 true, 否则为 false
System.out.println(a > 5 ^ b < 30); //false
System.out.println(a > 15 ^ b < 3); //false
System.out.println(a > 5 ^ b < 20); //true // !: 取反运算符.
System.out.println(!(a > 5)); //false //短路逻辑运算符: &&, ||. 若短路逻辑运算符前的表达式已经可以确定整个表达式的值,
//则不再判断短路运算符后边的表达式的值
System.out.println(a > 15 && (10 / 0 == 1)); //false //位运算符
int c = 3; //0000 0011 //左移运算符
System.out.println(c << 2); //0000 1100 -> 12 3 * (2*2) = 12 //右移运算符
System.out.println(c >> 2); //0000 0000 -> 0 3 / (2 * 2) = 0; //无符号右移运算符
int d = -1;
System.out.println(d >> 1); //-1
System.out.println(d >>> 1); //2147483647 //& 位运算符
/*
* 0000 0010
* & 0000 0011
* ___________
* 0000 0010
*/
System.out.println(2 & 3); //2 //三元运算符
String e = d > 3 ? "d > 3" : "d <= 3";
System.out.println(e); // d <= 3 //编译不能通过, 因为 : 的两边必须是表达式, 且必须是类型兼容的表达式
//d > 3 ? System.out.println("a") : System.out.println("b"); String res = d > 3 ? ">3" : "<=3";
}
}