第一天：
1windows:
---微軟  優點：流暢    缺點：藍屏+安全性差


linux
---server作業系統

win+r開啟執行對話方塊
notepad記事本      畫圖mspaint     計算器calc    
.exe可執行檔案   .class編譯後的檔案   

windiws優化：1、停止不必要的程序    
             2、停止不必要的服務   --開啟服務services.msc
             3、調整最佳效能       --設定視覺效果選項卡  調整為最佳效能
             4、桌面個性化         --windows經典
             5、修改虛擬記憶體       --50%
棧：先進後出  系統的視窗就是棧結構

進位制轉換：https://jingyan.baidu.com/article/495ba84109665338b30ede98.html
16進位制：0 1 2 3 4 5 6 7 8 9 A B C D E F  以0x開頭 
0xfe
 
1、dos命令:dir   cd    \   d:切換碟符   dir /？ 顯示幫助    . 當前目錄  .. 上級目錄   cls 清屏  mkdir建立目錄  exit退出  type 顯示內容
       echo >重定向 覆蓋操作  echo >>重定向  追加操作   del刪除目錄  tree使用樹形結構顯示檔案系統盤   set檢視環境變數

2、環境變數 
   1、java_home 供基於java的軟體尋找jdk的執行程式所用
             name:java_home
             value:c:\download\jdk.1.8.0-65
   2、path
             name:path
             value:%java_home%\bin;......
   3、classpath:搜尋類的目錄順序 
             name:classpath
             value: %java_home%\bin；%java_home%\lib\tools.jar;
   4、重啟命令列
   5、java -version 檢視版本  
   6、驗證是否ok：在任何目錄下輸入  javac，檢視輸出結果 

執行HelloWorld :  javac編譯  javac HelloWorld.java
                  java執行   java HelloWorld

第二天
    jre=jdk(java開發工具包)+核心類庫 
  面向物件：繼承   封裝   多型
進位制轉換 
負數的表現形式：補碼（取反+1）
8種基本型別  byte   -128~127        1位元組=8位
             short  -32768~32767   2位元組
             int     4位元組
             long    8位元組
             float   4位元組
             double  8位元組  
             boolean 1位元組
             char    2位元組     \u0000-\uffff 
3種引用型別：陣列 class interface
特殊字元 \t製表  \r換行  \n回車

s+=5與s=s+5的區別
    答：s+=5是進行自動型別轉換的，
    比如說我們在編寫Java程式的時候,有時候會發現定義一個short型的變數s, 
    short s = 4; 
    然後s = s+5報錯,而s+=5卻沒有問題,這是怎麼回事呢。 
    因為5是整型數,佔4個位元組,而short佔2個位元組,當s+5的時候,s為short型會轉為int型與5運算,可是結果卻要賦給精度低的short型,會丟失精度。所以會報錯,編譯不通過
    但是s+=5這一運算不同,就是一次運算,只有一次賦值運算,會自動轉換,編譯通過。

instance判斷物件是否是指定的型別，後面跟的是引用型別  
    它的作用是測試它左邊的物件是否是它右邊的類的例項，返回boolean型別的資料。舉個例子：　　String s = "I AM an Object!";　　boolean isObject = s instanceof Object;
　　我們聲明瞭一個String物件引用，指向一個String物件，然後用instancof來測試它所指向的物件是否是Object類的一個例項，顯然，這是真的，所以返回true，也就是isObject的值為True。


&邏輯與與&&短路與的區別 ：& 左邊無論真假，右邊都進行運算  && 如果左邊為真，右邊參與運算，如果左邊為假，則右邊不參與運算 
              false&true都判斷       false&&true
^問：
   異或：相同二進位制進行運算 相同為0，不同為1
   為什麼 &  |沒有短路？
   -128儲存形式？
   計算機中0是整數還是負數：負數
   成績float 用switch寫出 優良中差 與不及格
   列印直角三角形  空心三角形  乘法表
   //空心三角形
   public static void print6(int size){
        for(int i=1;i<=size;i++){
            if(i==size){//第一行等於最後一行
                for(int j=0;j<2*size-1;j++){
                    System.out.print("*");//列印*
                }
            }else{
                for(int j=1;j<=size-i;j++){//列印空格
                    System.out.print(" ");
                }
                for(int k=1;k<=2*i-1;k++){//第一行到最後一行
                    if(k==1||k==2*i-1){  //第一行或最後一行
                        System.out.print("*");
                    }else{
                        System.out.print(" ");//中間列印空格
                    }
                }
                System.out.println();
            }
        }
    }

    //菱形
    public static void print5(int n) {
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n - i; j++) {
                System.out.print(" ");
            }
            for (int k = 1; k <= 2 * i - 1; k++) {
                System.out.print("*");
            }
            System.out.println();
        }

        for (int i = 1; i < n; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(" ");
            }
            for (int k = 1; k <= (n - i) * 2 - 1; k++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }

