詳解IDEA中Debug的使用和進(jìn)制轉(zhuǎn)換問題
1.Debug模式
1.1 什么是Debug模式
是供程序員使用的程序調(diào)試工具，它可以用于查看程序的執(zhí)行流程，也可以用于追蹤程序執(zhí)行過程來調(diào)試程序。
1.2 Debug介紹與操作流程
如何加斷點
選擇要設(shè)置斷點的代碼行，在行號的區(qū)域后面單擊鼠標(biāo)左鍵即可
如何運行加了斷點的程序
在代碼區(qū)域右鍵Debug執(zhí)行
看哪里
看Debugger窗口
看Console窗口
點哪里
點Step Into (F7)這個箭頭，也可以直接按F7
如何刪除斷點
選擇要刪除的斷點，單擊鼠標(biāo)左鍵即可
如果是多個斷點，可以每一個再點擊一次。也可以一次性全部刪除
2. 進(jìn)制的介紹與書寫格式
2.1 進(jìn)制的介紹與書寫格式
代碼 :
public class Demo1 {
/*
十進(jìn)制：Java中，數(shù)值默認(rèn)都是10進(jìn)制，不需要加任何修飾。
二進(jìn)制：數(shù)值前面以0b開頭，b大小寫都可以。
八進(jìn)制：數(shù)值前面以0開頭。
十六進(jìn)制：數(shù)值前面以0x開頭，x大小寫都可以。
注意: 書寫的時候, 雖然加入了進(jìn)制的標(biāo)識, 但打印在控制臺展示的都是十進(jìn)制數(shù)據(jù).
*/
public static void main(String[] args) {
System.out.println(10);
System.out.println("二進(jìn)制數(shù)據(jù)0b10的十進(jìn)制表示為:" + 0b10);
System.out.println("八進(jìn)制數(shù)據(jù)010的十進(jìn)制表示為:" + 010);
System.out.println("十六進(jìn)制數(shù)據(jù)0x10的十進(jìn)制表示為:" + 0x10);
}
}
2.2 任意進(jìn)制到十進(jìn)制的轉(zhuǎn)換
2.3 進(jìn)制轉(zhuǎn)換-十進(jìn)制到任意進(jìn)制轉(zhuǎn)換
2.3.1 : 十進(jìn)制到二進(jìn)制的轉(zhuǎn)換
公式：除基取余使用源數(shù)據(jù)，不斷的除以基數(shù)（幾進(jìn)制，基數(shù)就是幾）得到余數(shù)，直到商為0，再將余數(shù)倒著拼起來即可。
需求：將十進(jìn)制數(shù)字11，轉(zhuǎn)換為2進(jìn)制。
實現(xiàn)方式：源數(shù)據(jù)為11，使用11不斷的除以基數(shù)，也就是2，直到商為0。
2.3.2 : 十進(jìn)制到十六進(jìn)制的轉(zhuǎn)換
公式：除基取余使用源數(shù)據(jù)，不斷的除以基數(shù)（幾進(jìn)制，基數(shù)就是幾）得到余數(shù)，直到商為0，再將余數(shù)倒著拼起來即可。
需求：將十進(jìn)制數(shù)字60，轉(zhuǎn)換為16進(jìn)制。
實現(xiàn)方式：源數(shù)據(jù)為60，使用60不斷的除以基數(shù)，也就是16，直到商為0。
結(jié)論：十進(jìn)制到任意進(jìn)制的轉(zhuǎn)換
公式：除基取余使用源數(shù)據(jù)，不斷的除以基數(shù)（幾進(jìn)制，基數(shù)就是幾）得到余數(shù)，直到商為0，再將余數(shù)倒著 拼起來即可
2.4 快速進(jìn)制轉(zhuǎn)換法
8421碼：
8421碼又稱BCD碼，是BCD代碼中最常用的一種BCD： (Binary-Coded Decimal) 二進(jìn)制碼十進(jìn)制數(shù)在這種編碼方式中，每一位二進(jìn)制值的1都是代表一個固定數(shù)值，把每一位的1代表的十進(jìn)制數(shù)加起來得到的結(jié)果就是它所代表的十進(jìn)制數(shù)。
2.5 原碼反碼補(bǔ)碼
前言 : 計算機(jī)中的數(shù)據(jù)，都是以二進(jìn)制補(bǔ)碼的形式在運算，而補(bǔ)碼則是通過反碼和原碼推算出來的
**原碼 **:（可直觀看出數(shù)據(jù)大?。?/p>
就是二進(jìn)制定點表示法，即最高位為符號位，【0】表示正，【1】表示負(fù)，其余位表示數(shù)值的大小。
通過一個字節(jié)表示+7和-7，代碼：byte b1 = 7; byte b2 = -7;一個字節(jié)等于8個比特位，也就是8個二進(jìn)制位
0(符號位) 0000111
1(符號位) 0000111
反碼 : 正數(shù)的反碼與其原碼相同；負(fù)數(shù)的反碼是對其原碼逐位取反，但符號位除外。
補(bǔ)碼 : （數(shù)據(jù)以該狀態(tài)進(jìn)行運算）正數(shù)的補(bǔ)碼與其原碼相同；負(fù)數(shù)的補(bǔ)碼是在其反碼的末位加1。
2.6 位運算-基本位運算符
public class Demo2 {
/*
位運算:
位運算符指的是二進(jìn)制位的運算，先將十進(jìn)制數(shù)轉(zhuǎn)成二進(jìn)制后再進(jìn)行運算。
在二進(jìn)制位運算中，1表示true，0表示false。
& 位與 : 遇false則false, 遇0則0
00000000 00000000 00000000 00000110 // 6的二進(jìn)制
& 00000000 00000000 00000000 00000010 // 2的二進(jìn)制
-----------------------------------------
00000000 00000000 00000000 00000010 // 結(jié)果: 2
| 位或 : 遇true則true, 遇1則1
^ 位異或 : 相同為false, 不同為true
~ 取反 : 全部取反, 0變1, 1變0 (也包括符號位)
00000000 00000000 00000000 00000110 // 6的二進(jìn)制補(bǔ)碼
~ 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 位運算-位移運算符
位運算概述 : 位運算符指的是二進(jìn)制位的運算，先將十進(jìn)制數(shù)轉(zhuǎn)成二進(jìn)制后再進(jìn)行運算。在二進(jìn)制位運算中，1表示true，0表示false。
位運算符介紹 : [外鏈圖片轉(zhuǎn)存失敗,源站可能有防盜鏈機(jī)制,建議將圖片保存下來直接上傳(img-bjGD9ZTs-1606280432728)(.\img\1590937235620.png)]
代碼 :
public class Demo3 {
/*
位移運算符:
<< 有符號左移運算，二進(jìn)制位向左移動, 左邊符號位丟棄, 右邊補(bǔ)齊0
運算規(guī)律: 向左移動幾位, 就是乘以2的幾次冪
12 << 2
(0)0000000 00000000 00000000 000011000 // 12的二進(jìn)制
-----------------------------------------------------------------------------
>> 有符號右移運算，二進(jìn)制位向右移動, 使用符號位進(jìn)行補(bǔ)位
運算規(guī)律: 向右移動幾位, 就是除以2的幾次冪
000000000 00000000 00000000 0000001(1) // 3的二進(jìn)制
-----------------------------------------------------------------------------
>>> 無符號右移運算符, 無論符號位是0還是1，都補(bǔ)0
010000000 00000000 00000000 00000110 // -6的二進(jìn)制
*/
public static void main(String[] args) {
System.out.println(12 << 1); // 24
System.out.println(12 << 2); // 48
}
}
public class Demo4 {
/*
^ 運算符的特點
一個數(shù), 被另外一個數(shù), 異或兩次, 該數(shù)本身不變
*/
public static void main(String[] args) {
System.out.println(10 ^ 5 ^ 10);
}
}
3.基礎(chǔ)練習(xí)
3.1 數(shù)據(jù)交換
案例需求
已知兩個整數(shù)變量a = 10，b = 20，使用程序?qū)崿F(xiàn)這兩個變量的數(shù)據(jù)交換
最終輸出a = 20，b = 10;
代碼實現(xiàn)
public class Test1 {
/*
需求：已知兩個整數(shù)變量a = 10，b = 20，使用程序?qū)崿F(xiàn)這兩個變量的數(shù)據(jù)交換
最終輸出a = 20，b = 10;
思路：
1. 定義一個三方變量temp，將a原本記錄的值，交給temp記錄 （a的值，不會丟了）
2. 使用 a 變量記錄 b 的值，（第一步交換完畢，b的值也丟不了了）
3. 使用 b 變量記錄 temp的值，也就是a原本的值 （交換完畢）
4. 輸出 a 和 b 變量即可
*/
/*
動態(tài)初始化格式：
數(shù)據(jù)類型[][] 變量名 = new 數(shù)據(jù)類型[m][n];
m表示這個二維數(shù)組，可以存放多少個一維數(shù)組
n表示每一個一維數(shù)組，可以存放多少個元素
*/
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 數(shù)組反轉(zhuǎn)【應(yīng)用】
案例需求 :
已知一個數(shù)組 arr = {19, 28, 37, 46, 50}; 用程序?qū)崿F(xiàn)把數(shù)組中的元素值交換，
交換后的數(shù)組 arr = {50, 46, 37, 28, 19}; 并在控制臺輸出交換后的數(shù)組元素
實現(xiàn)步驟 :
1. 定義兩個變量, start和end來表示開始和結(jié)束的指針.
確定交換條件, start < end 允許交換循環(huán)中編寫交換邏輯代碼每一次交換完成, 改變兩個指針?biāo)赶虻乃饕?start++, end–循環(huán)結(jié)束后, 遍歷數(shù)組并打印, 查看反轉(zhuǎn)后的數(shù)組
代碼實現(xiàn) :
public class Test2 {
/*
需求：已知一個數(shù)組 arr = {19, 28, 37, 46, 50}; 用程序?qū)崿F(xiàn)把數(shù)組中的元素值交換，
交換后的數(shù)組 arr = {50, 46, 37, 28, 19}; 并在控制臺輸出交換后的數(shù)組元素。
步驟:
1. 定義兩個變量, start和end來表示開始和結(jié)束的指針.
2. 確定交換條件, start < end 允許交換
3. 循環(huán)中編寫交換邏輯代碼
4. 每一次交換完成, 改變兩個指針?biāo)赶虻乃饕?start++, end--
5. 循環(huán)結(jié)束后, 遍歷數(shù)組并打印, 查看反轉(zhuǎn)后的數(shù)組
*/
public static void main(String[] args) {
int[] arr = {19, 28, 37, 46, 50};
// 1. 定義兩個變量, start和end來表示開始和結(jié)束的指針.
int start = 0;
int end = arr.length -1;
// 2. 確定交換條件, start < end 允許交換
// 4. 每一次交換完成, 改變兩個指針?biāo)赶虻乃饕?start++, end--
// for(int start = 0, end = arr.length -1; start < end; start++, end--)
for( ; start < end; start++, end--){
// 3. 循環(huán)中編寫交換邏輯代碼
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 二維數(shù)組概述
概述 : 二維數(shù)組也是一種容器，不同于一維數(shù)組，該容器存儲的都是一維數(shù)組容器
3.4 二維數(shù)組動態(tài)初始化
動態(tài)初始化格式：
數(shù)據(jù)類型[][] 變量名 = new 數(shù)據(jù)類型[m][n];
m表示這個二維數(shù)組，可以存放多少個一維數(shù)組
n表示每一個一維數(shù)組，可以存放多少個元素
public class Demo1Array {
/*
動態(tài)初始化格式：
數(shù)據(jù)類型[][] 變量名 = new 數(shù)據(jù)類型[m][n];
m表示這個二維數(shù)組，可以存放多少個一維數(shù)組
n表示每一個一維數(shù)組，可以存放多少個元素
*/
public static void main(String[] args) {
// 數(shù)據(jù)類型[][] 變量名 = new 數(shù)據(jù)類型[m][n];
int[][] arr = new int[3][3];
/*
[[I@10f87f48
@ : 分隔符
10f87f48 : 十六進(jìn)制內(nèi)存地址
I : 數(shù)組中存儲的數(shù)據(jù)類型
[[ : 幾個中括號就代表的是幾維數(shù)組
*/
System.out.println(arr);
/*
二維數(shù)組存儲一維數(shù)組的時候, 存儲的是一維數(shù)組的內(nèi)存地址
*/
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]);
// 向二維數(shù)組中存儲元素
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;
// 從二維數(shù)組中取出元素并打印
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 二維數(shù)組訪問元素的細(xì)節(jié)問題
問題 : 二維數(shù)組中存儲的是一維數(shù)組, 那能不能存入 [提前創(chuàng)建好的一維數(shù)組] 呢 ?
答 : 可以的
代碼實現(xiàn)
public class Demo2Array {
/*
問題: 二維數(shù)組中存儲的是一維數(shù)組, 那能不能存入 [提前創(chuàng)建好的一維數(shù)組] 呢 ?
答 : 可以的
*/
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 二維數(shù)組靜態(tài)初始化
**完整格式 :** 數(shù)據(jù)類型[][] 變量名 = new 數(shù)據(jù)類型[][]{ {元素1, 元素2...} , {元素1, 元素2...}
**簡化格式 :** 數(shù)據(jù)類型[][] 變量名 = { {元素1, 元素2...} , {元素1, 元素2...} ...};
**代碼實現(xiàn) : **
public class Demo3Array {
/*
完整格式：數(shù)據(jù)類型[][] 變量名 = new 數(shù)據(jù)類型[][]{ {元素1, 元素2...} , {元素1, 元素2...} ...};
簡化格式: 數(shù)據(jù)類型[][] 變量名 = { {元素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 二維數(shù)組遍歷
需求 :
已知一個二維數(shù)組 arr = {{11, 22, 33}, {33, 44, 55}};
遍歷該數(shù)組，取出所有元素并打印
步驟 :
1. 遍歷二維數(shù)組，取出里面每一個一維數(shù)組
2. 在遍歷的過程中，對每一個一維數(shù)組繼續(xù)完成遍歷，獲取內(nèi)部存儲的每一個元素
代碼實現(xiàn) :
public class Test1 {
/*
需求:
已知一個二維數(shù)組 arr = {{11, 22, 33}, {33, 44, 55}};
遍歷該數(shù)組，取出所有元素并打印
步驟:
1. 遍歷二維數(shù)組，取出里面每一個一維數(shù)組
2. 在遍歷的過程中，對每一個一維數(shù)組繼續(xù)完成遍歷，獲取內(nèi)部存儲的每一個元素
*/
public static void main(String[] args) {
int[][] arr = {{11, 22, 33}, {33, 44, 55}};
// 1. 遍歷二維數(shù)組，取出里面每一個一維數(shù)組
for (int i = 0; i < arr.length; i++) {
//System.out.println(arr[i]);
// 2. 在遍歷的過程中，對每一個一維數(shù)組繼續(xù)完成遍歷，獲取內(nèi)部存儲的每一個元素
//int[] temp = arr[i];
for (int j = 0; j < arr[i].length; j++) {
System.out.println(arr[i][j]);
}
}
}
}
3.8 二維數(shù)組求和
需求 :
某公司季度和月份統(tǒng)計的數(shù)據(jù)如下：單位(萬元)
第一季度：22,66,44
第二季度：77,33,88
第三季度：25,45,65
第四季度：11,66,99
步驟 :
定義求和變量，準(zhǔn)備記錄最終累加結(jié)果使用二維數(shù)組來存儲數(shù)據(jù)，每個季度是一個一維數(shù)組，再將4個一維數(shù)組裝起來遍歷二維數(shù)組，獲取所有元素，累加求和輸出最終結(jié)果
代碼實現(xiàn) :
public class Test2 {
/*
需求:
某公司季度和月份統(tǒng)計的數(shù)據(jù)如下：單位(萬元)
第一季度：22,66,44
第二季度：77,33,88
第三季度：25,45,65
第四季度：11,66,99
步驟:
1. 定義求和變量，準(zhǔn)備記錄最終累加結(jié)果
2. 使用二維數(shù)組來存儲數(shù)據(jù)，每個季度是一個一維數(shù)組，再將4個一維數(shù)組裝起來
3. 遍歷二維數(shù)組，獲取所有元素，累加求和
4. 輸出最終結(jié)果
*/
public static void main(String[] args) {
// 1. 定義求和變量，準(zhǔn)備記錄最終累加結(jié)果
int sum = 0;
// 2. 使用二維數(shù)組來存儲數(shù)據(jù)，每個季度是一個一維數(shù)組，再將4個一維數(shù)組裝起來
int[][] arr = { {22,66,44} , {77,33,88} , {25,45,65} , {11,66,99}};
// 3. 遍歷二維數(shù)組，獲取所有元素，累加求和
for (int i = 0; i < arr.length; i++) {
for(int j = 0; j < arr[i].length; j++){
sum += arr[i][j];
}
}
// 4. 輸出最終結(jié)果
System.out.println(sum);
}
}
個季度是一個一維數(shù)組，再將4個一維數(shù)組裝起來
3. 遍歷二維數(shù)組，獲取所有元素，累加求和
4. 輸出最終結(jié)果
*/
public static void main(String[] args) {
// 1. 定義求和變量，準(zhǔn)備記錄最終累加結(jié)果
int sum = 0;
// 2. 使用二維數(shù)組來存儲數(shù)據(jù)，每個季度是一個一維數(shù)組，再將4個一維數(shù)組裝起來
int[][] arr = { {22,66,44} , {77,33,88} , {25,45,65} , {11,66,99}};
// 3. 遍歷二維數(shù)組，獲取所有元素，累加求和
for (int i = 0; i < arr.length; i++) {
for(int j = 0; j < arr[i].length; j++){
sum += arr[i][j];
}
}
// 4. 輸出最終結(jié)果
System.out.println(sum);
}
}
到此這篇關(guān)于IDEA中Debug的使用和進(jìn)制轉(zhuǎn)換的文章就介紹到這了,更多相關(guān)IDEA使用Debug內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！
相關(guān)文章
這篇文章主要介紹了Java工程mybatis實現(xiàn)多表查詢過程詳解,文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值,需要的朋友可以參考下2020-06-06
這篇文章主要介紹了詳解IDEA啟動多個微服務(wù)的配置方法，文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2020-01-01
SpringBoot詳解MySQL如何實現(xiàn)讀寫分離
當(dāng)響應(yīng)的瓶頸在數(shù)據(jù)庫的時候,就要考慮數(shù)據(jù)庫的讀寫分離,當(dāng)然還可以分庫分表,那是單表數(shù)據(jù)量特別大,當(dāng)單表數(shù)據(jù)量不是特別大,但是請求量比較大的時候,就要考慮讀寫分離了.具體的話,還是要看自己的業(yè)務(wù)...如果還是很慢,那就要分庫分表了...我們這篇就簡單講一下讀寫分離2022-09-09
Spring Security攔截器引起Java CORS跨域失敗的問題及解決
這篇文章主要介紹了Spring Security攔截器引起Java CORS跨域失敗的問題及解決，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2021-07-07
mybatis調(diào)用存儲過程,帶in、out參數(shù)問題
這篇文章主要介紹了mybatis調(diào)用存儲過程,帶in、out參數(shù)問題,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教2024-01-01
SpringBoot錯誤處理機(jī)制以及自定義異常處理詳解
這篇文章主要為大家詳細(xì)介紹了SpringBoot錯誤處理機(jī)制以及自定義異常處理，具有一定的參考價值，感興趣的小伙伴們可以參考一下2019-05-05
這篇文章主要介紹了解決對接JAVA SM2加密遇到的坑，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2020-10-10
剖析Java中在Collection集合中使用contains和remove為什么要重寫equals
這篇文章主要介紹了Collection集合的contains和remove方法詳解remove以及相關(guān)的經(jīng)驗技巧，通過簡要的案例,講解了該項技術(shù)的了解與使用,以下就是詳細(xì)內(nèi)容,需要的朋友可以參考下2021-09-09
java自定義ClassLoader加載指定的class文件操作
這篇文章主要介紹了java自定義ClassLoader加載指定的class文件操作，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2021-02-02
string類和LocalDateTime的相互轉(zhuǎn)換方式
這篇文章主要介紹了string類和LocalDateTime的相互轉(zhuǎn)換方式，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2022-02-02