Java基礎Day8

1.API

1.1API概述【理解】

• 什麼是API

  API (Application Programming Interface) ：應用程序編程接口

  • 簡單理解就是學習Java已經寫好的類.

    • API是一個大的概念, 每一門編程語言在設計完畢之後, 都會存在一些已經寫好的類.

  • Scanner Random

• java中的API

  指的就是 JDK 中提供的各種功能的 Java類，這些類將底層的實現封裝了起來，我們不需要關心這些類是如何實現的，只需要學習這些類如何使用即可，我們可以通過幫助文檔來學習這些API如何使用。

1.2如何使用API幫助文檔【應用】

• 打開幫助文檔

 

• 找到索引選項卡中的輸入框

 

• 在輸入框中輸入Random

 

• 看類在哪個包下

 

• 看類的描述

 

• 看構造方法

 

• 看成員方法

 

2.String類

2.1String類概述【理解】

String 類代表字符串，Java 程序中的所有字符串文字（例如“abc”）都被實現爲此類的實例(對象)。

也就是說，Java 程序中所有的雙引號字符串，都是 String 類的對象。String 類在 java.lang 包下，所以使用的時候不需要導包

2.2String類的特點【理解】

• 字符串不可變，它們的值在創建後不能被更改

  • 關於不可改變的理解

    public class Demo1_String {
        public static void main(String[] args) {
            // String 類代表字符串。Java 程序中的所有字符串字面值（如 "abc" ）都作爲此類的實例實現。
            String s = "abc";
            // 字符串是一個不可改變的字符序列
            s = "def";          // 這一步不是對abc進行更改, 而是讓s變量記錄了一個新的字符串, 原來的abc一點沒動.
            System.out.println(s);
    ​
        }
    }

• 雖然 String 的值是不可變的，但是它們可以被共享

  • jdk8版本之前, 常量池在方法區

  • jdk8版本之後, 常量池整體挪到了堆內存.

• 字符串效果上相當於字符數組( char[] )，但是底層原理是字節數組( byte[] )

  • jdk8版本, 8版本之前, 底層源碼是char[]字符數組

  • jdk9版本以後, 底層的源碼是byte[] 字節數組

  • char[] 數組和 字符串之間是可以進行相互轉換的.

2.3String類的構造方法【記憶】

• 常用的構造方法

  方法名	說明
  public String()	創建一個空白字符串對象，不含有任何內容
  public String(char[] chs) √	根據字符數組的內容，來創建字符串對象
  public String(byte[] bys)	根據字節數組的內容，來創建字符串對象
  String s = “abc”; √	直接賦值的方式創建字符串對象，內容就是abc

• 示例代碼

  public class StringDemo01 {
      public static void main(String[] args) {
          //public String()：創建一個空白字符串對象，不含有任何內容
          String s1 = new String();
          System.out.println("s1:" + s1);
  ​
          //public String(char[] chs)：根據字符數組的內容，來創建字符串對象
          char[] chs = {'a', 'b', 'c'};
          String s2 = new String(chs);
          System.out.println("s2:" + s2);
  ​
          //public String(byte[] bys)：根據字節數組的內容，來創建字符串對象
          byte[] bys = {97, 98, 99};
          String s3 = new String(bys);
          System.out.println("s3:" + s3);
  ​
          //String s = “abc”; 直接賦值的方式創建字符串對象，內容就是abc
          String s4 = "abc";
          System.out.println("s4:" + s4);
      }
  }

2.4創建字符串對象兩種方式的區別【理解】

• 通過構造方法創建

  通過 new 創建的字符串對象，每一次 new 都會申請一個內存空間，雖然內容相同，但是地址值不同

  String s1 = new String("abc");

  String s2 = new String("abc");

  System.out.println(s1 == s2); // false

• 直接賦值方式創建

  以“”方式給出的字符串，只要字符序列相同(順序和大小寫)，無論在程序代碼中出現幾次，JVM 都只會建立一個 String 對象，並在字符串池中維護

  String s1 = "abc";

  String s2 = "abc";

  System.out.println(s1 == s2); // true

2.5字符串的比較【理解】

2.5.1==號的作用

• 比較基本數據類型：比較的是具體的值

  • System.out.println(10 == 10); // true