左移<<和右移>>  
三目運算子：System.out.println(b<40?"小於":"不小於");
比較三個數的大小，可巢狀
   int x=5; int y=6;int z=7;
   System.out.println( x>y?(x>z?x:z):(y>z?y:z));

switch 語句可選擇的型別 byte short int char
   在jdk1.7版本以前，引數型別只能是short、byte、int、char可正常執行。而例如String，Long、Integer、double、float等則會報錯。
   而jdk1.7版本以後，引數型別除了之前可使用的外，String、Integer類、 Character類、列舉型別都可以正常執行。而Long、double、float依舊會報錯。

while與for的區別：for迴圈定義的變數在for迴圈結束時就在記憶體中釋放，while迴圈使用的變數在迴圈結束後還可以繼續使用

第三天
  方法：具有特定功能的一段獨立小程式
  方法的格式 
  呼叫方法
前n項和
public static void He(int n){
int sum =0;
   for(int i=0;i<=n;i++){
        sum=sum+i;
   }
}
動態乘法表
pubclic static void table(int row){

  for(int i=1;i<=row;i++){

       for(int j=1;j<=i;j++){

         System.out.print(j+"*"+i+"="+(i*j)+"\t");

    }
      System.out.println(\r\n);
  }

}
計算階乘
   public static int fabric(int n){
   if(n<=0){
        return -1;
        }
   int res=1;
   for(int i=1;i<=n;i++){
   res=res*i;
   
    }
     return res;
     }
  }
遞迴 rescursive
 public static int fac(int n){
   if(n=1){
          return 1;
      }
   return n * fac(n-1);
      }
}


陣列：同一種資料型別的集合。
陣列的定義  型別[] 變數名=new 型別[數值]  陣列的長度固定 int [] a=new int[10];    int[] a={1,2,3}
length()是屬性，不是方法
定義陣列，並直接初始化 int[] arr=new int[] {1,2,3};  

問：提取陣列元素最大值

  public static int getMax(int[] arr){
       if(arr==null||arr.length==0){
          return -1;
   }
       int max=arr[0];
       for(int i=1;i<arr.length;i++){
       max=max>arr[i]?max:arr[i]
   }
}

棧：方法在棧中,方法的呼叫鏈條 儲存區域性變數，資料使用完，所佔空間會自動釋放

堆：物件和陣列在堆中；是jvm最大的記憶體空間

氣泡排序:每一次選出當前元素中最大的數放在末尾
  public static void maoPao(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {//外層迴圈控制排序趟數
            for (int j = 0; j < arr.length - 1 - i; j++) {//內層迴圈控制每一趟排序多少次
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        for (int ii : arr) {
            System.out.println(ii);
        }
    }
選擇排序:在要排序的一組數中，選出最小的一個數與第一個位置的數交換；然後在剩下的數當中再找最小的與第二個位置的數交換，
 public static void selectSort(int [] arr){
        for(int i=0;i<arr.length;i++){
            for(int j=i+1;j<arr.length;j++){
                if(arr[i]>arr[j]){
                    int temp=arr[i];
                    arr[i]=arr[j];
                    arr[j]=temp;
                }
            }
        }
    }

    public static void print(int [] arr){
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]+" ");
        }
    }
}
折半查詢（二分法）
public class Demo1 {
    /**
     * * A:案例演示
     * 陣列高階二分查詢程式碼
     * B:注意事項
     * 如果陣列無序，就不能使用二分查詢。
     * 因為如果你排序了，但是你排序的時候已經改變了我最原始的元素索引。

     */
    public static void main(String[] args) {
        int[] arr = {11,22,33,44,55,66,77};
        System.out.println(getIndex(arr, 22));
        System.out.println(getIndex(arr, 66));
        System.out.println(getIndex(arr, 88));
    }

    /*
     * 二分查詢
     * 1,返回值型別,int
     * 2,引數列表int[] arr,int value
     */

