2.5 原码反码补码
前言 : 计算机中的数据，都是以二进制补码的形式在运算，而补码则是通过反码和原码推算出来的
原码 :（可直观看出数据大小）
就是二进制定点表示法，即最高位为符号位，【0】表示正，【1】表示负，其余位表示数值的大小。
通过一个字节表示+7和-7，代码：byte b1 = 7; byte b2 = -7;一个字节等于8个比特位，也就是8个二进制位
0(符号位) 0000111
1(符号位) 0000111
反码 : 正数的反码与其原码相同；负数的反码是对其原码逐位取反，但符号位除外。
补码 : （数据以该状态进行运算）正数的补码与其原码相同；负数的补码是在其反码的末位加1。
2.6 位运算-基本位运算符
package com.itheima.demo; public class Demo2 { /* 位运算: 位运算符指的是二进制位的运算，先将十进制数转成二进制后再进行运算。 在二进制位运算中，1表示true，0表示false。 & 位与 : 遇false则false, 遇0则0 00000000 00000000 00000000 00000110 // 6的二进制 & 00000000 00000000 00000000 00000010 // 2的二进制 ----------------------------------------- 00000000 00000000 00000000 00000010 // 结果: 2 | 位或 : 遇true则true, 遇1则1 ^ 位异或 : 相同为false, 不同为true ~ 取反 : 全部取反, 0变1, 1变0 (也包括符号位) 00000000 00000000 00000000 00000110 // 6的二进制补码 ~ 11111111 11111111 11111111 11111001 - 1 // -1求反码 ------------------------------------ 11111111 11111111 11111111 11111000 // 反码推原码 10000000 00000000 00000000 00000111 // -7 */ public static void main(String[] args) { System.out.println(6 & 2); System.out.println(~6); } }
2.7 位运算-位移运算符
位运算概述 : 位运算符指的是二进制位的运算，先将十进制数转成二进制后再进行运算。在二进制位运算中，1表示true，0表示false。
位运算符介绍 :
代码 :
package com.itheima.demo; public class Demo3 { /* 位移运算符: << 有符号左移运算，二进制位向左移动, 左边符号位丢弃, 右边补齐0 运算规律: 向左移动几位, 就是乘以2的几次幂 12 << 2 (0)0000000 00000000 00000000 000011000 // 12的二进制 ----------------------------------------------------------------------------- >> 有符号右移运算，二进制位向右移动, 使用符号位进行补位 运算规律: 向右移动几位, 就是除以2的几次幂 000000000 00000000 00000000 0000001(1) // 3的二进制 ----------------------------------------------------------------------------- >>> 无符号右移运算符, 无论符号位是0还是1，都补0 010000000 00000000 00000000 00000110 // -6的二进制 */ public static void main(String[] args) { System.out.println(12 << 1); // 24 System.out.println(12 << 2); // 48 } }
package com.itheima.demo; public class Demo4 { /* ^ 运算符的特点 一个数, 被另外一个数, 异或两次, 该数本身不变 */ public static void main(String[] args) { System.out.println(10 ^ 5 ^ 10); } }
3.基础练习
3.1 数据交换
- 案例需求
已知两个整数变量a = 10，b = 20，使用程序实现这两个变量的数据交换 最终输出a = 20，b = 10;
- 代码实现
package com.itheima.test; public class Test1 { /* 需求：已知两个整数变量a = 10，b = 20，使用程序实现这两个变量的数据交换 最终输出a = 20，b = 10; 思路： 1. 定义一个三方变量temp，将a原本记录的值，交给temp记录 （a的值，不会丢了） 2. 使用 a 变量记录 b 的值，（第一步交换完毕，b的值也丢不了了） 3. 使用 b 变量记录 temp的值，也就是a原本的值 （交换完毕） 4. 输出 a 和 b 变量即可 */ /* 动态初始化格式： 数据类型[][] 变量名 = new 数据类型[m][n]; m表示这个二维数组，可以存放多少个一维数组 n表示每一个一维数组，可以存放多少个元素 */ public static void main(String[] args) { int a = 10; int b = 20; // 将a原本记录的值，交给temp记录 （a的值，不会丢了） int temp = a; // 用 a 变量记录 b 的值，（第一步交换完毕，b的值也丢不了了） a = b; // 使用 b 变量记录 temp的值，也就是a原本的值 （交换完毕） b = temp; // 输出 a 和 b 变量即可 System.out.println("a=" + a); System.out.println("b=" + b); } }
3.2 数组反转【应用】
- 案例需求 :
已知一个数组 arr = {19, 28, 37, 46, 50}; 用程序实现把数组中的元素值交换，
交换后的数组 arr = {50, 46, 37, 28, 19}; 并在控制台输出交换后的数组元素
- 实现步骤 :
定义两个变量, start和end来表示开始和结束的指针.
确定交换条件, start < end 允许交换
循环中编写交换逻辑代码
每一次交换完成, 改变两个指针所指向的索引 start++, end--
循环结束后, 遍历数组并打印, 查看反转后的数组
- 代码实现 :
package com.itheima.test; public class Test2 { /* 需求：已知一个数组 arr = {19, 28, 37, 46, 50}; 用程序实现把数组中的元素值交换， 交换后的数组 arr = {50, 46, 37, 28, 19}; 并在控制台输出交换后的数组元素。 步骤: 1. 定义两个变量, start和end来表示开始和结束的指针. 2. 确定交换条件, start < end 允许交换 3. 循环中编写交换逻辑代码 4. 每一次交换完成, 改变两个指针所指向的索引 start++, end-- 5. 循环结束后, 遍历数组并打印, 查看反转后的数组 */ public static void main(String[] args) { int[] arr = {19, 28, 37, 46, 50}; // 1. 定义两个变量, start和end来表示开始和结束的指针. int start = 0; int end = arr.length -1; // 2. 确定交换条件, start < end 允许交换 // 4. 每一次交换完成, 改变两个指针所指向的索引 start++, end-- // for(int start = 0, end = arr.length -1; start < end; start++, end--) for( ; start < end; start++, end--){ // 3. 循环中编写交换逻辑代码 int temp = arr[start]; arr[start] = arr[end]; arr[end] = temp; } for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); } } }
3.3 二维数组概述
概述 : 二维数组也是一种容器，不同于一维数组，该容器存储的都是一维数组容器
3.4 二维数组动态初始化
动态初始化格式：
数据类型[][] 变量名 = new 数据类型[m][n];
m表示这个二维数组，可以存放多少个一维数组
n表示每一个一维数组，可以存放多少个元素
package com.itheima.demo; public class Demo1Array { /* 动态初始化格式： 数据类型[][] 变量名 = new 数据类型[m][n]; m表示这个二维数组，可以存放多少个一维数组 n表示每一个一维数组，可以存放多少个元素 */ public static void main(String[] args) { // 数据类型[][] 变量名 = new 数据类型[m][n]; int[][] arr = new int[3][3]; /* [[I@10f87f48 @ : 分隔符 10f87f48 : 十六进制内存地址 I : 数组中存储的数据类型 [[ : 几个中括号就代表的是几维数组 */ System.out.println(arr); /* 二维数组存储一维数组的时候, 存储的是一维数组的内存地址 */ System.out.println(arr[0]); System.out.println(arr[1]); System.out.println(arr[2]); System.out.println(arr[0][0]); System.out.println(arr[1][1]); System.out.println(arr[2][2]); // 向二维数组中存储元素 arr[0][0] = 11; arr[0][1] = 22; arr[0][2] = 33; arr[1][0] = 11; arr[1][1] = 22; arr[1][2] = 33; arr[2][0] = 11; arr[2][1] = 22; arr[2][2] = 33; // 从二维数组中取出元素并打印 System.out.println(arr[0][0]); System.out.println(arr[0][1]); System.out.println(arr[0][2]); System.out.println(arr[1][0]); System.out.println(arr[1][1]); System.out.println(arr[1][2]); System.out.println(arr[2][0]); System.out.println(arr[2][1]); System.out.println(arr[2][2]); } }
3.5 二维数组访问元素的细节问题
问题 : 二维数组中存储的是一维数组, 那能不能存入 [提前创建好的一维数组] 呢 ?
答 : 可以的
代码实现
package com.itheima.demo; public class Demo2Array { /* 问题: 二维数组中存储的是一维数组, 那能不能存入 [提前创建好的一维数组] 呢 ? 答 : 可以的 */ public static void main(String[] args) { int[] arr1 = {11,22,33}; int[] arr2 = {44,55,66}; int[] arr3 = {77,88,99,100}; int[][] arr = new int[3][3]; arr[2][3] = 100; arr[0] = arr1; arr[1] = arr2; arr[2] = arr3; System.out.println(arr[1][2]); System.out.println(arr[2][3]); } }
3.6 二维数组静态初始化
完整格式 : 数据类型 变量名 = new 数据类型{ {元素1, 元素2...} , {元素1, 元素2...}
简化格式 : 数据类型 变量名 = { {元素1, 元素2...} , {元素1, 元素2...} ...};
代码实现 :
package com.itheima.demo; public class Demo3Array { /* 完整格式：数据类型[][] 变量名 = new 数据类型[][]{ {元素1, 元素2...} , {元素1, 元素2...} ...}; 简化格式: 数据类型[][] 变量名 = { {元素1, 元素2...} , {元素1, 元素2...} ...}; */ public static void main(String[] args) { int[] arr1 = {11,22,33}; int[] arr2 = {44,55,66}; int[][] arr = {{11,22,33}, {44,55,66}}; System.out.println(arr[0][2]); int[][] array = {arr1,arr2}; System.out.println(array[0][2]); } }
3.7 二维数组遍历
- 需求 :
已知一个二维数组 arr = {{11, 22, 33}, {33, 44, 55}};
遍历该数组，取出所有元素并打印
- 步骤 :
- 遍历二维数组，取出里面每一个一维数组
- 在遍历的过程中，对每一个一维数组继续完成遍历，获取内部存储的每一个元素
- 代码实现 :
package com.itheima.test; public class Test1 { /* 需求: 已知一个二维数组 arr = {{11, 22, 33}, {33, 44, 55}}; 遍历该数组，取出所有元素并打印 步骤: 1. 遍历二维数组，取出里面每一个一维数组 2. 在遍历的过程中，对每一个一维数组继续完成遍历，获取内部存储的每一个元素 */ public static void main(String[] args) { int[][] arr = {{11, 22, 33}, {33, 44, 55}}; // 1. 遍历二维数组，取出里面每一个一维数组 for (int i = 0; i < arr.length; i++) { //System.out.println(arr[i]); // 2. 在遍历的过程中，对每一个一维数组继续完成遍历，获取内部存储的每一个元素 //int[] temp = arr[i]; for (int j = 0; j < arr[i].length; j++) { System.out.println(arr[i][j]); } } } }
3.8 二维数组求和
需求 :
某公司季度和月份统计的数据如下：单位(万元) 第一季度：22,66,44 第二季度：77,33,88 第三季度：25,45,65 第四季度：11,66,99
步骤 :
- 定义求和变量，准备记录最终累加结果
- 使用二维数组来存储数据，每个季度是一个一维数组，再将4个一维数组装起来
- 遍历二维数组，获取所有元素，累加求和
- 输出最终结果