• 比較引用數據類型：比較的是對象地址值

  • int[] arr1 = {1,2,3}; int[] arr2 = {1,2,3};

  • System.out.println(arr1 == arr2); // false

2.5.2equals方法的作用

• 方法介紹

  public boolean equals(String s)     比較兩個字符串內容是否相同、區分大小寫

• 示例代碼

  public class StringDemo02 {
      public static void main(String[] args) {
          //構造方法的方式得到對象
          char[] chs = {'a', 'b', 'c'};
          String s1 = new String(chs);
          String s2 = new String(chs);
  ​
          //直接賦值的方式得到對象
          String s3 = "abc";
          String s4 = "abc";
  ​
          //比較字符串對象地址是否相同
          System.out.println(s1 == s2);       // false
          System.out.println(s1 == s3);       // false
          System.out.println(s3 == s4);       // true
          System.out.println("--------");
  ​
          //比較字符串內容是否相同
          System.out.println(s1.equals(s2));  // true
          System.out.println(s1.equals(s3));  // true
          System.out.println(s3.equals(s4));  // true
      }
  }

• 問題: 字符串常量池在內存中的哪個位置?

  jdk7版本包括7之前, 在方法區中

  jdk8版本之後, 整體挪到了堆內存中.

2.6用戶登錄案例【應用】

2.6.1案例需求

已知用戶名和密碼，請用程序實現模擬用戶登錄。總共給三次機會，登錄之後，給出相應的提示

2.6.2代碼實現

/*
    思路：
        1:已知用戶名和密碼，定義兩個字符串表示即可
        2:鍵盤錄入要登錄的用戶名和密碼，用 Scanner 實現
        3:拿鍵盤錄入的用戶名、密碼和已知的用戶名、密碼進行比較，給出相應的提示。字符串的內容比較，用equals() 方法實現
        4:用循環實現多次機會，這裏的次數明確，採用for循環實現，並在登錄成功的時候，使用break結束循環
 */
public class StringTest01 {
    public static void main(String[] args) {
        //已知用戶名和密碼，定義兩個字符串表示即可
        String username = "itheima";
        String password = "czbk";
​
        //用循環實現多次機會，這裏的次數明確，採用for循環實現，並在登錄成功的時候，使用break結束循環
        for(int i=0; i<3; i++) {
​
            //鍵盤錄入要登錄的用戶名和密碼，用 Scanner 實現
            Scanner sc = new Scanner(System.in);
​
            System.out.println("請輸入用戶名：");
            String name = sc.nextLine();
​
            System.out.println("請輸入密碼：");
            String pwd = sc.nextLine();
​
            //拿鍵盤錄入的用戶名、密碼和已知的用戶名、密碼進行比較，給出相應的提示。字符串的內容比較，用equals() 方法實現
            if (name.equals(username) && pwd.equals(password)) {
                System.out.println("登錄成功");
                break;
            } else {
                if(2-i == 0) {
                    System.out.println("你的賬戶被鎖定，請與管理員聯繫");
                } else {
                    //2,1,0
                    //i,0,1,2
                    System.out.println("登錄失敗，你還有" + (2 - i) + "次機會");
                }
            }
        }
    }
}

2.7遍歷字符串案例【應用】

2.7.1案例需求

鍵盤錄入一個字符串，使用程序實現在控制檯遍歷該字符串

2.7.2代碼實現

/*
    思路：
        1:鍵盤錄入一個字符串，用 Scanner 實現
        2:遍歷字符串，首先要能夠獲取到字符串中的每一個字符
            public char charAt(int index)：返回指定索引處的char值，字符串的索引也是從0開始的
        3:遍歷字符串，其次要能夠獲取到字符串的長度
            public int length()：返回此字符串的長度
            數組的長度：數組名.length
            字符串的長度：字符串對象.length()
        4:遍歷字符串的通用格式
 */
public class StringTest02 {
    public static void main(String[] args) {
        //鍵盤錄入一個字符串，用 Scanner 實現
        Scanner sc = new Scanner(System.in);
​
        System.out.println("請輸入一個字符串：");
        String line = sc.nextLine();
​
        for(int i=0; i<line.length(); i++) {
            System.out.println(line.charAt(i));
        }
    }
}