    public static int getIndex(int[] arr, int value) {
        int min = 0;
        int max = arr.length - 1;
        int mid = (min + max) / 2;

        while(arr[mid] != value) {					//當中間值不等於要找的值,就開始迴圈查詢
            if(arr[mid] < value) {					//當中間值小於了要找的值
                min = mid + 1;						//最小的索引改變
            }else if (arr[mid] > value){			//當中間值大於了要找的值
                max = mid - 1;						//最大的索引改變
            }

            mid = (min + max) / 2;					//無論最大還是最小改變,中間索引都會隨之改變

            if(min > max) {							//如果最小索引大於了最大索引,就沒有查詢的可能性了
                return -1;							//返回-1
            }
        }
        return mid;
    }


輸出一個整數的二進位制
public static int byteScope(byte b){
  return b&xxff;
}
public static void putIntBinaryString(int n){
   for(int i=31;i>= 0;i--){
         System.out.print((n>>i)&0x1);
  }
    System.out.println();
}
二維陣列 ：九宮格


第三天
1、把一個數組的元素放進另一個數組裡，可截斷 
 public static void arrayCopy(int [] arr1,int [] arr2){
        if(arr1.length>arr2.length){
            for(int i=0;i<arr2.length;i++){
                arr2[i]=arr1[i];
            }
        }else{
            for(int i=0;i<arr2.length;i++){
                arr2[i]=arr1[i%(arr1.length)];
            }
        }
        for(int i=0;i<arr2.length;i++){
            System.out.print(arr2[i]+" ");
        }
  }
2、矩陣轉置（二維陣列）
  public static void rever(int[][] arr) {
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < i; j++) {
                int temp = arr[i][j];
                arr[i][j] = arr[j][i];
                arr[j][i] = temp;
            }
        }
    }
    public static void out(int[][] arr) {
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }


3、面向物件與面向過程
    滿漢全席的例子 物件：先找負責人  過程：自己全做一遍
    面向過程強調功能行為   面向物件將功能封裝進物件，強調具備了功能的物件
 
4、類和物件的關係
  物件:是實實在在的個體 類：對現實事務的軟體抽象


5、成員變數有預設初始化值  區域性變數需手動初始化

day04
一、java -x 檢視java非標準輸出幫助
java -Xmx100m 設定jvm的堆空間最大值
     -Xms100m 設定jvm的堆空間初始值

二、匿名物件  new Person().run();
          作為引數進行傳遞  run 



三、封裝：隱藏物件的屬性和實現細節，僅對外提供公共訪問方式
         1、子類會繼承父類的所有東西，而修飾符只是影響屬性或者方法對外是否可見。
         2、子類不能繼承父類的私有屬性，但是如果子類中公有的方法影響到了父類私有屬性，那麼私有屬性是能夠被子類使用的
四、建構函式
       1、函式名和類名形同
       2、無返回值
       3、可以過載
       4、如果類沒有定義建構函式，jvm分配一個空構造 
       5、建立物件

五、構造程式碼塊 {}
       從上到下按序執行


六、物件的建立過程
       1、靜態程式碼塊：在類載入期間執行，且只執行一次
       2、靜態成員不可以訪問非靜態 
       3、靜態成員變數通過類來訪問 

七、this和super
    指向物件自身的引用，用於區分成員變數和方法的形參。
    this()訪問當前類的建構函式，且必須 在第一行，為了建構函式的重用
    super()訪問父類的建構函式

八：static
      隨著類載入而載入
      優先於物件存在   
      被所有物件所共享
      可以直接被類名呼叫
      靜態方法不可以寫this,super
問：百錢買百雞
 公雞：5/只  母雞：3/只 小雞1/3只 100元買100只
public class Buy {
    //公雞5yuan一隻，母雞3元一隻，小雞3只一元錢，100元買100只
    public static void main(String[] args) {
        for (int i = 0; i < 100 / 5; i++) {
           for(int j=0;j<100/3;j++){
              for(int k=0;k<100;k=k+3){
                int count=i+j+k;
                int money=i*5+j*3+(k/3);
                if(money==100&&count==100){
                    System.out.println("公雞："+i+"母雞："+j+"小雞"+k);
                }
              }
           }
        }
    }
}

九、方法的重寫與過載 
重寫（Override）存在於繼承體系中，指子類實現了一個與父類在方法宣告上完全相同的一個方法，子類的返回值型別要等於或者小於父類的返回值；

過載（Overload）存在於同一個類中，指一個方法與已經存在的方法名稱上相同，但是引數型別、個數、順序至少有一個不同。應該注意的是，返回值不同，其它都相同不算是過載

方法覆蓋：1、靜態覆蓋靜態。非靜態覆蓋非靜態
          2、非私有方法，才能重寫
          3、子類的訪問許可權要大於父類的方法訪問許可權


