javaSE--基础六(idea.debug,进制转换,二维数组)

Debug调试

什么是Debug调试？
	Debug调试可以让我们看到程序的执行流程，和变量的变化情况

如何完成Debug调试？
	1.打断点 （程序执行时，会停在断点的位置）
		在代码编辑区域的最左边，点一下即可
	2.点击Debug 运行 (小虫子)
    3.通过Debug的一些按钮来完成后续的调试操作
    	看下图

进制【了解】

进制指的是一种计数方式，常用的计数方式有 十进制、二进制、八进制、十六进制

十进制： 由0、1、2、3....9 组成，逢10进1
	例如： 100
二进制： 由0、1组成，逢2进1
	例如： 0b100
八进制： 由0、1、2...7组成，逢8进1
	例如： 0100
十六进制：由0、1、2...9、a、b、c、d、e、f组成，逢16进制1
	例如： 0x2f65

其他进制转十进制

系数：每一位数字
基数：几进制，基数就是几
权：从右往左，每一位的权分别是0,1,2,3... 

公式：系数*基数的权次幂之和

十进制转十进制
12345 = 1*10^4 +  2*10^3 + 3*10^2  + 4*10^1  + 5*10^0
	  = 10000  +  2000	 + 300	  + 40		+ 5
      = 12345
    
二进制转十进制
1010  = 1*2^3 + 0*2^2  + 1*2^1 + 0*2^0
	  = 8	  + 0	   + 2	   + 0
      = 10
....

十进制转其他进制

公式：除基取余，直到商为0，把余数反转拼接

十进制10转换二进制
			商	余数
	10/2	5	 0
    5/2		2	 1
    2/2		1	 0
    1/2		0	 1 
    把余数反转拼接：1010
....

二进制转其他进制的快速转换

8421码

把二进制数据从右往左对每一位进行标号，依次是1 2 4 8 …

二进制转十进制
	128  64  32  16  8   4   2   1	
	1	 0	 1	 0	 1	 0	 0	 1
    把数字为1的上面的标号相加就是二进制对应的十进制
    	128+32+8+1=169
    
二进制转八进制：
	从右往左把二进制的每三位看做一组(不足三位，前面补0)，每一组按照8421码来求结果，组合起来就是八进制
	010	  101	001
    2	  5		1	  组合起来251
    
二进制转十六进制
	从右往左把二进制的每四看做一组(不足四位，前面补0)，每一组按照8421码来求结果，组合起来就是十六进制
	1010	 1001
    a	     9	      组合起来a9	
    

练习：二进制10011转八进制
	010   011
    2	  3			  组合起来23

原码反码和补码

原码：一个二进制数据，最高位符号位(0表示正数，1表示负数)，后面的叫数值位
	符号位	   数值位
	0		 0000101	+5	
    1		 0000101	-5

正数：正数的原码、反码和补码都是一样

负数的反码：符号位不变，数值位取反
            符号位	   数值位
     原码	   1		0000101	
     反码	   1		1111010

负数的补码：在反码的基础上+1
            符号位	    数值位
     原码	   1		 0000101	
     反码	   1		 1111010
     补码	   1		 1111011
   
注意：计算机中所有的数据运算都是用【补码进行运算的】
	5+(-7)=-2
    
    5是正数的原码、反码、补码都是一样的  
    	00000101
    -7的原码、反码、补码、依次算出来
            符号位	  数值位
        原码	1      0000111
    	反码	1	   1111000
    	补码	1	   1111001
    
    5+(-7)的底层运算是用补码进行运算
    	00000101   5的补码
    +1	11111001   -7的补码
    --------------
        11111110   补码
    -1	00000001
    -------------------
        11111101   反码
    	10000010   原码	-2 

位运算

&(位与)  |(位或)  ^(位异或)  ~(取反)