2.8統計字符次數案例【應用】

2.8.1案例需求

鍵盤錄入一個字符串，統計該字符串中大寫字母字符，小寫字母字符，數字字符出現的次數(不考慮其他字符)

2.8.2代碼實現

/*
  思路：
        1:鍵盤錄入一個字符串，用 Scanner 實現
        2:要統計三種類型的字符個數，需定義三個統計變量，初始值都爲0
        3:遍歷字符串，得到每一個字符
        4:判斷該字符屬於哪種類型，然後對應類型的統計變量+1
            假如ch是一個字符，我要判斷它屬於大寫字母，小寫字母，還是數字，直接判斷該字符是否在對應的範圍即可
            大寫字母：ch>='A' && ch<='Z'
            小寫字母： ch>='a' && ch<='z'
            數字： ch>='0' && ch<='9'
        5:輸出三種類型的字符個數
 */
public class StringTest03 {
    public static void main(String[] args) {
        //鍵盤錄入一個字符串，用 Scanner 實現
        Scanner sc = new Scanner(System.in);
​
        System.out.println("請輸入一個字符串：");
        String line = sc.nextLine();
​
        //要統計三種類型的字符個數，需定義三個統計變量，初始值都爲0
        int bigCount = 0;
        int smallCount = 0;
        int numberCount = 0;
​
        //遍歷字符串，得到每一個字符
        for(int i=0; i<line.length(); i++) {
            char ch = line.charAt(i);
​
            //判斷該字符屬於哪種類型，然後對應類型的統計變量+1
            if(ch>='A' && ch<='Z') {
                bigCount++;
            } else if(ch>='a' && ch<='z') {
                smallCount++;
            } else if(ch>='0' && ch<='9') {
                numberCount++;
            }
        }
​
        //輸出三種類型的字符個數
        System.out.println("大寫字母：" + bigCount + "個");
        System.out.println("小寫字母：" + smallCount + "個");
        System.out.println("數字：" + numberCount + "個");
    }
}

2.9字符串拼接案例【應用】

2.9.1案例需求

定義一個方法，把 int 數組中的數據按照指定的格式拼接成一個字符串返回，調用該方法，

並在控制檯輸出結果。例如，數組爲 int[] arr = {1,2,3}; ，執行方法後的輸出結果爲：[1, 2, 3]

2.9.2代碼實現

/*
    思路：
        1:定義一個 int 類型的數組，用靜態初始化完成數組元素的初始化
        2:定義一個方法，用於把 int 數組中的數據按照指定格式拼接成一個字符串返回。
          返回值類型 String，參數列表 int[] arr
        3:在方法中遍歷數組，按照要求進行拼接
        4:調用方法，用一個變量接收結果
        5:輸出結果
 */
public class StringTest04 {
    public static void main(String[] args) {
        //定義一個 int 類型的數組，用靜態初始化完成數組元素的初始化
        int[] arr = {1, 2, 3};
​
        //調用方法，用一個變量接收結果
        String s = arrayToString(arr);
​
        //輸出結果
        System.out.println("s:" + s);
    }
​
    //定義一個方法，用於把 int 數組中的數據按照指定格式拼接成一個字符串返回
    /*
        兩個明確：
            返回值類型：String
            參數：int[] arr
     */
    public static String arrayToString(int[] arr) {
        //在方法中遍歷數組，按照要求進行拼接
        String s = "";
​
        s += "[";
​
        for(int i=0; i<arr.length; i++) {
            if(i==arr.length-1) {
                s += arr[i];
            } else {
                s += arr[i];
                s += ", ";
            }
        }
​
        s += "]";
​
        return s;
    }
}

2.10字符串反轉案例【應用】

2.10.1案例需求

定義一個方法，實現字符串反轉。鍵盤錄入一個字符串，調用該方法後，在控制檯輸出結果

例如，鍵盤錄入 abc，輸出結果 cba

2.10.2代碼實現

/*
    思路：
        1:鍵盤錄入一個字符串，用 Scanner 實現
        2:定義一個方法，實現字符串反轉。返回值類型 String，參數 String s
        3:在方法中把字符串倒着遍歷，然後把每一個得到的字符拼接成一個字符串並返回
        4:調用方法，用一個變量接收結果
        5:輸出結果
 */