十、子類的例項化過程：
子類中所有的建構函式預設都會訪問父類中空引數的建構函式，因為每一個建構函式的第一行都有一條預設的語句super();

十一、final
  類 方法 變數

十二、內部類：
1、定義在類內部的類成為內部類
2、內部類可以在類成員位置上
3、內部類還可以在方法內定義
4、內部類訪問區域性變數時，不能區域性變數進行重新賦值。java8不要求必須給區域性變數使用final修飾


day04
一、抽象類
抽象方法：沒有函式體的方法，必須使用abstract修飾，abstract void cry();必須在抽象類中
  抽象類不能例項化
抽象類：1、可以有建構函式
        2、由子類來例項化

二、非法修飾符組合： private+abstract      fianl+abstract
三、介面interface :最低標準 usb例子
  成員變數：public static final
  成員函式：public void white();
特點：所有方法都是抽象的，用來多實現，功能擴充套件
 面向介面程式設計：降低耦合度,可多重繼承
四、多型：同一種事物表現出的多種形態
         三個條件： 必須要有繼承
	            必須要重寫
	            父類引用指向子類物件
ClassCastException:類轉換異常
類中方法可以覆蓋，成員變數（資產）不能覆蓋
五、匿名內部類：簡化程式碼量，將類的宣告，方法的實現，物件的建立一氣呵成

public class 匿名內部類 {
    public static void main(String[] args) {
        tuHao t = new tuHao(new Bfm() {
            @Override
            public void white() {
                System.out.println("white....");
            }
        });
    }
}

interface Bfm {
    void white();
}

class tuHao {
    public tuHao(Bfm bfm) {
        bfm.white();
    }

}


六、介面卡模式
介面介面卡：有時我們寫的一個介面中有多個抽象方法，當我們寫該介面的實現類時，必須實現該介面的所有方法，
這明顯有時比較浪費，因為並不是所有的方法都是我們需要的，有時只需要某一些，此處為了解決這個問題
我們引入了介面的介面卡模式，藉助於一個抽象類，該抽象類實現了該介面，
實現了所有的方法，而我們不和原始的介面打交道，只和該抽象類取得聯絡，所以我們寫一個類，繼承該抽象類，
重寫我們需要的方法就行。

public class Adapter {
    public static void main(String[] args) {
       Button b1=new Button();
//匿名內部類物件
       b1.addListener(new MouseAdapter() {
           @Override
           public void onClick() {
               System.out.println("單機");
           }

           @Override
           public void onDbClick() {
               System.out.println("雙擊");
           }
       });
       b1.click();
       b1.onDbClick();

    }

}
//按鈕
class Button{
    private MouseListener listener;
    public void addListener(MouseListener listener){
        this.listener=listener;
    }

    public void click(){
         listener.onClick();
    }
    public void onDbClick(){
        listener.onDbClick();
    }

}
//滑鼠監聽器
interface MouseListener{
    public void onClick();
    public void onDbClick();
    public void rightClick();
    public void leftClick();
}
//滑鼠介面卡
abstract  class MouseAdapter implements MouseListener{
    public void rightClick(){ //可空實現

    }
    public void leftClick(){

    }
}
day05
異常
一、
throw丟擲異常物件的指令  throws在方法中修飾丟擲異常的關鍵字
try-catch-finally
finally只有一種情況不會執行，就是sysyem.exit();
可以有多個catch語句，catch的順序需要注意，子類異常需要先行catch,否則程式碼不可達，編譯無法通過
方法重寫時，不能宣告丟擲新的異常型別，只能是原有的異常體系。

二、java -cp classes -d   xxx.java //-cp指定編譯程式時需要搜尋的類路徑順序 
java -d classes xxx.java //-d
指定存放classes檔案的位置，同時生成對應的目錄樹
三、包、許可權

jar cvf xxx.jar -C foo/ .    //將foo目錄下的所有檔案進行歸檔，生成xxx.jar

四、程序：1、執行時的應用程式
          2、程序之間的記憶體不是共享（獨佔）
          3、程序間通訊使用套接字 socket
    執行緒：1、程序內併發執行的程式碼段
          2、執行緒之間共享記憶體
          3、建立靈活響應的桌面程式
          4、每個執行的執行緒對應一個stack
          5、應用程式至少有一個執行緒（主執行緒）

五、建立執行緒的方式
棧溢位：死遞迴
1、Thread.yield() 讓當前執行緒讓出cpu搶佔權，具有謙讓之意，順時的動作

2、Thread.sleep()讓當前執行緒休眠指定毫秒數

