06Debug&基础练习

拼搏现实的明天。 2023-10-13 14:56 8阅读 0赞

#### Debug&基础练习 ####

*  1.Debug模式
 *   *  1.1 什么是Debug模式
     *  1.2 Debug介绍与操作流程
 *  2. 进制的介绍与书写格式
 *   *  2.1 进制的介绍与书写格式
     *  2.2 任意进制到十进制的转换
     *  2.3快速进制转换法
 *  3.原码反码补码
 *  4.位运算-位移运算符
 *  5.二维数组
 *   *  5.1二维数组求和
 *  6.冒泡排序
 *  7.验证“鬼谷猜想”
 *  8.快速排序

## 1.Debug模式 ##

### 1.1 什么是Debug模式 ###

是供程序员使用的程序调试工具，它可以用于查看程序的执行流程，  
也可以用于追踪程序执行过程来调试程序。

### 1.2 Debug介绍与操作流程 ###

*  如何加断点
 *  选择要设置断点的代码行，在行号的区域后面单击鼠标左键即可
 *  如何运行加了断点的程序
    
     *  在代码区域右键Debug执行  
        ![在这里插入图片描述][ad4bb553b52844d8970c4f8c41be8173.png]
 *  看哪里
    
     *  看Debugger窗口
     *  看Console窗口
 *  点哪里
    
     *  点Step Into (F7)这个箭头，也可以直接按F7
 *  如何删除断点
    
     *  选择要删除的断点，单击鼠标左键即可
     *  如果是多个断点，可以每一个再点击一次。也可以一次性全部删除
    
    ## 2. 进制的介绍与书写格式 ##
    
    ### 2.1 进制的介绍与书写格式 ###

public class Demo1 {
        
        /*
            十进制：Java中，数值默认都是10进制，不需要加任何修饰。
            二进制：数值前面以0b开头，b大小写都可以。
            八进制：数值前面以0开头。
            十六进制：数值前面以0x开头，x大小写都可以。
    
            注意: 书写的时候, 虽然加入了进制的标识, 但打印在控制台展示的都是十进制数据.
         */
        public static void main(String[] args) {
        
            System.out.println(10);
            System.out.println("二进制数据0b10的十进制表示为:" + 0b10);
            System.out.println("八进制数据010的十进制表示为:" + 010);
            System.out.println("十六进制数据0x10的十进制表示为:" + 0x10);
        }
    }

### 2.2 任意进制到十进制的转换 ###

![在这里插入图片描述][1cea0751dfc9460388d38dce89b761c5.png]  
![在这里插入图片描述][9f2ce238d42e486fb0aba982b5adf410.png]

### 2.3快速进制转换法 ###

![在这里插入图片描述][53c9a3b6a75a41f3a7e9ce589180eb46.png]  
![在这里插入图片描述][921086ee5f5f4fc7a9566348a06bf76f.png]  
![在这里插入图片描述][d783513d4d954031990274180291cd3d.png]

## 3.原码反码补码 ##

前言 : 计算机中的数据，都是以二进制补码的形式在运算，而补码则是通过反码和原码推算出来的

\*\*原码 \*\*:（可直观看出数据大小）

就是二进制定点表示法，即最高位为符号位，【0】表示正，【1】表示负，其余位表示数值的大小。

通过一个字节表示+7和-7，代码：byte b1 = 7; byte b2 = -7;一个字节等于8个比特位，也就是8个二进制位

0(符号位) 0000111

1(符号位) 0000111

**反码 :** 正数的反码与其原码相同；负数的反码是对其原码逐位取反，但符号位除外。

**补码 :** （数据以该状态进行运算）正数的补码与其原码相同；负数的补码是在其反码的末位加1。  
![在这里插入图片描述][f6cff77f385b45ec8c2b4863e4e71d9d.png]

## 4.位运算-位移运算符 ##

**位运算概述 :** 位运算符指的是二进制位的运算，先将十进制数转成二进制后再进行运算。在二进制位运算中，1表示true，0表示false。

![在这里插入图片描述][e0e8e0f18d4a4ca3b932f0441d456fb9.png]  
1.位运算实现乘除：  
原理： 右移1位，相当于整除2；a左移1位，相当于乘以2

a >> n	# 将a整除2^n
    a << n	# 将a乘以2^n

2.位运算判断奇偶  
原理： 在二进制中，奇数的最后一位必为1，偶数的最后一位必为0，所以可以通过与1做与运算来判断奇偶

if a & 1:
        # 奇数
    else:
        # 偶数

3.位运算交换两数  
原理： 数a与数a做异或运算结果为0，数a与0做异或运算结果为a。所以位运算也能不使用临时变量交换两数，效率比普通运算高

swap(a, b){
        
        a = a ^ b	
        b = b ^ a	# b = b ^ a ^ b = (b ^ b) ^ a = 0 ^ a = a
        a = a ^ b	# a = a ^ b ^ a = (a ^ a) ^ b = 0 ^ b = b
    }

## 5.二维数组 ##

动态初始化格式：
    
    数据类型[][] 变量名 = new 数据类型[m][n];
    m表示这个二维数组，可以存放多少个一维数组
    n表示每一个一维数组，可以存放多少个元素

静态初始化格式：
    完整格式：数据类型[][] 变量名 = new 数据类型[][]{ {元素1, 元素2...} , {元素1, 元素2...} ...};
       简化格式: 数据类型[][] 变量名 = { {元素1, 元素2...} , {元素1, 元素2...} ...};

### 5.1二维数组求和 ###