public class StringTest05 {
    public static void main(String[] args) {
        //鍵盤錄入一個字符串，用 Scanner 實現
        Scanner sc = new Scanner(System.in);
​
        System.out.println("請輸入一個字符串：");
        String line = sc.nextLine();
​
        //調用方法，用一個變量接收結果
        String s = reverse(line);
​
        //輸出結果
        System.out.println("s:" + s);
    }
​
    //定義一個方法，實現字符串反轉
    /*
        兩個明確：
            返回值類型：String
            參數：String s
     */
    public static String reverse(String s) {
        //在方法中把字符串倒着遍歷，然後把每一個得到的字符拼接成一個字符串並返回
        String ss = "";
​
        for(int i=s.length()-1; i>=0; i--) {
            ss += s.charAt(i);
        }
​
        return ss;
    }
}

2.11幫助文檔查看String常用方法【記憶】

方法名	說明
public boolean equals(Object anObject)	比較字符串的內容，嚴格區分大小寫(用戶名和密碼)
public char charAt(int index)	返回指定索引處的 char 值
public int length()	返回此字符串的長度

3.StringBuilder(字符串的緩衝區)類

3.1StringBuilder類概述【理解】

StringBuilder 是一個可變的字符串類，我們可以把它看成是一個容器，這裏的可變指的是 StringBuilder 對象中的內容是可變的

3.2StringBuilder類和String類的區別【理解】

• String類：內容是不可變的

• StringBuilder類：內容是可變的

3.3StringBuilder類的構造方法【記憶】

• 常用的構造方法

  方法名	說明
  public StringBuilder()	創建一個空的字符串的緩衝區
  public StringBuilder(String str)	創建一個帶有數據的字符串緩衝區,數據由參數而定

• 示例代碼

public class StringBuilderDemo01 {
    public static void main(String[] args) {
        //public StringBuilder()：創建一個空白可變字符串對象，不含有任何內容
        StringBuilder sb = new StringBuilder();
        System.out.println("sb:" + sb);
        System.out.println("sb.length():" + sb.length());
​
        //public StringBuilder(String str)：根據字符串的內容，來創建可變字符串對象
        StringBuilder sb2 = new StringBuilder("hello");
        System.out.println("sb2:" + sb2);
        System.out.println("sb2.length():" + sb2.length());
    }
}

3.4StringBuilder類添加和反轉方法【記憶】

• 添加和反轉方法

  方法名	說明
  public StringBuilder append(任意類型)	添加數據，並返回對象本身
  public StringBuilder reverse()	返回相反的字符序列

• 示例代碼

public class StringBuilderDemo01 {
    public static void main(String[] args) {
        //創建對象
        StringBuilder sb = new StringBuilder();
​
        //public StringBuilder append(任意類型)：添加數據，並返回對象本身
//        StringBuilder sb2 = sb.append("hello");
//
//        System.out.println("sb:" + sb);
//        System.out.println("sb2:" + sb2);
//        System.out.println(sb == sb2);
​
//        sb.append("hello");
//        sb.append("world");
//        sb.append("java");
//        sb.append(100);
​
        //鏈式編程
        sb.append("hello").append("world").append("java").append(100);
​
        System.out.println("sb:" + sb);
​
        //public StringBuilder reverse()：返回相反的字符序列
        sb.reverse();
        System.out.println("sb:" + sb);
    }
}

3.5StringBuilder和String相互轉換【應用(重點)】

• StringBuilder轉換爲String

  public String toString()：通過 toString() 就可以實現把 StringBuilder 轉換爲 String

• String轉換爲StringBuilder

  public StringBuilder(String s)：通過構造方法就可以實現把 String 轉換爲 StringBuilder

• 示例代碼

public class StringBuilderDemo02 {
    public static void main(String[] args) {
        /*
        //StringBuilder 轉換爲 String
        StringBuilder sb = new StringBuilder();
        sb.append("hello");
​
        //String s = sb; //這個是錯誤的做法
​
        //public String toString()：通過 toString() 就可以實現把 StringBuilder 轉換爲 String
        String s = sb.toString();
        System.out.println(s);
        */
​
        //String 轉換爲 StringBuilder
        String s = "hello";
​
        //StringBuilder sb = s; //這個是錯誤的做法
​
        //public StringBuilder(String s)：通過構造方法就可以實現把 String 轉換爲 StringBuilder
        StringBuilder sb = new StringBuilder(s);
​
        System.out.println(sb);
    }
}