3、Thred.join() 當前執行緒等待指定的執行緒結束後才能繼續執行

4、Thread.setDaemon(true);  守護執行緒  為其他執行緒提供服務的執行緒
                                    若程序中剩餘執行緒都是守護執行緒的話，則程序終止了

執行緒間通訊，產生共享資源的問題：加鎖，防止併發訪問。由並行變為序列
例子：在火車上上廁所，搶到之後馬上上鎖，出來後，其他執行緒繼續搶；
synchronized
取票問題：
public class Ticket {
    public static void main(String[] args) {
        Saler s1 = new Saler("s1");
        Saler s2 = new Saler("s2");
        s1.start();
        s2.start();
    }
}

class Saler extends Thread {
    static int tickets = 100;
    static Object lock = new Object();
    private String name;

    public Saler(String name) {
        this.name = name;
    }

    public void run() {
        while (true) {
            int t = getTickets();
            if (t == -1) {
                return;
            } else {
                System.out.println(name + ":" + t);
            }

        }
    }

    //取票
    public int getTickets() {
        synchronized (lock) {
            int t = tickets;
            tickets = tickets - 1;
            return t < 1 ? -1 : t;
        }
    }
}

六、同步方法public synchronized void save(){}與同步程式碼塊synchronized(object){}的區別？
同步程式碼塊執行期間，執行緒始終持有物件的監控權，其他執行緒只能等待

七、同步靜態方法 ，使用類作為同步標記
  public staitc synchronized xxx(...){
          
  }
八、生產者和消費者
public class ThreadDemo {
    public static void main(String[] args) {
        Pool pool = new Pool();
        Productor p1 = new Productor("生產者", pool);
        Productor p2 = new Productor("生產者", pool);
        Customer c1 = new Customer("消費者", pool);
        p1.start();
        p2.start();
        c1.start();
    }
}

//生產者
class Productor extends Thread {
    static int i = 0;
    private String name;
    private Pool pool;

    public Productor(String name, Pool pool) {
        this.name = name;
        this.pool = pool;
    }

    public void run() {
        while (true) {
            pool.add(i++);
            try {
                Thread.sleep(100);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("生產了" + i + "");
        }

    }
}

//消費者
class Customer extends Thread {
    private String name;
    private Pool pool;

    public Customer(String name, Pool pool) {
        this.name = name;
        this.pool = pool;
    }

    public void run() {
        while (true) {
            int i = pool.remove();
            try {
                Thread.sleep(100);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("消費了" + i);
        }
    }
}


//生產 刪除方法類
class Pool {
    private List<Integer> list = new ArrayList<Integer>();
    //容量最大值
    private int Max = 100;//防止棧溢位，到達100等待

    //新增元素
    public void add(int n) {
        synchronized (this) {
            try {
                while (list.size() >= Max) {
                    this.wait(1);
                }
                    list.add(n);
                    System.out.println("size =="+list.size());
                    this.notify();

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    //刪除元素
    public int remove() {
        synchronized (this) {
            try {
                while (list.size() == 0) {
                    this.wait(1);
                }
                    int i = list.remove(0);
                    this.notify();
                    return i;

            } catch (Exception e) {
                e.printStackTrace();
            }
            return -1;
        }
    }

}
需要注意的是：java.lang.IllegalMonitorStateException 
            wait和notify方法的呼叫必須處在物件的鎖中，呼叫這些方法時首先需要獲得該物件的鎖
	    消費者被喚醒後是從wait()方法後面執行，而不是重新從同步塊開始

九、wait()和sleep()的區別？
sleep() :釋放cpu執行權，不釋放鎖
wait()：讓當前執行緒進入鎖旗標的等待佇列，釋放cpu執行權,釋放鎖
        暫定當前正在執行的執行緒,並釋放資源鎖,讓其他執行緒可以有機會執行(程式停頓在這一行).
notify()
十、解決死鎖的問題
notifyAll()通知所有執行緒可以搶佔cpu和鎖旗標監控權
wait(1000);等待固定的時間點


day06
equals() 與 == 的區別

對於基本型別，== 判斷兩個值是否相等（記憶體地址），基本型別沒有 equals() 方法。
對於引用型別，== 判斷兩個例項是否引用同一個物件，而 equals() 判斷引用的物件（物件內容）是否等價。需重寫。

一、Runnable介面
1、介面
2、public void runn(){};
3、使用Runnable物件建立執行緒(有3中建立方式) 
        new Thread(Runnable r).start();
4、供現有類實現執行緒功能
5、靜態同步方法是使用class作為鎖；
6、非靜態同步方法是使用this(當前物件)作為鎖；
public class Test {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(i);
                }
            }
        }).start();
    }
}
二、CAS:compare and set
避免同步帶來的效率降低
三、執行緒安全問題
      同步方法，同步程式碼塊，靜態同步程式碼塊
