Debug,进制转换和数组
1.1 什么是Debug模式
是供程序员使用的程序调试工具,它可以用于查看程序的执行流程,也可以用于追踪程序执行过程来调试程序。
1.2 Debug介绍与操作流程
-
如何加断点
-
选择要设置断点的代码行,在行号的区域后面单击鼠标左键即可
-
-
如何运行加了断点的程序
-
在代码区域右键Debug执行
-
-
看哪里
-
看Debugger窗口
-
看Console窗口
-
-
点哪里
-
点Step Into (F7)这个箭头,也可以直接按F7
-
-
如何删除断点
-
选择要删除的断点,单击鼠标左键即可
-
如果是多个断点,可以每一个再点击一次。也可以一次性全部删除
-
2. 进制的介绍与书写格式
2.1 进制的介绍与书写格式
代码 :
1 public class Demo1 { 2 /* 3 十进制:Java中,数值默认都是10进制,不需要加任何修饰。 4 二进制:数值前面以0b开头,b大小写都可以。 5 八进制:数值前面以0开头。 6 十六进制:数值前面以0x开头,x大小写都可以。 7 8 注意: 书写的时候, 虽然加入了进制的标识, 但打印在控制台展示的都是十进制数据. 9 */ 10 public static void main(String[] args) { 11 System.out.println(10); 12 System.out.println("二进制数据0b10的十进制表示为:" + 0b10); 13 System.out.println("八进制数据010的十进制表示为:" + 010); 14 System.out.println("十六进制数据0x10的十进制表示为:" + 0x10); 15 } 16 }
2.2 任意进制到十进制的转换
2.3 进制转换-十进制到任意进制转换
2.3.1 : 十进制到二进制的转换
公式:除基取余使用源数据,不断的除以基数(几进制,基数就是几)得到余数,直到商为0,再将余数倒着拼起来即可。
需求:将十进制数字11,转换为2进制。
实现方式:源数据为11,使用11不断的除以基数,也就是2,直到商为0。
2.3.2 : 十进制到十六进制的转换
公式:除基取余使用源数据,不断的除以基数(几进制,基数就是几)得到余数,直到商为0,再将余数倒着拼起来即可。
需求:将十进制数字60,转换为16进制。
实现方式:源数据为60,使用60不断的除以基数,也就是16,直到商为0。
结论:十进制到任意进制的转换
公式:除基取余使用源数据,不断的除以基数(几进制,基数就是几)得到余数,直到商为0,再将余数倒着 拼起来即可
2.4 快速进制转换法
8421码:
8421码又称BCD码,是BCD代码中最常用的一种BCD: (Binary-Coded Decimal) 二进制码十进制数在这种编码方式中,每一位二进制值的1都是代表一个固定数值,把每一位的1代表的十进制数加起来得到的结果就是它所代表的十进制数。
2.5 原码反码补码
前言 : 计算机中的数据,都是以二进制补码的形式在运算,而补码则是通过反码和原码推算出来的
原码 :(可直观看出数据大小)
就是二进制定点表示法,即最高位为符号位,【0】表示正,【1】表示负,其余位表示数值的大小。
通过一个字节表示+7和-7,代码:byte b1 = 7; byte b2 = -7;一个字节等于8个比特位,也就是8个二进制位
0(符号位) 0000111
1(符号位) 0000111
反码 : 正数的反码与其原码相同;负数的反码是对其原码逐位取反,但符号位除外。
补码 : (数据以该状态进行运算)正数的补码与其原码相同;负数的补码是在其反码的末位加1。
2.6 位运算-基本位运算符
1 package com.itheima.demo; 2 3 public class Demo2 { 4 /* 5 位运算: 6 7 位运算符指的是二进制位的运算,先将十进制数转成二进制后再进行运算。 8 在二进制位运算中,1表示true,0表示false。 9 10 & 位与 : 遇false则false, 遇0则0 11 12 00000000 00000000 00000000 00000110 // 6的二进制 13 & 00000000 00000000 00000000 00000010 // 2的二进制 14 ----------------------------------------- 15 00000000 00000000 00000000 00000010 // 结果: 2 16 17 | 位或 : 遇true则true, 遇1则1 18 19 ^ 位异或 : 相同为false, 不同为true 20 21 ~ 取反 : 全部取反, 0变1, 1变0 (也包括符号位) 22 23 00000000 00000000 00000000 00000110 // 6的二进制补码 24 ~ 11111111 11111111 11111111 11111001 25 26 - 1 // -1求反码 27 ------------------------------------ 28 11111111 11111111 11111111 11111000 // 反码推原码 29 30 10000000 00000000 00000000 00000111 // -7 31 */ 32 public static void main(String[] args) { 33 System.out.println(6 & 2); 34 System.out.println(~6); 35 } 36 }
2.7 位运算-位移运算符
位运算概述 : 位运算符指的是二进制位的运算,先将十进制数转成二进制后再进行运算。在二进制位运算中,1表示true,0表示false。
位运算符介绍 :
代码 :
1 package com.itheima.demo; 2 3 public class Demo3 { 4 /* 5 位移运算符: 6 7 << 有符号左移运算,二进制位向左移动, 左边符号位丢弃, 右边补齐0 8 运算规律: 向左移动几位, 就是乘以2的几次幂 9 10 12 << 2 11 12 (0)0000000 00000000 00000000 000011000 // 12的二进制 13 14 ----------------------------------------------------------------------------- 15 >> 有符号右移运算,二进制位向右移动, 使用符号位进行补位 16 运算规律: 向右移动几位, 就是除以2的几次幂 17 18 000000000 00000000 00000000 0000001(1) // 3的二进制 19 20 ----------------------------------------------------------------------------- 21 22 >>> 无符号右移运算符, 无论符号位是0还是1,都补0 23 24 010000000 00000000 00000000 00000110 // -6的二进制 25 26 */ 27 public static void main(String[] args) { 28 System.out.println(12 << 1); // 24 29 System.out.println(12 << 2); // 48 30 31 } 32 } 33 34 35 package com.itheima.demo; 36 37 public class Demo4 { 38 /* 39 ^ 运算符的特点 40 41 一个数, 被另外一个数, 异或两次, 该数本身不变 42 */ 43 public static void main(String[] args) { 44 System.out.println(10 ^ 5 ^ 10); 45 } 46 }
3.基础练习
3.1 数据交换
案例需求
已知两个整数变量a = 10,b = 20,使用程序实现这两个变量的数据交换 最终输出a = 20,b = 10;
代码实现
1 package com.lvsen.test; 2 3 public class Test1 { 4 /* 5 需求:已知两个整数变量a = 10,b = 20,使用程序实现这两个变量的数据交换 6 最终输出a = 20,b = 10; 7 8 9 思路: 10 1. 定义一个三方变量temp,将a原本记录的值,交给temp记录 (a的值,不会丢了) 11 2. 使用 a 变量记录 b 的值,(第一步交换完毕,b的值也丢不了了) 12 3. 使用 b 变量记录 temp的值,也就是a原本的值 (交换完毕) 13 4. 输出 a 和 b 变量即可 14 */ 15 /* 16 动态初始化格式: 17 18 数据类型[][] 变量名 = new 数据类型[m][n]; 19 m表示这个二维数组,可以存放多少个一维数组 20 n表示每一个一维数组,可以存放多少个元素 21 */ 22 public static void main(String[] args) { 23 int a = 10; 24 int b = 20; 25 26 // 将a原本记录的值,交给temp记录 (a的值,不会丢了) 27 int temp = a; 28 // 用 a 变量记录 b 的值,(第一步交换完毕,b的值也丢不了了) 29 a = b; 30 // 使用 b 变量记录 temp的值,也就是a原本的值 (交换完毕) 31 b = temp; 32 33 // 输出 a 和 b 变量即可 34 System.out.println("a=" + a); 35 System.out.println("b=" + b); 36 } 37 }
3.2 数组反转【应用】
案例需求 :
已知一个数组 arr = {19, 28, 37, 46, 50}; 用程序实现把数组中的元素值交换,
交换后的数组 arr = {50, 46, 37, 28, 19}; 并在控制台输出交换后的数组元素
实现步骤 :
-
定义两个变量, start和end来表示开始和结束的指针.
-
确定交换条件, start < end 允许交换
-
循环中编写交换逻辑代码
-
每一次交换完成, 改变两个指针所指向的索引 start++, end--
-
循环结束后, 遍历数组并打印, 查看反转后的数组
代码实现 :
1 package com.lvsen.test; 2 3 public class Test2 { 4 /* 5 需求:已知一个数组 arr = {19, 28, 37, 46, 50}; 用程序实现把数组中的元素值交换, 6 交换后的数组 arr = {50, 46, 37, 28, 19}; 并在控制台输出交换后的数组元素。 7 8 步骤: 9 1. 定义两个变量, start和end来表示开始和结束的指针. 10 2. 确定交换条件, start < end 允许交换 11 3. 循环中编写交换逻辑代码 12 4. 每一次交换完成, 改变两个指针所指向的索引 start++, end-- 13 5. 循环结束后, 遍历数组并打印, 查看反转后的数组 14 */ 15 public static void main(String[] args) { 16 int[] arr = {19, 28, 37, 46, 50}; 17 // 1. 定义两个变量, start和end来表示开始和结束的指针. 18 int start = 0; 19 int end = arr.length -1; 20 // 2. 确定交换条件, start < end 允许交换 21 // 4. 每一次交换完成, 改变两个指针所指向的索引 start++, end-- 22 // for(int start = 0, end = arr.length -1; start < end; start++, end--) 23 for( ; start < end; start++, end--){ 24 // 3. 循环中编写交换逻辑代码 25 int temp = arr[start]; 26 arr[start] = arr[end]; 27 arr[end] = temp; 28 } 29 30 for (int i = 0; i < arr.length; i++) { 31 System.out.println(arr[i]); 32 } 33 } 34 }
3.3 二维数组概述
概述 : 二维数组也是一种容器,不同于一维数组,该容器存储的都是一维数组容器
3.4 二维数组动态初始化
动态初始化格式:
数据类型[][] 变量名 = new 数据类型[m][n];
m表示这个二维数组,可以存放多少个一维数组
n表示每一个一维数组,可以存放多少个元素
1 package com.lvsen.demo; 2 3 public class Demo1Array { 4 /* 5 动态初始化格式: 6 7 数据类型[][] 变量名 = new 数据类型[m][n]; 8 m表示这个二维数组,可以存放多少个一维数组 9 n表示每一个一维数组,可以存放多少个元素 10 */ 11 public static void main(String[] args) { 12 // 数据类型[][] 变量名 = new 数据类型[m][n]; 13 int[][] arr = new int[3][3]; 14 /* 15 [[I@10f87f48 16 17 @ : 分隔符 18 10f87f48 : 十六进制内存地址 19 I : 数组中存储的数据类型 20 [[ : 几个中括号就代表的是几维数组 21 */ 22 System.out.println(arr); 23 24 /* 25 二维数组存储一维数组的时候, 存储的是一维数组的内存地址 26 */ 27 System.out.println(arr[0]); 28 System.out.println(arr[1]); 29 System.out.println(arr[2]); 30 31 System.out.println(arr[0][0]); 32 System.out.println(arr[1][1]); 33 System.out.println(arr[2][2]); 34 35 // 向二维数组中存储元素 36 arr[0][0] = 11; 37 arr[0][1] = 22; 38 arr[0][2] = 33; 39 40 arr[1][0] = 11; 41 arr[1][1] = 22; 42 arr[1][2] = 33; 43 44 arr[2][0] = 11; 45 arr[2][1] = 22; 46 arr[2][2] = 33; 47 48 // 从二维数组中取出元素并打印 49 System.out.println(arr[0][0]); 50 System.out.println(arr[0][1]); 51 System.out.println(arr[0][2]); 52 System.out.println(arr[1][0]); 53 System.out.println(arr[1][1]); 54 System.out.println(arr[1][2]); 55 System.out.println(arr[2][0]); 56 System.out.println(arr[2][1]); 57 System.out.println(arr[2][2]); 58 } 59 }
3.5 二维数组访问元素的细节问题
问题 : 二维数组中存储的是一维数组, 那能不能存入 [提前创建好的一维数组] 呢 ?
答 : 可以的
代码实现
1 package com.lvsen.demo; 2 3 public class Demo2Array { 4 /* 5 问题: 二维数组中存储的是一维数组, 那能不能存入 [提前创建好的一维数组] 呢 ? 6 答 : 可以的 7 */ 8 public static void main(String[] args) { 9 int[] arr1 = {11,22,33}; 10 int[] arr2 = {44,55,66}; 11 int[] arr3 = {77,88,99,100}; 12 13 int[][] arr = new int[3][3]; 14 15 arr[2][3] = 100; 16 17 arr[0] = arr1; 18 arr[1] = arr2; 19 arr[2] = arr3; 20 21 System.out.println(arr[1][2]); 22 System.out.println(arr[2][3]); 23 } 24 }
3.6 二维数组静态初始化
完整格式 : 数据类型 变量名 = new 数据类型{ {元素1, 元素2...} , {元素1, 元素2...}
简化格式 : 数据类型 变量名 = { {元素1, 元素2...} , {元素1, 元素2...} ...};
代码实现 :
1 package com.lvsen.demo; 2 3 public class Demo3Array { 4 /* 5 完整格式:数据类型[][] 变量名 = new 数据类型[][]{ {元素1, 元素2...} , {元素1, 元素2...} ...}; 6 7 简化格式: 数据类型[][] 变量名 = { {元素1, 元素2...} , {元素1, 元素2...} ...}; 8 */ 9 public static void main(String[] args) { 10 int[] arr1 = {11,22,33}; 11 int[] arr2 = {44,55,66}; 12 13 int[][] arr = {{11,22,33}, {44,55,66}}; 14 System.out.println(arr[0][2]); 15 16 int[][] array = {arr1,arr2}; 17 System.out.println(array[0][2]); 18 } 19 }
3.7 二维数组遍历
需求 :
已知一个二维数组 arr = {{11, 22, 33}, {33, 44, 55}};
遍历该数组,取出所有元素并打印
步骤 :
-
遍历二维数组,取出里面每一个一维数组 2. 在遍历的过程中,对每一个一维数组继续完成遍历,获取内部存储的每一个元素
代码实现 :
1 package com.lvsen.test; 2 3 public class Test1 { 4 /* 5 需求: 6 7 已知一个二维数组 arr = {{11, 22, 33}, {33, 44, 55}}; 8 遍历该数组,取出所有元素并打印 9 10 步骤: 11 1. 遍历二维数组,取出里面每一个一维数组 12 2. 在遍历的过程中,对每一个一维数组继续完成遍历,获取内部存储的每一个元素 13 */ 14 public static void main(String[] args) { 15 int[][] arr = {{11, 22, 33}, {33, 44, 55}}; 16 17 // 1. 遍历二维数组,取出里面每一个一维数组 18 for (int i = 0; i < arr.length; i++) { 19 //System.out.println(arr[i]); 20 // 2. 在遍历的过程中,对每一个一维数组继续完成遍历,获取内部存储的每一个元素 21 //int[] temp = arr[i]; 22 for (int j = 0; j < arr[i].length; j++) { 23 System.out.println(arr[i][j]); 24 } 25 } 26 } 27 }
3.8 二维数组求和
需求 :
某公司季度和月份统计的数据如下:单位(万元) 第一季度:22,66,44 第二季度:77,33,88 第三季度:25,45,65 第四季度:11,66,99
步骤 :
-
定义求和变量,准备记录最终累加结果
-
使用二维数组来存储数据,每个季度是一个一维数组,再将4个一维数组装起来
-
遍历二维数组,获取所有元素,累加求和
-
输出最终结果
代码实现 :
1 package com.lvsen.test; 2 3 public class Test2 { 4 /* 5 需求: 6 某公司季度和月份统计的数据如下:单位(万元) 7 第一季度:22,66,44 8 第二季度:77,33,88 9 第三季度:25,45,65 10 第四季度:11,66,99 11 12 步骤: 13 1. 定义求和变量,准备记录最终累加结果 14 2. 使用二维数组来存储数据,每个季度是一个一维数组,再将4个一维数组装起来 15 3. 遍历二维数组,获取所有元素,累加求和 16 4. 输出最终结果 17 */ 18 public static void main(String[] args) { 19 // 1. 定义求和变量,准备记录最终累加结果 20 int sum = 0; 21 // 2. 使用二维数组来存储数据,每个季度是一个一维数组,再将4个一维数组装起来 22 int[][] arr = { {22,66,44} , {77,33,88} , {25,45,65} , {11,66,99}}; 23 // 3. 遍历二维数组,获取所有元素,累加求和 24 for (int i = 0; i < arr.length; i++) { 25 for(int j = 0; j < arr[i].length; j++){ 26 sum += arr[i][j]; 27 } 28 } 29 // 4. 输出最终结果 30 System.out.println(sum); 31 } 32 }