JavaEE基础：运算符、进制及进制转换、键盘输入-第三个学习日

本文主要是介绍JavaEE基础：运算符、进制及进制转换、键盘输入-第三个学习日，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

书接上回~~

JavaEE基础：java常量、变量、数据类型、数据类型转化、运算符-第二个学习日_dragonl2d的博客-CSDN博客

位运算符：

对于数据在内存中的表示按照位移的方式进行运行的符号
位移运算符，只能对于整型数据进行操作
分类 << >> >>>
<< 左移运算符，每移动一位，相当于把原来的数字扩大为原来的2倍，移动几位，就相当于乘以2的几次方
>> 右移运算符每移动一位，相当于把原来的数字除以2移动几位，就相当于除以2的几次方
>>> 无符号右移 只能操作正数

代码：

class Demo01 {
	public static void main(String[] args) {
		int i = 10;
		System.out.println(i << 1);// i * 2
		System.out.println(i << 2);
		int j = 32;
		System.out.println(j >> 1);
		System.out.println(j >> 2);
		int m = -8;
		System.out.println(m >> 1);
		int n = 16;
		System.out.println(n >>> 1);
	}
}

三元(目)运算符：

元：可以操作数据的个数
三元运算符，可以操作三个数据的运算符
格式：
1. 布尔表达式1? 表达式2 : 表达式3;
表达式: java中由常量或者变量组成的具有返回值的式子就是表达式
表达式1：必须是一个布尔类型的表达式，true或者false
表达式2或者3：可以是任意类型的数据
执行流程：
1. 如果表达式1结果是true，此时就选择表达式2的值，作为整个三元运算符的结果
2. 如果表达式1计结果为false，此时就选择表达式3的值，作为整个三元运算符的结果

代码：

class Demo02 {
	public static void main(String[] args) {
		// 布尔表达式1 ? 表达式2 : 表达式3;
		//需求：比较两个整数的大小  获取最大的一个
		int a = 10;
		int b = 3;
		//布尔表达式1：比较a和b的值谁大  
		int max = a > b ? a : b;
		System.out.println("最大值为：" + max);

		// 三元表达式最终会有值产出  产出的值一定是看表达式2和3的类型
		//接受考虑表达式2和3是什么类型
		String str = a > b ? "前一个数字大" : "后一个数字大";
		System.out.println(str);

        // 判断一个数是奇数还是偶数
	    int num = 4;
	    //判断一个数是奇数还是偶数， 对2进行取余运算，如果== 0 说明是偶数
	    String str1 = num % 2 == 0 ? num + "是偶数" : num + "是奇数";
		System.out.println(str1);
        
        // 使用三元运算符判断一个年份是否是闰年
		int year = 2001;
		// 布尔表达式 ：
		String str2 = year % 4 == 0 && year % 100 != 0 || year % 400 == 0 ? year + "是闰年" : year + "不是闰年";
		System.out.println(str2);
        
	}
}

进制：

计数和进位的制度，几进制就是逢几进一
生活中最常用的就是十进制
1. 六十进制：时分秒逢60进1
2. 七进制星期逢7进1
3. 十二进制月份逢12 进1
计算机中常见进制
1. 进制名称使用符号
2. 二进制 0b
3. 八进制 0
4. 十进制无符号
5. 十六进制 0x
注意：
1. 除了十进制以外其他进制的数据都要指明他采用的进制数，需要在数值前面加上对应的符号
2. 十六进制，从10以后使用字母来进行表示
  - a ——10
  - b ——11
  - c ——12
  - d ——13
  - e ——14
  - f ——15

代码：

class Demo03 {
	public static void main(String[] args) {
		//二进制
		int i = 0b10;
		System.out.println(i);
		//八进制
		System.out.println(011);
		// 十六进制
		System.out.println(0x11);
	}
}

进制转换

其他进制转十进制

转换原因：生活中和实际项目开发中，常用的是十进制
转换方式：基数乘以系数的权次幂求和
1. 基数：指定进制的每一位数
2. 系数：进制数
3. 权次幂：基数后数据位数

代码：

class Demo04 {
	public static void main(String[] args) {
		//二进制转十进制
		// 0b1010
		// 基数  0b 1 0 1 0     基数要和每一个系数的n次幂进行相乘  最终再求和
		// 系数  2
		// 1 * 2^3 + 0 * 2 ^ 2 + 1 * 2^1 + 0 * 2 ^0 = 10
		System.out.println(0b1010);

		// 八进制  0 7 0 3
		// 7*8^2 + 3 * 8^0 = 451
		System.out.println(0703);

		// 十六进制
			//0x 3 a c
			// 3 ^ 16^2 + 10*16 + 12 = 940
			System.out.println(0x3ac);
	}
}

十进制转其他进制：

转换原因：计算机中不同场景下的运算和存储会使用不同的进制，例如底层是二进制，颜色可以用十六进制方式表示
转换方式：除基倒余法(辗转相除法)
1. 例如：十进制数52 转换成二进制结果 0b110100

52 / 2 .................0

26 / 2 .................0

13 / 2 .................1

6 / 2 .................0

