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

书接上回~~

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

位运算符:

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

代码:

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. 元:可以操作数据的个数
  2. 三元运算符,可以操作三个数据的运算符
  3. 格式:
    1. 布尔表达式1? 表达式2 : 表达式3;
  4. 表达式: java中由常量或者变量组成的具有返回值的式子就是表达式
  5. 表达式1:必须是一个布尔类型的表达式,true或者false
  6. 表达式2或者3:可以是任意类型的数据
  7. 执行流程:
    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. 计数和进位的制度,几进制就是逢几进一
  2. 生活中最常用的就是十进制
    1. 六十进制: 时分秒  逢60进1
    2. 七进制   星期  逢7进1
    3. 十二进制    月份  逢12 进1
  3. 计算机中常见进制
    1. 进制名称 使用符号
    2. 二进制   0b
    3. 八进制   0
    4. 十进制 无符号
    5. 十六进制 0x
  4. 注意:
    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. 转换方式:基数乘以系数的权次幂求和
    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. 转换原因:计算机中不同场景下的运算和存储会使用不同的进制,例如底层是二进制,颜色可以用十六进制方式表示
  2. 转换方式:除基倒余法(辗转相除法)
    1. 例如: 十进制数52 转换成二进制 结果 0b110100

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

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

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

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

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

    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);
	}
}

原码反码补码:

  1. 计算机中的数据,分为无符号数据和有符号数据,java语言都是有符号位的,十进制数和小数在计算机中都是以二进制的形式存储,而且存储的有符号的整数都是存储他们的补码
  2. java有符号的数据的表示规则
    1. 符号:0代表正  1代表负 放在数值的最高位
    2. 有符号的数据可以表示为:原码、反码、补码
      1. 原码:数值的二进制表示,但是在做加法和减法运算时,在cpu的内部始终都是用的加法为了实现减法这个过程,就出现了反码,但可以发现的是0000 0000表示+0,1000 0000表示-0,而0是不应该带有符号位的,所以有了补码的出现
  3. 原码、反码、补码的计算规则
    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类型的最值的推导:

  1. java中的整数数据类型各自占不同的内存大小,也有对应的数值范围
  2. 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

位运算符的详解:

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

    &          与            按位进行与运算

    |           或            按位进行或运算

    ~          非            按位进行取反运算

    ^         异或          按位进行异或运算

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

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

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

按位&:

  1. 补码按位逐位相与,全1为1,否则为0
  2. 参数运算的数字,低位对齐,高位不足补0
  3. 举例: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

按位 | :

  1. 补码按位逐位相或,全0则0,否则为1
  2. 参与运算的数字,低位对齐,高位不足补0
  3. 举例: 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. 对一个操作数进行运算,补码按位逐位取反,1变0,0变1
  2. 参与运算的数字,低位对齐,高位不足补0
  3. 举例:  ~11                                           

       0000 1011                                          

       1111 0100     结果的补码                                

       1111 0011     结果的反码       补码-1 

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

按位异或^:

  1. 补码按位逐位异或,相同为0,不同为1
  2. 参与运算的数字,低位对齐,高位不足补0
  3. 举例: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

位移运算符:

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

  1. Scanner是jdk提供给我们的一个类,是已经定义好的,我们只需要知道功能是怎么用就可以
  2. Scanner类在jdk的 java.util.Scanner;
  3. 作用:在程序运行过程中,可以使用Scanner类来实现获取从键盘输入的数据,提高数据来源的灵活性
  4. 只有java.lang包下的类,不需要导包,使用其他包下的类都需要导包
  5. 使用步骤:
    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基础:运算符、进制及进制转换、键盘输入-第三个学习日

 

上一篇:66.QT-线程并发、QTcpServer并发、QThreadPool线程池


下一篇:【Tomcat】申请Tomcat证书,即SSL证书