四、執行緒的六種狀態：
1.new  新建
2.runnable  可執行
3.blocked等待監視器的鎖定權  synchronized(this)  阻塞
4.waiting 一個執行緒等待另一個執行緒特定的操作 wait();
5.timed waiting 限時等待 wait(引數);
6.terminated  死亡
7.sleep休眠

五、String
1、一旦初始化不可被改變
2、建立String的區別：
      String s1="abc";//產生一個物件
 
      String s2=new String("abc");//產生二個物件
3、String類的部分方法
   例子：
   public class ziFu {
    public static void main(String[] args) {
        String s1 = "abc defga";
        String s2 = "gzzz";
        System.out.println(s1.charAt(1));// 返回指定索引處的 char 值。 b
        System.out.println(s1.contains(s2));//當且僅當此字串包含 char 值的指定序列時，才返回 true。
        System.out.println(s1.length());// 返回此字串的長度。
        System.out.println(s1.toCharArray());   //將此字串轉換為一個新的字元陣列。
        System.out.println(s1.indexOf("a"));//返回指定字元在此字串中第一次出現處的索引
        System.out.println(s1.endsWith(s2));//  測試此字串是否以指定的字尾結束。
        System.out.println(s1.getBytes());//將字串轉換成位元組陣列
        System.out.println(s1.replace(s1,s2));//用s2替換s1
        System.out.println(s1.toUpperCase());//變為大寫 toLowerCase()小寫
        String [] s3=s1.split(" ");// 根據給定的正則表示式的匹配來拆分此字串。
        System.out.println(s3);
        
        System.out.println(s1.substring(2));//擷取
        System.out.println(s1.substring(1,7));//擷取左閉右開區間 bcdefg
    }
}
4、debug
5、編碼表：
 ASCII：7位表示   GBK  UniCode:國際標準碼 2個位元組   UTF-8:最多使用3個byte表示字元
小組合作開發先調字符集：Utf-8碼
字元在記憶體中儲存的都是unicode碼

day07
作業：字串反轉
     1、StringBuffer 的reverse方法
     2、利用棧
     3、遞迴
一、StringBuffer
1、字串緩衝區
2、執行緒安全的
二、StringBuilder
1、字串構建器
2、執行緒不安全
三、包裝類wrapper
boolean —> Boolean
char —> Character
byte—> Byte
short—> Short
long—> Long
int —> Integer
float—> Float
double—> Double
四、建造器模式  
五、自動拆箱與自動裝箱
      1、自動裝箱：將基本型別自動裝換成包裝類物件
      2、自動拆箱：將包裝類物件自動裝換成基本型別
      Integer a=new Integer(12); //自動裝箱 Integer a=12;
      Integer b=new Integer(13);
      a+b=a.intValue()+b.intValue();
六、基本型別與包裝類的區別(int 與Integer的區別)
     1、包裝類是物件，擁有方法和欄位；基本型別不是
     2、包裝類是引用傳遞，基本型別是值傳遞。
     3、儲存位置不同，基本型別在棧中，包裝型別在堆中
     4、宣告方式不同，基本型別不需要new，包裝類需要new在堆記憶體中，通過物件的引用來呼叫。
     5、包裝類可以宣告為null，基本型別需初始化  Inteager a=null;
七、泛型
八、集合
   陣列：元素型別相同、長度固定、地址連續、下標訪問以0為基址
   集合：只能存放物件元素型別可以不同、長度可變
collection的兩個介面：list介面:有序可重複    set介面：無序不重複 （TreeSet特殊有序）
ArrayList:陣列 查詢快 儲存滿
   list add(..)
   list.remove(index);
   list.get(index);
   list.clear();
LinkedList:連結串列 通過手拉手實現物件引用，儲存快，查詢慢

九、重寫equals()

public voolean equals(Object obj){
 //1、obj==null
 if(obj==null){
        return false;
     }
 //2、是否是同一物件
 if(this==obj){
         return true;
      }     
 //3、判斷obj是否是person例項
 if(obj instanceof  Person){
      Person p0=(Pserson)obj;
      if(this.name.equals(p0.name)&&this.age==p0.age){
            return true;
      }
  }
  return fasle;
  }
}
十、迭代器
Iterator it=i.terator();
while(it.hasNext()){
   System.out.println(it.next());
}