3 / 2 .................1

0b110100

代码：

class Demo05 {
	public static void main(String[] args) {
		//将十进制数据69 分别转为 二进制 八进制 十六进制
		/*
			69 / 2 = 34...1
			34 / 2 = 17...0
			17 / 2 = 8 ...1
			8  / 2 = 4 ...0
			4  / 2 = 2 ...0
			2  / 2 = 1 ...0
						  1
		
		*/
		System.out.println(0b1000101);
		/*
			转为八进制
			69 / 8 = 8 ...5
			8 / 8  = 1 ...0
			              1
		*/
		System.out.println(0105);
		/*
			转为十六进制
			69 / 16 = 4...5
			              4 
		*/
		System.out.println(0x45);
	}
}

二进制转其他进制：

二进制转八进制：从右往左，三位一组（2^3=8），不够高位补0 每组用等值的八进制码代替

二进制转十六进制：从右往左，四位自足（2^4=16），不够高位补0 每组用等值的十六进制码代替

代码：

class Demo06 {
	public static void main(String[] args) {
		/* 八进制：10110111011 		
			 010 110 111 011
	         2   6   7   3
		*/
		System.out.println(0b10110111011);
		System.out.println(02673);
		/* 十六进制：10110111011 
			0101 1011 1011
			 5    b   b
		*/
		System.out.println(0x5bb);
	}
}

其他进制转二进制:

八进制转二进制，将每一位八进制数据转换成对应的3位二进制数，组合起来

十六进制转二进制，将每一位十六进制数转为对应的4位二进制数，组合起来

代码:

class Demo07 {
	public static void main(String[] args) {
		//八进制  552 
		/*
			二进制  
			5     5    2
			101  101  010
		
		*/
		System.out.println(0b101101010);
		System.out.println(0552);
		// 十六进制  bc 转为二进制
		/*
			b  c
			11  12
			1011  1100
		*/
		System.out.println(0xbc);
		System.out.println(0b10111100);
		//八进制转十六进制
		/*
			八进制  552 
			1 0110 1010  按4位一组 再组合
			1  6   a
		*/
		System.out.println(0x16a);
		//十六进制转八进制
		/*
			十六进制  bc
			010 111 100
			2   7   4
		*/
		System.out.println(0274);
	}
}

原码反码补码:

计算机中的数据，分为无符号数据和有符号数据，java语言都是有符号位的，十进制数和小数在计算机中都是以二进制的形式存储，而且存储的有符号的整数都是存储他们的补码
java有符号的数据的表示规则
1. 符号：0代表正 1代表负放在数值的最高位
2. 有符号的数据可以表示为：原码、反码、补码
  1. 原码：数值的二进制表示，但是在做加法和减法运算时，在cpu的内部始终都是用的加法，为了实现减法这个过程，就出现了反码，但可以发现的是0000 0000表示+0，1000 0000表示-0，而0是不应该带有符号位的，所以有了补码的出现
原码、反码、补码的计算规则：
1. 原码：最高位表示数的符号，其他表示数值，就是二进制码的本身即： +7：0000 0111 -7：1000 0111
2. 反码：正数的反码和原码相同，负数的反码是由原码的符号位不变，其余按位取反即： +7：0000 0111 反码 0000 0111 -7：1000 0111 反码 1111 1000
3. 补码：正数的补码和原码相同，负数的补码是由原码符号位不变，其余按位取反，最低位 +1 即： -7：1000 0111 补码 1111 1001

byte类型的最值的推导：

java中的整数数据类型各自占不同的内存大小，也有对应的数值范围
byte取值范围 -128至127 最值的推导过程
1. 正数 0000 0001 -- 0111 1111 补码和原码一致对应值 1-127
2. 负数 1000 0001 -- 1111 1111 这些数据在计算机中都是以补码的形式存在，转换成原码之后，其取值范围 -1到-127；
3. 0000 0000表示0
4. 1000 0000表示-128
  - -1的原码 1000 0001 补码 1111 1111
  - -127的原码 1111 1111 补码 1000 0001
  - 两者相加结果为 1 1000 0000 -128
  - 所以计算机中1000 0000在计算机中表示数字-128

位运算符的详解：

位运算符：主要按照每个二进制位进行运算，其操作数和运算结果都是整数类型，只能对byte、short、char、int、long
Java语言中位运算符分为：位逻辑运算符和位移运算符两类
分类：
& 与按位进行与运算

| 或按位进行或运算

~ 非按位进行取反运算

^ 异或按位进行异或运算

<< 左位移按位左移，数值扩大2的倍数

>> 右位移按位右移，值向右移动一位

>>> 无符号右移 只针对正数按位右移，数值缩小2的倍数

按位&：

补码按位逐位相与，全1为1，否则为0
参数运算的数字，低位对齐，高位不足补0
举例：4 & 5 -4 & 5

4 100 1000 0100 -4

5 101 1111 1011 -4反码

100 结果为4 1111 1110 -4补码

0000 0101 5

0000 0100 结果为4

按位 | ：

