ctrl shift k 代碼快捷鍵

```java java語言的代碼塊

```shell shell語言的代碼塊 #tab上面的一個鍵， 按shift切換成英文

//有序
ctrl + shift + [

ctrl + c // 拷貝
ctrl + v // 粘貼
ctrl + x // 剪切
ctrl + z // 撤銷

DAY2

notepad++的安裝和使用

1. 打開java文件進行編輯，編輯完成記得ctrl + s保存/。

2. 注意編碼

java注釋、關鍵字、標識符

 

java注釋

1. 單行注釋 // 注釋內容

2. 多行注釋

   /*

   *注釋內容

   */

3. 文檔注釋/**注釋內容 */

關鍵字

1. 關鍵字是java語言的一些特殊的字母，具有特殊含義，java中關鍵字是小寫字母開頭。

    

標識符

1. 標識符就是名稱（命名）意思，定義類，包，方法，變量名，目的是一個號的命名。

2. 標識符的組成

   • 英文的大小寫字母a-z A-Z

   • 數字0-9

   • 符號 _ 與 $

3. 標識符

   • 數字不能打頭

   • 不可以使用關鍵字

   • 嚴格區分大小寫，做到見名知意

   • 駝峰命名法

     public class StudentTest {
         //駝峰命名法
     }

計算機的存儲單元

1. 計算機的內存是如何存儲數據？計算機的最小存儲單元叫字節（byte）（B）, 計算機存儲設備的最小信息單元叫位（bit）(b)。

2. 存儲單元

   • 1B（字節） = 8位

   • 1KB = 1024B

   • 1MB = 1024KB

   • 1GB = 1024MB

   • 1TB = 1024GB

進制的換算

1. 十進制

2. 二進制

3. 八進制（0開頭）

4. 十六進制（0x開頭）

 

數據類型

1. 基本數據類型（八種）

   • byte 1個字節 -128-127

   • short 2個字節 -32768 - 32767

   • int 4個字節 -2147483648 - 2147483648

   • long 8個字節 -2^63 - 2^63 - 1

   • float 4個字節 -3.403E- 3.403E

   • double 8個字節

   • char 2個字節

   • boolean 1

2. 引用數據類型

   • String（字符串）

   • 其他的引用數據類型（數組，類）

 

基本數據類型的強制轉換

1. 需求 定義一個byte類型的數，并且給一個值為300；

2. 問題

3. 解決：強制類型轉換加上（數據類型）

   byte b = (byte)300;

4. 需求2：給byte類型的數賦值 128

5. 問題：超過給定的數據范圍，就會循環。

DAY3

變量

1. 定義格式

   數據類型 變量名 賦值符號 數值
       int num = 10

2. 代碼演示

   public class VariableDemo {
       public static void main(String[] args) {
           //定義一個3.5的變量
           double d = 3.5;
       }
   }

    

常量

1. 定義：永遠不會變的量，10，10.3，1000L

2. 代碼演示

   public class ConstantDemo {
       public static void main(String[] args) {
           System.out.println(10);
       }
   }

3. 常量不能修改，如被final修飾的值。 修改后會報錯。

運算符

1. 運算符是用來計算數據的，數據可以是常量，也可以是變量，被我們運算符操作的數，我們稱之為操作數。

2. 算術運算符+、-、*、/、%、++、--

   • +可以做連接符

   • ++a是先++再使用a 、 a++是先使用a再++

賦值運算符

1. 賦值運算符，用來為變量賦值的

2. =、+=、-=、*=、/=、%=

關系運算符

1. 關系運算符又叫比較運算符，用來判斷兩個操作數大小關系，以及是否相等，結果是boolen類型，true false

2. <、<=、 >、 >=、==、!=

3. 注意：賦值運算的=和關系運算符的==是有區別的，=是做賦值，==是做判斷比較。

   int a = 5;
   int b = 10;
   System.out.println(a == b);
   System.out.println(a = b);

拓展內容

1. 二進制運算的原碼，反碼，補碼（Integer.toBinaryString()）

   • 原碼：1 00000000 00000000 00000000 00000001

   • 反碼：1 00000000 00000000 00000000 00000001

   • 補碼 ：1 00000000 00000000 00000000 00000001

     -1這個數的原碼、反碼、補碼
         原碼10000000 00000000 00000000 00000001
         反碼11111111 11111111 11111111 11111110
         補碼 = 反碼 + 1
             11111111 11111111 11111111 11111111

2. 計算機以補碼為運算

邏輯運算符

1. 邏輯運算符，用與boolean類型的值進運算比較。最終的結果true或者是false

2. & 、|、！、^、&&、||

條件運算符

1. boolean？值1：值2

   true?"xx":"yy"

    

位運算符

1. 當你使用數字操作位運算符時，是使用二進制進行操作的。

2. &、|、^、~、<<、>>

3. >>> 無符號右移

    

IDEA工具的安裝

1. 項目和模塊的之間的關系：project --> 多個模塊 --> 多個包--->多個類（包用域名倒著寫）www.baidu.com com.baidu

2. idea快捷鍵

說明	快捷鍵
主方法	psvm
單行注釋	ctrl + /
多行注釋	ctrl + shift + /
文檔注釋	/** + enter
打印輸出語句	sout
刪除一行	ctrl + y
復制一行	ctrl + d
代碼格式化	ctrl + alt + L
重命名	shift + f6(暫時實現不了)
多行輸入	alt + 鼠標左鍵
上下移動	shift + alt + 方向鍵
自動生成變量名	ctrl + alt + v

 

DAY4

條件與循環語句

選擇結構if

1. if 的定義

   if (boolean) {
       
   }
   if (boolean) {
       
   }
   else {
       
   }

2. if...else 語句

3. if..else if....else if...else

選擇結構

1. 定義

   switch(表達式) {
       case 目標值:
           執行語句
           break;
       case 目標值:
           執行語句
           break;
       case 目標值:
           執行語句
           break;
       default:
           執行語句
   }

    

循環語句

while循環

1. 循環：重復相同的步驟

   //定義
   while (boolean) {
       代碼塊
   }
   ?
   //需求1：播放音樂10次
   //需求2：定義一個變量，從0開始，當變量小于5的時候，計算變量之間的和

    

do...while

1. 先做一次，再判斷

   do {
       語句塊
   }while (boolean);
   ?
   //需求：不管你之前聽音樂聽了多少次，當我判斷的時候都要一次 播放音樂 < 10

    

for循環

1. for 循環的定義

   for (表達式1; 表達式2; 表達式3) {
       內語句
   }
   外語句
   ?
   執行流程
       第一步：先執行表達式1
       第二步：再執行表達式2
       第三步：再執行內語句
       第四步：再執行表達式3
       第五步：回到表達式2 后面重復2 - 5步，直到表達式2為false
       最后：執行外語句

嵌套循環

1. 特點：最外層的循環執行一次，里面全部執行完，再去執行最外層的代碼。

   for (; ;) {
       for (; ;) {
           
       }
   }
   //用*打印一個三角形

    

break

1. 在switch條件語句和循環語句中都可以使用break語句。當它出現在switch條件語句之后，作用是終止某個case并跳出switch結構

   • 需求：定義一個變量num = 1， 當num 大于10的時候，循環停止

2. 標記語法

   可以指定break跳出某一層循環

continue

1. 終止本次循環，繼續往下執行

   • 需求：對1 - 100內的奇數求和

2. 注意：continue是停止本次循環，繼續執行下一次循環，而break是整體把循環結束

    

DAY5

數組

1. 在生活中，會遇到以下的場景，需求：統計班級學生數量，計算學生的平均年齡，找出學生最老的，找出學生最小的的。

   • 加入我們班有35個人，需要35個變量來表示我們學生的年齡，這樣做很麻煩而且很臃腫。

2. 數組的概念：一堆數的組合。20，21，23，20。

3. 數組的length屬性，就是數組的長度

4. 數組的索引是從0開始的，也就是數組的下標，最大值是數組的長度-1，也就是length - 1

5. 數組長度一但確定，就不可變。

數組的定義

 

1. 動態定義：數組初始化時，數組的元素是空的。需要我們重新賦值才有數據。

   數據類型[] 數組名 = new 數據類型[元素個數];
   //樣例
   int[] ages = new int[35];
   ?
   //賦值
   數組名稱[對應的索引]

    

2. 數組的靜態定義：數組初始化時候，就已經確定了各索引元素的值

   //方式1
   數據類型[] 數組名稱 = new 數據類型[]{數據1, 數據2, 數據3};
   ?
   //方式2
   數據類型[] 數組名稱 = {數據1, 數據2, 數據3};

3. 獲取值，或者賦值

   給數組元素賦值
   數組名稱[索引] = 值;
   //獲取值
   數據類型 變量 = 數組名稱[索引]

   • length:數組的長度

   • 索引：從0開始，比length少1

數組的遍歷

1. 在操作數組時，經常需要去拿元素取元素，這種操作就是數組的遍歷

2. 遍歷的語法

   //for 循環
   for (int i = 0; i < arr.length; i ++) {
       
   }
   //foreach 遍歷
   數組變量名.iter
   for (數據類型 變量名:數組名稱) {
       
   }

3. foreach底層其實還是使用我們的for循環

數組的特點

1. 常見問題

   • 索引越界（沒有在索引范圍內）

   • 數組未初始化

   • 空指針異常

2. 數組元素的特點

   • 數組的元素數據類型必須一致。（char 有ASCII碼表對應）

   • 數組元素連續，空間大小一致，并且內存地址連續，呈現線性結構。

   • 數組長度固定之后，不可改變

   • 數組不僅可以存儲基本數據類型，還可以存儲引用數據類型，數組本身就是引用數據類型。

     String[] strs = {"1", "2", "3"};

3. 優缺點

   • 優點

     • 根據索引去訪問元素（快）

     • 能存儲較多的數據

   • 缺點

     • 數組的長度固定不可改變（超過容量增加數組元素時，只能用新數組代替）

     • 只能存儲一種數據類型

     • 刪除很慢，根據內容找索引很慢。

 

數組的拷貝及其擴容

1. 需求：原數組不夠放，新增加了元素，只能考慮擴容和拷貝

    //原來的5個同學的年齡
   int[] ages = {12, 13, 21, 19, 23};
   //新加入一個同學 18;
   int[] newAges = new int[ages.length + 1];
   ?
   for (int i = 0; i < ages.length; i++) {
       newAges[i] = ages[i];
   }
   newAges[newAges.length - 1] = 18;
   for (int newAge : newAges) {
       System.out.println(newAge);
   }

    

2. 需求2：從原數組某一個位置開始拷貝，拷貝某一個長度到目標數組里面去

   //從原數組的第2個元素，拷貝3個元素到新數組里面去
   //需求2的實現
   int[] ages2 = {12, 13, 21, 19, 23};
   ?
   int[] newAges2 = new int[3];
   ?
   //第二個元素
   int srcPos = 1;
   //拷貝多長
   int index = 3;
   int destPos = 0;
   for (int i = srcPos; i < srcPos + index; i++) {
       //新數組從目標位置開始拷貝，每次遞增
       newAges2[destPos++] = ages2[i];
   }
   System.out.println("--------");
   for (int newAge : newAges2) {
       System.out.println(newAge);
   }

    

數組的工具類Arrays簡單了解

1. 需求：int[] ages = {1,3, 4, 5, 6};打印輸出的時候，[1,3,4,5,6];

   //Array.toString(ages);
   int[] ages = {1, 3, 4, 5, 6};
   //最后的字符串結果
   String ret = "[";
   for (int i = 0; i < ages.length; i++) {
       //如果當前元素是最后一個元素，就不添加。
       if (i == ages.length - 1) {
           ret += ages[i] + "]";
       }
       else {
           ret += ages[i] + ",";
       }
   //            ret += i == ages.length - 1 ? ages[i] + "]" : ages[i] + ",";
   }
   System.out.println(ret);

 

二維數組

1. 定義：二維數組，就是數組中有數組

   //一維數組
   int[] arr = new int[10];
   動態定義
   int[][] arr2 = new int[2][3];
   //靜態定義
   int[][] arrays = new int[][]{{1, 2, 3}, {4, 5}};
   int[][] arrays = {{1, 2, 3}, {1, 4}};

   • 遍歷：第一層拿到里面的數組元素（數組），第二層拿到具體的值。

簡單算法

1. 交換元素

   //方式1中間變量
   int a = 10;
   int b = 20;
   int temp = a;
   a = b;
   b = temp;
   ?
   //方式2不使用中間變量
   int c = 2;
   int d = 3;
   c = c ^ d;
   d = c ^ d;
   c = c ^ d;

    

冒泡排序

1. 做相鄰比較

   int[] heights = {9, 2, 6, 7, 4, 1};
   for (int i = 0; i < heights.length - 1; i++) {
       for (int j = 0; j < heights.length - i - 1; j++) {
           if (heights[j] > heights[j + 1]) {
               heights[j] ^= heights[j + 1];
               heights[j + 1] ^= heights[j];
               heights[j] ^= heights[j + 1];
           }
       }
   }
   System.out.println("最終會");
   System.out.println(Arrays.toString(heights));

    

選擇排序

int[] height = {9, 2, 6, 7, 4, 1};
//最外層控制找到最小的元素
for (int i = 0; i < height.length - 1; i++) {
    //定位一個元素，不停的去找最小值
    for (int j = i + 1; j < height.length; j++) {
        if (height[i] > height[j]) {
            height[i] ^= height[j];
            height[j] ^= height[i];
            height[i] ^= height[j];
        }
    }
}
System.out.println(Arrays.toString(height));

 

二分查找

1. 要求：要求數組元素是有序的

   int[] arr = {1, 2, 3, 5 ,6 ,8, 9, 11, 12, 16};
   //目標尋找的數
   int num = 1;
   ?
   //從哪里開始找
   int min = 0;
   int max = arr.length - 1;
   while (min <= max) {
       System.out.print("min " + min);
       System.out.println(" max " + max);
       int mid = (min + max) >> 1;
       int midValue = arr[mid];
       if (midValue < num) {
           min = mid + 1;
       }
       else if(midValue > num){
           max = mid - 1;
       }
       else {
           System.out.println("找到了，當前位置的位置是: " + mid);
           break;
       }
   }

2.