day08
一箇中文佔幾個位元組？（不同的編碼格式下）
一、Map
  1、map介面是單獨的介面,沒有繼承任何介面，與之前的jdk版本不同
  2、key-value對，稱為Entry
  3、map.size()是entry的數量
  4、put放入，get提取
  5、HashMap.hash()方法意義
  6、Node<k,v>
          class Node<k,v>{
                final int hash;     //新hash
		final k key;  //key不能修改
		v value,      //value
		Node <k,v>next;  //

	  }
  7、元素重複的判斷標準
         (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))
  8、(p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))
     a. new Hash不同，物件不同
     b. new Hash相同。物件是同一物件，則物件相同
     c. new Hash相同，物件不是同一物件，再判斷equals方法，則物件相同性判定和equals一致
     

  5、迭代entrySet  keySet
  
        //迭代Map   entrySet
        Set<Map.Entry<String, String>> entries = map.entrySet();
        Iterator<Map.Entry<String, String>> iterator = entries.iterator();
        while(iterator.hasNext()){
            Map.Entry<String,String> entry = iterator.next();
            String key=entry.getKey();
            String value=entry.getValue();
            System.out.println(key+"==="+value);
        }

        //增加for
        Set<Map.Entry<Integer, String>> entries = map.entrySet();    //crtl+alt+v
        for(Map.Entry<Integer,String> entry:entries){
            Integer key=entry.getKey();
            String value=entry.getValue();
            System.out.println(key+"==="+value);
        }


	//迭代key    keySet
        Set<String> set = map.keySet();
        Iterator<String> iterator = set.iterator();
        while(iterator.hasNext()){
            String key=iterator.next();
            String value=map.get(key);
            System.out.println(key+"=="+value);
        }

        //增加for
        Set<Integer> keys = map.keySet();
        for(Integer key:keys){
            System.out.println(key+"==="+map.get(key));
        }

	//迭代value
	Collection<String> values = map.values();
        Iterator<String> iterator = values.iterator();
        while(iterator.hasNext()){
            String value = iterator.next();
            System.out.println(value);
        }


二、
問：
hashMap中的hash演算法的實現原理，為什麼？
1、為什麼移位？高16位向右移動16位，由高低16位做異或運算：目的是雜湊值跟特徵值相關
2、為什麼異或？相同為0，不同為1 使物件更加分散
hashMap擴容？bucket

三、唯一性
    HashSet:通過hashMap實現的
    TreeSet：通過compareTo或者compare方法，元素以二叉樹的形式存放
四、集合的巢狀
public class Demo {
    public static void main(String[] args) {
        //班級人數5
        List<String> names = null;
        //年級:10個班級的集合
        List<List<String>> grades = null;
        // 學校：6個年級的集合
        List<List<List<String>>> school = new ArrayList<List<List<String>>>();
        for (int i = 1; i <= 6; i++) {
            //建立每個年級，是班級的集合
            grades = new ArrayList<List<String>>();
            school.add(grades);
            //處理每個年級的班級集合
            for (int j = 1; j <= 10; j++) {
                names = new ArrayList<String>();
                grades.add(names);
                for (int k = 1; k <= 5; k++) {
                    names.add("tom--" + i + "-" + j + "-" + k);
                }
            }
        }
        outName(school);
    }
 //迭代輸出
    public static void outName(List<List<List<String>>> allNames) {
        Iterator<List<List<String>>> it = allNames.iterator();
        //每個年級
        while (it.hasNext()) {
            List<List<String>> grade = it.next();
            //班級
            Iterator<List<String>> classes = grade.iterator();
            while (classes.hasNext()) {
                List<String> names = classes.next();
                Iterator<String> nameIt = names.iterator();
                while (nameIt.hasNext()) {
                    System.out.println(nameIt.next());
                }
            }
        }
    }

}

day09
一、Map與Collection在集合中並列存在
Map儲存元素用put，Collection使用add方法
Map沒有直接取出元素的方法，而是先轉成Set集合，在通過迭代獲取元素
Map集合中key要保持唯一性
二、HashMap與HashTable與TreeMap
三、集合工具類
    Collection的max,min,synchronizedList,sort
    Arrays的sort,asList,binarySearch
四、可變引數
     public void add(String a,String...str) jdk1.5之後必須是方法的最後一個引數