补码按位逐位相或，全0则0，否则为1
参与运算的数字，低位对齐，高位不足补0
举例： 4 | 5 -4 | 5

4 100 1000 0100 -4

5 101 1111 1011 -4反码

101 结果为5 1111 1110 -4补码

0000 0101 5

1111 1111 结果的补码

1111 1110 结果的反码补码-1

1000 0001 结果为-1 反码符号位不变，其他取反

按位取反~：

对一个操作数进行运算，补码按位逐位取反，1变0,0变1
参与运算的数字，低位对齐，高位不足补0
举例： ~11

0000 1011

1111 0100 结果的补码

1111 0011 结果的反码补码-1

1000 1100 结果为-12 反码符号位不变，其他取反

按位异或^：

补码按位逐位异或，相同为0，不同为1
参与运算的数字，低位对齐，高位不足补0
举例：4 ^ 5 -4 ^ 5

4 100 1000 0100 -4

5 101 1111 1011 -4反码

001 结果为1 1111 1110 -4补码

0000 0101 5

1111 1011 结果的补码

1111 1010 结果的反码补码-1

1000 0101 结果为-5

位移运算符：

操作数想某个方向移动指定的二进制位数，运算效率高
<< 按位左移，补码按位左移，高位舍弃，低位补0，移动一位扩大2倍
>> 按位右移：补码按位右移，最高位补符号位，低位舍弃，移动一位缩小为原来的二分之一
1. 正数右移得到的结果和除法一致
2. 负数可能不一致，运算过程，将负数转为对应补码，右移，移动时高位补1，将移动后的补码结果转换，得到原码，解出最终结果
>>> 无符号右移，最高位补0，最终正数运算完成之后结果缩小为原来的二分之一
举例：11<<1 -11<<1

0000 1011 1000 1011

0001 0110 结果：22 1111 0100 反码

1111 0101 -11的补码

1110 1010 结果的补码舍弃最高位

1110 1001 结果的反码

1001 0110 结果为：-22

4>>1 -11>>1

0000 0100 1000 1011

0000 0010 结果：2 1111 0100 反码

1111 0101 -11的补码

1111 1010 结果的补码

1111 1001 结果的反码

1000 0110 结果为： -6

>>>不能操作负数

-1>>>1

1000 0001

1111 1111 补码

1111 1111 右移1位右移不管多少都是1

代码：

class Demo08 {
	public static void main(String[] args) {
		System.out.println(-4&5);
		System.out.println(-5|6);
		System.out.println(-4^-5);
		System.out.println(~11);
		System.out.println("<<<<<<<<<<<<<<<<<我是分割线>>>>>>>>>>>>>>>");
		System.out.println(11<<1);
		System.out.println(-11<<1);
		System.out.println(-11>>1);
        System.out.println(11>>>1);
		// -1 
		// 1000 0001
		// 1111 1111 补码
		// 1111 1111 右移1位
		//右移不管多少都是1
		//无符号右移只能操作正数，所以不存在不准确
	}
}

键盘录入Scanner：

Scanner是jdk提供给我们的一个类，是已经定义好的，我们只需要知道功能是怎么用就可以
Scanner类在jdk的 java.util.Scanner;
作用：在程序运行过程中，可以使用Scanner类来实现获取从键盘输入的数据，提高数据来源的灵活性
只有java.lang包下的类，不需要导包，使用其他包下的类都需要导包
使用步骤：
1. 导包
  - 目的：为了让jvm定位到Scanner类型所在的具体位置
  - 导入方式：在类的声明上方，使用关键字 import 表示导入
  - import java.util.Scanner;
2. 创建键盘录入对象：Scanner sc = new Scanner(System.in);
3. 调用 sc对象的nextInt()方法，获取键盘录入的一个整数：int x = sc.nextInt();
4. 使用x完成运算

键盘录入整数:

代码:

//1、在类的声明上方，导入键盘录入类所在的包
import java.util.Scanner;
class Demo09 {
	public static void main(String[] args) {
		//2、在主方法内创建键盘录入对象
		Scanner sc = new Scanner(System.in);
		//3、调用sc对象的nextInt() 方法 获取一个整数，并使用对应类型接受
		int x= sc.nextInt();
		//4、使用刚才录入的整数完成运算
		System.out.println("键盘录入的整数为：" + x);
		//nextInt()方法可以重复调用  多次调用  
		//想要录入几个数，就调用几次这个方法
		System.out.println("再录入一个整数：");
		int x2 = sc.nextInt();
		System.out.println(x2);
	}
}

键盘录入一段字符串:

调用 Scanner对象中的next()方法录入一段字符串，使用字符串类型接收

代码:

import java.util.Scanner;
class Demo10 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一段字符串");
		String str = sc.next();
		System.out.println(str);//该录入方式中不能存在空格，如果有空格，只能录入空格之前的
	}
}

键盘还可以录入其他数据类型，常见的还有nextLine()、nextDouble() 、nextFloat()、 nextByte()······，具体的方式都一样。保证录入的数据类型和定义的数据类型相同即可~

这篇关于JavaEE基础：运算符、进制及进制转换、键盘输入-第三个学习日的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

Java教程