运算规则：
   &(位与)： 把需要运算的数据转换为二进制，每一位逐一进行位与运算
   			1&1=1;  1&0=0;  0&0=0;
   |(位或)： 把需要运算的数据转换为二进制，每一位逐一进行位或运算
   			1|1=1;  1|0=1;  0|0=0;
   ^(位异或)：把需要运算的数据转换为二进制，每一位逐一进行位异或运算
  			1^1=0; 0^0=0;  1^0=1; 0^1=1
            
            特点：一个数被另一个数异或两次，等于这个数本身
                
   ~(取反): 把需要运算的数据转换为二进制,每一位0变1,1变0

<<(左移)  >>(右移)  >>>(无符号右移)
运算规则：
	<<(左移)：在二进制数据的最右边补对应位数的0，左边符号位被丢弃
		相当于乘以2的几次幂		
		
	>>(右移)：在最左边补对应位数的符号位，最后边的舍弃
		相当于除以2的几次幂
		
	>>>(无符号右移)：无论是正数还是负数，在最左边补对应位数的0

数据交换【重点】

两个数据交换，可以采用第三方变量。

int a=9;
int b=10;

//定义第三方变量
int temp=a;
a=b;
b=temp;

System.out.println("a:"+a);
System.out.println("b:"+b);   

还可以采用位异或的方式，利用一个数被另一个数异或两次，结果等于这个数本身的特点。

int a=9;
int b=10;
//采用异或的特点
a=a^b;	//a=9^10
b=a^b;  //b=9^10^10=9
a=a^b;  //a=9^10^9=10   

数组元素反转

public class ArrayTest{
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5};

        reverse(array); //反转一次
        reverse(array); //再反转一次 

        //遍历数组
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+" ");
        }
    }

    public static void reverse(int[] array){
        //1.定义一个开始索引start，和结束索引end
        int start = 0;
        int end = array.length - 1;
        while (start < end) {
            //2.让start位置的元素和end位置的元素互换位置
            int temp = array[start];
            array[start] = array[end];
            array[end] = temp;

            //3.每次互换完之后，让start++，end--
            start++;
            end--;
        }
    }
}

二维数组

二维数组中的元素是多个一维数组（容器里面装的也是容器）

• 二维数组动态初始化

//数据类型[][]  数组名= new 数据类型[m][n];  //m: 有多少个一维数组，n：表示每一个一维数组有多少个元素

int[][] array=new int[3][2]; 
System.out.println(array); //二维数组的地址值

System.out.println(array[0]); //第一个一维数组的地址
System.out.println(array[1]); //第二个一维数组的地址
System.out.println(array[2]); //第三个一维数组的地址 

//获取二维数组中的元素
System.out.println(array[0][1]); //第一个一维数组的1索引元素
System.out.println(array[1][0]); //第二个一维数组的0索引元素
...
    
//给二维数组的元素赋值
array[1][0]=10; //给第二个一维数组的0索引元素赋值为10
...

以下是二维数组的细节图解

• 二维数组的静态初始化

//数据类型[][]  数组名 = {{元素1,元素2...},{元素1,元素2...}};
String[][] stus={{"张三","李四"},{"王五","赵柳"}}; 

二维数组的遍历求和

/*
打印二维数组的元素，格式为
    1 2 3 4
    5 6 7 8
    9 10 11 12 13 14
*/
public class ArrayDemo {
    public static void main(String[] args) {
        int[][] array={{1,2,3,4},{5,6,7,8},{9,10,11,12,13,14}};
      
        int sum=0;

        //1.获取二维数组中的每一个一维数组
        for (int i = 0; i < array.length; i++) {
            //array[i]表示一位数组，继续遍历一维数组
            for (int j = 0; j < array[i].length; j++) {
                //2.获取一维数组中的每一个元素
                System.out.print(array[i][j]+" ");
                sum+=array[i][j];
            }
            System.out.println(); //一个一维数组打印完了，再换一行
        }

        System.out.println("二维数组中所有元素的和为："+sum);
    }
}