某公司季度和月份统计的数据如下：单位(万元)
    第一季度：22,66,44
    第二季度：77,33,88
    第三季度：25,45,65
    第四季度：11,66,99

public class Test2 {
        
       
        public static void main(String[] args) {
        
            int sum = 0;
            int[][] arr = {
         {
        22,66,44} , {
        77,33,88} , {
        25,45,65} , {
        11,66,99}};
            // 遍历二维数组，获取所有元素，累加求和
            for (int i = 0; i < arr.length; i++) {
        
                for(int j = 0; j < arr[i].length; j++){
        
                    sum += arr[i][j];
                }
            }
            System.out.println(sum);
        }
    }

## 6.冒泡排序 ##

编写程序实现对给定的 4 个整数从大到小的顺序排列。

public class day6Test2_1 {
        
        public static void main(String[] args) {
        
            int[] num = {
        13,56,24,11};
            //冒泡排序
            for (int i =0;i<num.length-1;i++)
            {
        
                for (int j =0;j<num.length-i-1;j++)
                {
        
                    if (num[j] < num[j+1])  //交换两个数据
                    {
        
                        num[j]=num[j]^num[j+1];
                        num[j+1]=num[j]^num[j+1];
                        num[j]=num[j]^num[j+1];
                    }
                }
            }
            for (int i =0;i<num.length;i++)
            {
        
                System.out.print(num[i]+" ");
            }
        }
    }

## 7.验证“鬼谷猜想” ##

验证“鬼谷猜想”：对任意自然数，若是奇数，就对它乘以 3 再加 1；若是
    
    偶数，就对它除以 2，这样得到一个新数，再按上述计算规则进行计算，一直进
    
    行下去，最终必然得到 1。（1--1000）

import java.util.Scanner;
    public class day6Test2_5 {
        
        public static void main(String[] args) {
        
            Scanner sc = new Scanner(System.in);
            int num = sc.nextInt();
            while (num!=1)
            {
        
                if (num%2==0)
                {
        
                    num/=2;
                }
                else
                {
        
                    num=num*3+1;
                }
                System.out.println(num);
            }
        }
    }

![在这里插入图片描述][8c0cd3fd885447619a45adaf44b4f67e.png]

## 8.快速排序 ##

需求：应用快速排序按小到大排序数组，然后输入一个数找到其下标。

package test;
    import java.util.Scanner;
    public class QuickSort {
        
        public static void main(String[] args) {
        
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入一个数：");
            boolean index=false ; //下标
            int num  = sc.nextInt();
            int[] arr = {
        8,5,7,3,9,6,66};
            int begin = 0;
            int end = arr.length-1;
            QuickSort(arr,begin,end); 
            for (int i  = 0;i<arr.length;i++)
            {
        
                System.out.print(arr[i]+" ");
            }
    
            for (int i = 0;i<arr.length;i++)
            {
        
                if (num == arr[i])
                {
        
                    index = true;
                    System.out.println("该数的下标为："+(i));
                    break;
                }
            }
            if (!index)
            {
        
                System.out.println("并没有这个数");
            }
    
    
        }
        public static void QuickSort(int[] arr,int low,int high){
        
            if(low<high){
        
                int i=low;
                int j=high;
                int key=arr[low];
                while(i<j){
        
                    while(i<j&&arr[j]>=key)
                        j--;
                    if(i<j)
                        arr[i++]=arr[j];//先赋值在自增
                    while(i<j&&arr[i]<key)
                        i++;
                    if(i<j)
                        arr[j--]=arr[i];//先赋值在自增
                }
                arr[i]=key;
                QuickSort(arr,low,i-1);//给左边排序
                QuickSort(arr,i+1,high);//给右边排序
            }
            }
    
        public static void swap(int a,int b)
        {
        
            a = a^b;
            b = a^b;
            a = a^b;
        }
    }

![在这里插入图片描述][3b69a20c823345adaade0462d19edc53.png]

[ad4bb553b52844d8970c4f8c41be8173.png]: https://img-blog.csdnimg.cn/ad4bb553b52844d8970c4f8c41be8173.png
[1cea0751dfc9460388d38dce89b761c5.png]: https://img-blog.csdnimg.cn/1cea0751dfc9460388d38dce89b761c5.png
[9f2ce238d42e486fb0aba982b5adf410.png]: https://img-blog.csdnimg.cn/9f2ce238d42e486fb0aba982b5adf410.png
[53c9a3b6a75a41f3a7e9ce589180eb46.png]: https://img-blog.csdnimg.cn/53c9a3b6a75a41f3a7e9ce589180eb46.png
[921086ee5f5f4fc7a9566348a06bf76f.png]: https://img-blog.csdnimg.cn/921086ee5f5f4fc7a9566348a06bf76f.png
[d783513d4d954031990274180291cd3d.png]: https://img-blog.csdnimg.cn/d783513d4d954031990274180291cd3d.png
[f6cff77f385b45ec8c2b4863e4e71d9d.png]: https://img-blog.csdnimg.cn/f6cff77f385b45ec8c2b4863e4e71d9d.png
[e0e8e0f18d4a4ca3b932f0441d456fb9.png]: https://img-blog.csdnimg.cn/e0e8e0f18d4a4ca3b932f0441d456fb9.png
[8c0cd3fd885447619a45adaf44b4f67e.png]: https://img-blog.csdnimg.cn/8c0cd3fd885447619a45adaf44b4f67e.png
[3b69a20c823345adaade0462d19edc53.png]: https://img-blog.csdnimg.cn/3b69a20c823345adaade0462d19edc53.png