Debug,进制转换和数组

1.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}; 并在控制台输出交换后的数组元素


实现步骤 :


    

  1. 

    定义两个变量, start和end来表示开始和结束的指针. 
    

    2. 

  2. 

    确定交换条件, start < end 允许交换 
    

    3. 

  3. 

    循环中编写交换逻辑代码 
    

    4. 

  4. 

    每一次交换完成, 改变两个指针所指向的索引 start++, end-- 
    

    5. 

  5. 

    循环结束后, 遍历数组并打印, 查看反转后的数组
    

    6. 



代码实现 :






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


​ 遍历该数组，取出所有元素并打印


步骤 :


    

  1. 

    遍历二维数组，取出里面每一个一维数组 2. 在遍历的过程中，对每一个一维数组继续完成遍历，获取内部存储的每一个元素
    

    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


 步骤 :


    

  1. 

    定义求和变量，准备记录最终累加结果
    

    2. 

  2. 

    使用二维数组来存储数据，每个季度是一个一维数组，再将4个一维数组装起来
    

    3. 

  3. 

    遍历二维数组，获取所有元素，累加求和
    

    4. 

  4. 

    输出最终结果
    

    5. 



代码实现 :




 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 }




 







            

            
posted @ 
2022-07-02 20:20 
森森爱java 
阅读(95) 
评论(0) 
 
收藏 
举报