應用場景 :

String - StringBuilder : 如果需要調用StringBuilder裏面的方法, 就可以進行轉換.

StringBuilder - String : 如果要實現的需求, 對類型有限制, 就需要轉換

 

if(s.equals(sb.toString())){

}

 

3.6字符串拼接升級版案例【應用】

3.6.1案例需求

定義一個方法，把 int 數組中的數據按照指定的格式拼接成一個字符串返回，調用該方法，

並在控制檯輸出結果。例如，數組爲int[] arr = {1,2,3}; ，執行方法後的輸出結果爲：[1, 2, 3]

3.6.2代碼實現

/*
    思路：
        1:定義一個 int 類型的數組，用靜態初始化完成數組元素的初始化
        2:定義一個方法，用於把 int 數組中的數據按照指定格式拼接成一個字符串返回。
          返回值類型 String，參數列表 int[] arr
        3:在方法中用 StringBuilder 按照要求進行拼接，並把結果轉成 String 返回
        4:調用方法，用一個變量接收結果
        5:輸出結果
 */
public class StringBuilderTest01 {
    public static void main(String[] args) {
        //定義一個 int 類型的數組，用靜態初始化完成數組元素的初始化
        int[] arr = {1, 2, 3};
​
        //調用方法，用一個變量接收結果
        String s = arrayToString(arr);
​
        //輸出結果
        System.out.println("s:" + s);
​
    }
​
    //定義一個方法，用於把 int 數組中的數據按照指定格式拼接成一個字符串返回
    /*
        兩個明確：
            返回值類型：String
            參數：int[] arr
     */
    public static String arrayToString(int[] arr) {
        //在方法中用 StringBuilder 按照要求進行拼接，並把結果轉成 String 返回
        StringBuilder sb = new StringBuilder();
​
        sb.append("[");
​
        for(int i=0; i<arr.length; i++) {
            if(i == arr.length-1) {
                sb.append(arr[i]);
            } else {
                sb.append(arr[i]).append(", ");
            }
        }
​
        sb.append("]");
​
        String s = sb.toString();
​
        return  s;
    }
}

3.7字符串反轉升級版案例【應用】

3.7.1案例需求

定義一個方法，實現字符串反轉。鍵盤錄入一個字符串，調用該方法後，在控制檯輸出結果

例如，鍵盤錄入abc，輸出結果 cba

3.7.2代碼實現

/*
    思路：
        1:鍵盤錄入一個字符串，用 Scanner 實現
        2:定義一個方法，實現字符串反轉。返回值類型 String，參數 String s
        3:在方法中用StringBuilder實現字符串的反轉，並把結果轉成String返回
        4:調用方法，用一個變量接收結果
        5:輸出結果
 */
public class StringBuilderTest02 {
    public static void main(String[] args) {
        //鍵盤錄入一個字符串，用 Scanner 實現
        Scanner sc = new Scanner(System.in);
​
        System.out.println("請輸入一個字符串：");
        String line = sc.nextLine();
​
        //調用方法，用一個變量接收結果
        String s = myReverse(line);
​
        //輸出結果
        System.out.println("s:" + s);
    }
​
    //定義一個方法，實現字符串反轉。返回值類型 String，參數 String s
    /*
        兩個明確：
            返回值類型：String
            參數：String s
     */
    public static String myReverse(String s) {
        //在方法中用StringBuilder實現字符串的反轉，並把結果轉成String返回
        //String --- StringBuilder --- reverse() --- String
//        StringBuilder sb = new StringBuilder(s);
//        sb.reverse();
//        String ss = sb.toString();
//        return ss;
​
       return new StringBuilder(s).reverse().toString();
    }
}

3.8幫助文檔查看StringBuilder常用方法【記憶】

方法名	說明
public StringBuilder append (任意類型)	添加數據，並返回對象本身
public StringBuilder reverse()	返回相反的字符序列
public int length()	返回長度，實際存儲值
public String toString()	通過toString()就可以實現把StringBuilder轉換爲String