五、陣列的拷貝
public class test1 {
    public static void main(String[] args) {
        int a1[]={1,2,3,4,5};
        int a2[]=new int[10];
	  //public static native void arraycopy(Object src,int srcPos, Object dest, int destPos,int length);
          //                                    原陣列,原陣列的開始位置，目標陣列，目標陣列的的開始位置，拷貝的個數
        System.arraycopy(a1,1,a2,3,3);
        System.out.println(Arrays.toString(a1));  //[1, 2, 3, 4, 5]
        System.out.println(Arrays.toString(a2));  //[0, 0, 0, 2, 3, 4, 0, 0, 0, 0]
    }
}

day10

一、IO流
 流的型別
  字元流：操作文字   Reader  Writer
  位元組流：二進位制檔案 InputStream  OutputStream 可操作媒體檔案。字串
 流向
   輸入：讀操作
   輸出：寫操作
二、java.io.FileWriter
   1、new FileWriter(String path);
   2、write(String str);寫入字元資料到流中
   3、flush() 清理流
   4、close()關閉 ，隱藏了flush()操作
   5、流在close之後，不能再寫入資料
      可重複關閉，不會出現問題 
讀檔案要比寫檔案複雜
public class Test {
    public static void main(String[] args) {
        try {
            FileReader reader = new FileReader("d:/hello.txt");
            char[] buffer = new char[3];
            int length = -1;
            while ((length = reader.read(buffer)) != -1) {
                System.out.println(new String(buffer, 0, length));
                      }
            reader.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

定義檔案路徑時，可以用"/"或者"\\"
作業：1、實現檔案的複製
      public class Test {
         public static void main(String[] args) {
        try {
            FileInputStream fis = new FileInputStream("d:/hello.txt");
            FileOutputStream fos = new FileOutputStream("H:/hello.txt");
            byte[] buffer = new byte[1024];
            int len = 0;
            while ((len = fis.read(buffer)) != -1) {
                fos.write(buffer, 0, len);
                fos.flush();
            }
            fis.close();
            fos.close();
            System.out.println("over");
     } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
      2、檔案的刪除
public class Test2 {
    public static void main(String[] args) {
        File dir=new File("d://liu");
        deleteFile(dir);
    }
    private static void deleteFile(File dir) {
        File[] files = dir.listFiles();//1,獲取該資料夾下的所有的檔案和資料夾
        for (File file : files) {//2,遍歷陣列
            if (file.isFile()) {//3,判斷是檔案直接刪除
                file.delete();
            } else {
                deleteFile(file); //4,如果是資料夾,遞迴呼叫
            }
        }
        dir.delete();//5,迴圈結束後,把空資料夾刪掉
        System.out.println("刪除完畢");
    }

      3、使用FileWriter,將1-100萬寫入到文字中
      4、hashSet和hashMap的關係
      5、檔案切割與合成
三、裝飾模式
四、緩衝區字元流
    1、BufferReader：這個類就是一個包裝類，它可以包裝字元流，將字元流放入快取裡，先把字元讀到快取裡，到快取滿了或者你flush的時候，再讀入記憶體，就是為了提供讀的效率而設計的。 
    2、BufferWriter
BufferedInputStream和BufferedOutputStream這兩個類分別是FilterInputStream和FilterOutputStream的子類，作為裝飾器子類，使用它們可以防止每次讀取/傳送資料時進行實際的寫操作，代表著使用緩衝區。

我們有必要知道不帶緩衝的操作，每讀一個位元組就要寫入一個位元組，由於涉及磁碟的IO操作相比記憶體的操作要慢很多，所以不帶緩衝的流效率很低。帶緩衝的流，可以一次讀很多位元組，但不向磁碟中寫入，只是先放到記憶體裡。等湊夠了緩衝區大小的時候一次性寫入磁碟，這種方式可以減少磁碟操作次數，速度就會提高很多！

同時正因為它們實現了緩衝功能，所以要注意在使用BufferedOutputStream寫完資料後，要呼叫flush()方法或close()方法，強行將緩衝區中的資料寫出。否則可能無法寫出資料。與之相似還BufferedReader和BufferedWriter兩個類。

BufferedInputStream和BufferedOutputStream類就是實現了緩衝功能的輸入流/輸出流。使用帶緩衝的輸入輸出流，效率更高，速度更快。

五、函式的回撥
六、單元測試
    @Test  要求：不能帶參不能有返回值不能是靜態方法
FileInputStream
       支援skip()方法，skip向後跳的時候不能是檔案頭地址，可以超過檔案末尾地址
FileOutputStream
       不支援skip
RandomAccessFile
       隨機訪問檔案，定位到檔案的任意位置