[TOC]

StringBuffer類

StringBuffer類概述及其構造方法

• StringBuffer類概述

  • 線程安全的可變字符序列。
  • 用字符串做拼接，比較耗時并且也耗內存，而這種拼接操作又是比較常見的，為了解決這個問題，Java就提供了一個字符串緩沖區類StringBuffer供我們使用。

• StringBuffer和String的區別?

  • 前者長度和內容可變，后者不可變。
  • 如果使用前者做字符串的拼接，不會浪費太多的資源。

• 構造方法

  • public StringBuffer()：無參構造方法。
  • public StringBuffer(int capacity)：指定容量的字符串緩沖器對象。
  • public StringBuffer(String str)：指定字符串內容的字符串緩沖器對象。

• StringBuffer的方法：

  • public int capacity()：返回當前容量。（初始值16個字符） 理論值
  • public int length():返回長度（字符數）。 實際值

public class StringBufferDemo {
    public static void main(String[] args) {
        // public StringBuffer():無參構造方法
        StringBuffer sb = new StringBuffer();
        System.out.println("sb:" + sb);
        System.out.println("sb.capacity():" + sb.capacity());
        System.out.println("sb.length():" + sb.length());
        System.out.println("--------------------------");

        // public StringBuffer(int capacity):指定容量的字符串緩沖區對象
        StringBuffer sb2 = new StringBuffer(50);
        System.out.println("sb2:" + sb2);
        System.out.println("sb2.capacity():" + sb2.capacity());
        System.out.println("sb2.length():" + sb2.length());
        System.out.println("--------------------------");

        // public StringBuffer(String str):指定字符串內容的字符串緩沖區對象
        StringBuffer sb3 = new StringBuffer("hello");
        System.out.println("sb3:" + sb3);
        System.out.println("sb3.capacity():" + sb3.capacity());
        System.out.println("sb3.length():" + sb3.length());
    }
}

/*
運行結果：
sb:
sb.capacity():16
sb.length():0
--------------------------
sb2:
sb2.capacity():50
sb2.length():0
--------------------------
sb3:hello
sb3.capacity():21 // 16+5
sb3.length():5
*/

StringBuffer類的成員方法

• ** 添加**功能

  • public StringBuffer** append**(String str)

    • 可以把任意類型數據添加到字符串緩沖區里面,并返回字符串緩沖區本身

    // 創建字符串緩沖區對象
    StringBuffer sb = new StringBuffer();
    
    //public StringBuffer append(String str)
    StringBuffer sb2 = sb.append("hello");//將hello添加到StringBuffer緩沖器
    System.out.println("sb:" + sb);
    System.out.println("sb2:" + sb2);
    System.out.println(sb == sb2); // true
    

    StringBuffer sb = new StringBuffer();
    // 鏈式編程
    sb.append("hello").append(true).append(12).append(34.56);
    System.out.println("sb:" + sb);
    sb.insert(5, "world");
    System.out.println("sb:" + sb);
    

  • public StringBuffer insert(int offset,String str)

    • 在指定位置把任意類型的數據插入到字符串緩沖區里面,并返回字符串緩沖區本身

• 刪除功能

  • public StringBuffer deleteCharAt(int index)
    • 刪除指定位置的字符，并返回本身
  • public StringBuffer delete(int start,int end)
    • 刪除從指定位置開始指定位置結束的內容，并返回本身（包左不包右）

    // public StringBuffer delete(int start,int
    // end):刪除從指定位置開始指定位置結束的內容，并返回本身
    // 需求：我要刪除world這個字符串
    // sb.delete(5, 10);
    
    // 需求:我要刪除所有的數據
    sb.delete(0, sb.length());
    System.out.println("sb:" + sb);
    

• 替換功能

  • public StringBuffer replace(int start,int end,String str)
    • 從start開始到end用str替換

    // 需求：我要把world這個數據替換為"節日快樂"
    sb.replace(5, 10, "節日快樂");
    System.out.println("sb:" + sb);
    

• 反轉功能

  • public StringBuffer reverse()

      // 添加數據
      sb.append("霞青林愛我");
      System.out.println("sb:" + sb);
  
      // public StringBuffer reverse()
      sb.reverse();
      System.out.println("sb:" + sb);
  

/*
result:
sb:霞青林愛我
sb:我愛林青霞
*/
```

• 截取功能 : 注意返回值類型不再是StringBuffer本身,而是String類型
  • public String substring(int start)
  • public String substring(int start,int end)
    • 截取功能和前面幾個功能的不同：返回值類型是String類型，本身沒有發生改變

    public class StringBufferDemo {
    public static void main(String[] args) {
        // 創建字符串緩沖區對象
        StringBuffer sb = new StringBuffer();

        // 添加元素
        sb.append("hello").append("world").append("java");
        System.out.println("sb:" + sb);

        // 截取功能
        // public String substring(int start)
        String s = sb.substring(5);
        System.out.println("s:" + s);
        System.out.println("sb:" + sb);

        // public String substring(int start,int end)
        String ss = sb.substring(5, 10);
        System.out.println("ss:" + ss);
        System.out.println("sb:" + sb);
    }
}

StringBuffer類練習

• String和StringBuffer的相互轉換
  • 注意：不能把字符串的值直接賦值給StringBuffer,可通過以下兩種方式進行賦值：
• String轉StringBuffer方法：
  • 方式1:通過構造方法
    • StringBuffer sb = new StringBuffer(s);
  • 方式2：通過append()方法
    • StringBuffer sb2 = new StringBuffer();
    • sb2.append(s);
• StringBuffer轉String方法：
  • 注：任何引用類型調用toString方法都可以轉為String類型。
  • 方式1:通過構造方法
    • String str = new String(buffer);
  • 方式2：通過toString()方法
    • String str2 = buffer.toString();

public class StringBufferTest {
    public static void main(String[] args) {
        // String -- StringBuffer
        String s = "hello";
        StringBuffer sb2 = new StringBuffer();
        sb2.append(s);
        System.out.println("sb:" + sb);
        System.out.println("sb2:" + sb2);
        System.out.println("---------------");

        // StringBuffer -- String
        StringBuffer buffer = new StringBuffer("java");
        // String(StringBuffer buffer)
        // 方式1:通過構造方法
        String str = new String(buffer);
        // 方式2：通過toString()方法
        String str2 = buffer.toString();
        System.out.println("str:" + str);
        System.out.println("str2:" + str2);
    }
}

• 把數組拼接成一個字符串

public class StringBufferTest2 {
    public static void main(String[] args) {
        // 定義一個數組
        int[] arr = { 44, 33, 55, 11, 22 };

        //用StringBuffer做拼接的方式
        String s2 = arrayToString2(arr);
        System.out.println("s2:" + s2);
    }

    // 用StringBuffer做拼接的方式
    public static String arrayToString2(int[] arr) {
        StringBuffer sb = new StringBuffer();
        sb.append("[");
        for (int x = 0; x < arr.length; x++) {
            if (x == arr.length - 1) {
                sb.append(arr[x]);
            } else {
                sb.append(arr[x]).append(", ");
            }
        }
        sb.append("]");

        return sb.toString();
    }
}

• 把字符串反轉

public class StringBufferTest3 {
    public static void main(String[] args) {
        // 鍵盤錄入數據
        Scanner sc = new Scanner(System.in);
        System.out.println("請輸入數據：");
        String s = sc.nextLine();

        // 方式1：用String做拼接
        String s1 = myReverse(s);
        System.out.println("s1:" + s1);
        // 方式2：用StringBuffer的reverse()功能
        String s2 = myReverse2(s);
        System.out.println("s2:" + s2);
    }

    // 用StringBuffer的reverse()功能
    public static String myReverse2(String s) {
        // StringBuffer sb = new StringBuffer();
        // sb.append(s);

        // StringBuffer sb = new StringBuffer(s);
        // sb.reverse();
        // return sb.toString();

        // 簡易版
        return new StringBuffer(s).reverse().toString();
    }

    // 用String做拼接
    public static String myReverse(String s) {
        String result = "";

        char[] chs = s.toCharArray();
        for (int x = chs.length - 1; x >= 0; x--) {
            // char ch = chs[x];
            // result += ch;
            result += chs[x];
        }

        return result;
    }
}

• 判斷一個字符串是否是對稱字符串
  • 例如"abc"不是對稱字符串，"aba"、"abba"、"aaa"、"mnanm"是對稱字符串

public class StringBufferTest4 {
    public static void main(String[] args) {
        // 創建鍵盤錄入對象
        Scanner sc = new Scanner(System.in);
        System.out.println("請輸入一個字符串：");
        String s = sc.nextLine();

        // 一個一個的比較
        boolean b = isSame(s);
        System.out.println("b:" + b);
        
        //用字符串緩沖區的反轉功能
        boolean b2 = isSame2(s);
        System.out.println("b2:"+b2);
    }
    
    public static boolean isSame2(String s) {
        return new StringBuffer(s).reverse().toString().equals(s);
    }

    public static boolean isSame(String s) {
        boolean flag = true;

        // 把字符串轉成字符數組
        char[] chs = s.toCharArray();

        for (int start = 0, end = chs.length - 1; start <= end; start++, end--) {
            if (chs[start] != chs[end]) {
                flag = false;
                break;
            }
        }
        return flag;
    }
}

StringBuffer類面試題

• 通過查看API了解一下StringBuilder類

  • 此類提供一個與 StringBuffer 兼容的 API，但不保證同步。該類被設計用作 StringBuffer 的一個簡易替換，用在字符串緩沖區被單個線程使用的時候（這種情況很普遍）。如果可能，建議優先采用該類，因為在大多數實現中，它比 StringBuffer 要快。

• String , StringBuffer , StringBuilder的區別

  • A:String是內容不可變的，而StringBuffer,StringBuilder都是內容可變的。
  • B:StringBuffer是同步的，數據安全,效率低;
  • C:StringBuilder是不同步的,數據不安全,效率高

• StringBuffer和數組的區別?

  • 二者都可以看出是一個容器，裝其他的數據。
  • StringBuffer的數據最終是一個字符串數據。
  • 數組可以放置多種數據，但必須是同一種數據類型的。

• 看程序寫結果：
  • String作為參數傳遞
  • StringBuffer作為參數傳遞
• 注意：
  • String作為參數傳遞，效果和基本類型作為參數傳遞是一樣的。
  • StringBuffer類型調用append方法時內存值會改變

public class StringBufferDemo {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "world";
        System.out.println(s1 + "---" + s2);// hello---world
        change(s1, s2);
        System.out.println(s1 + "---" + s2);// hello---world

        StringBuffer sb1 = new StringBuffer("hello");
        StringBuffer sb2 = new StringBuffer("world");
        System.out.println(sb1 + "---" + sb2);// hello---world
        change(sb1, sb2);
        System.out.println(sb1 + "---" + sb2);// hello---worldworld

    }

    public static void change(StringBuffer sb1, StringBuffer sb2) {
        sb1 = sb2;//StringBuffer類型用`=`賦值的特殊點。
        sb2.append(sb1);
    }

    public static void change(String s1, String s2) {
        s1 = s2;
        s2 = s1 + s2;
    }
}

數組高級(排序和查找)

排序

• 冒泡排序(必須掌握)
  • 相鄰元素兩兩比較，大的往后放，第一次完畢，最大值出現在了最大索引處
    

public class ArrayDemo {
    public static void main(String[] args) {
        // 定義一個數組
        int[] arr = { 24, 69, 80, 57, 13 };
        System.out.println("排序前：");
        printArray(arr);

        //由于我可能有多個數組要排序，所以我要寫成方法
        bubbleSort(arr);
        System.out.println("排序后：");
        printArray(arr);
    }
    
    //冒泡排序代碼
    public static void bubbleSort(int[] arr){
        for (int x = 0; x < arr.length - 1; x++) {
            for (int y = 0; y < arr.length - 1 - x; y++) {
                if (arr[y] > arr[y + 1]) {
                    int temp = arr[y];
                    arr[y] = arr[y + 1];
                    arr[y + 1] = temp;
                }
            }
        }
    }

    // 遍歷功能
    public static void printArray(int[] arr) {
        System.out.print("[");
        for (int x = 0; x < arr.length; x++) {
            if (x == arr.length - 1) {
                System.out.print(arr[x]);
            } else {
                System.out.print(arr[x] + ", ");
            }
        }
        System.out.println("]");
    }
}

• 選擇排序

  • 從0索引開始，依次和后面元素比較，小的往前放，第一次完畢，最小值出現在了最小索引處

    
    

public class ArrayDemo {
    public static void main(String[] args) {
        // 定義一個數組
        int[] arr = { 24, 69, 80, 57, 13 };
        System.out.println("排序前：");
        printArray(arr);

        //用方法改進
        selectSort(arr);
        System.out.println("排序后：");
        printArray(arr);

    }
    
    public static void selectSort(int[] arr){
        for(int x=0; x<arr.length-1; x++){
            for(int y=x+1; y<arr.length; y++){
                if(arr[y] <arr[x]){
                    int temp = arr[x];
                    arr[x] = arr[y];
                     arr[y] = temp;
                }
            }
        }
    }

    // 遍歷功能
    public static void printArray(int[] arr) {
        System.out.print("[");
        for (int x = 0; x < arr.length; x++) {
            if (x == arr.length - 1) {
                System.out.print(arr[x]);
            } else {
                System.out.print(arr[x] + ", ");
            }
        }
        System.out.println("]");
    }
}

練習題：字符串排序

public class ArrayTest {
    public static void main(String[] args) {
        // 定義一個字符串
        String s = "dacgebf";

        // 把字符串轉換為字符數組
        char[] chs = s.toCharArray();

        // 把字符數組進行排序
        bubbleSort(chs);

        //把排序后的字符數組轉成字符串
        String result = String.valueOf(chs);
        
        //輸出最后的字符串
        System.out.println("result:"+result);
    }

    // 冒泡排序
    public static void bubbleSort(char[] chs) {
        for (int x = 0; x < chs.length - 1; x++) {
            for (int y = 0; y < chs.length - 1 - x; y++) {
                if (chs[y] > chs[y + 1]) {
                    char temp = chs[y];
                    chs[y] = chs[y + 1];
                    chs[y + 1] = temp;
                }
            }
        }
    }
}

查找

基本查找: 數組元素無序

public static int getIndex(int[] arr,int value) {
    int index = -1;
    for(int x=0; x<arr.length; x++) {
        if(arr[x] == value) {
            index = x;
            break;
        }
    }
    return index;
}

二分查找(折半查找) : 數組元素有序

public class ArrayDemo {
    public static void main(String[] args) {
        //定義一個數組
        int[] arr = {11,22,33,44,55,66,77};
        
        //寫功能實現
        int index = getIndex(arr, 33);
        System.out.println("index:"+index);
        
        //假如這個元素不存在后有什么現象呢?
        index = getIndex(arr, 333);
        System.out.println("index:"+index);
    }
    
    /*
     * 兩個明確：
     * 返回值類型：int
     * 參數列表：int[] arr,int value
     */
    public static int getIndex(int[] arr,int value){
        //定義最大索引，最小索引
        int max = arr.length -1;
        int min = 0;
        
        //計算出中間索引
        int mid = (max +min)/2;
        
        //拿中間索引的值和要查找的值進行比較
        while(arr[mid] != value){
            if(arr[mid]>value){
                max = mid - 1;
            }else if(arr[mid]<value){
                min = mid + 1;
            }
            //加入判斷
            if(min > max){
                return -1;
            }
            mid = (max +min)/2;
        }
        return mid;
    }
}

數組高級練習題

• 把字符串中的字符進行排序。
• 舉例：”dacgebf”
• 結果：”abcdefg”

Arrays類

Arrays類概述

• 針對數組進行操作的工具類。提供了排序，查找等功能。

Arrays類常用方法

• public static String toString(int[] a):把數組轉為字符串
• public static void sort(int[] a)：對數組進行排序
• public static int binarySearch(int[] a,int key)：二分查找

常用方法源碼詳細解釋

• public static String toString(int[] a)
• public static int binarySearch(int[] a,int key)

基本類型包裝類

基本類型包裝類概述

• 將基本數據類型封裝成對象的好處在于可以在對象中定義更多的功能方法操作該數據。
• 常用的操作之一：用于基本數據類型與字符串之間的轉換。
• 基本類型和包裝類的對應
  • byte <---> Byte
  • short <---> Short
  • int <---> Integer
  • long <---> Long
  • float <---> Float
  • double <---> Double
  • char <---> Character
  • boolean <---> Boolean

Integer類

Integer類概述

• Integer類概述
  • Integer 類在對象中包裝了一個基本類型 int 的值
  • 該類提供了多個方法，能在 int 類型和 String 類型之間互相轉換，還提供了處理 int 類型時非常有用的其他一些常量和方法。

Integer類構造方法

• public Integer(int value)
• public Integer(String s)
  • 注：這個字符串必須是由數字字符串組成。

Integer類成員方法

• int類型和String類型的相互轉換：String.valueOf

  • int –-> String

      int number = 100;
      // 方式1
      String s1 = "" + number;
      System.out.println("s1:" + s1);
  
      // 方式2(最優)
      String s2 = String.valueOf(number);
      System.out.println("s2:" + s2);
  
      // 方式3
      // int -- Integer -- String
      Integer i = new Integer(number);
      String s3 = i.toString();
      System.out.println("s3:" + s3);
  
      // 方式4
      // public static String toString(int i)
      String s4 = Integer.toString(number);
      System.out.println("s4:" + s4);
      System.out.println("-----------------");
  

  • String –-> int: Integer.parseInt

      // String -- int
      String s = "100";
      // 方式1
      // String --> Integer --> int
      Integer ii = new Integer(s);
      // public int intValue()
      int x = ii.intValue();
      System.out.println("x:" + x);
      //方式2(非常重要)
      //public static int parseInt(String s)
      int y = Integer.parseInt(s);
      System.out.println("y:"+y);
  

• public int intValue()
• public static int parseInt(String s)
• public static String toString(int i)
• public static Integer valueOf(int i)
• public static Integer valueOf(String s)
• 常用的基本進制轉換
  • public static String toBinaryString(int i)
  • public static String toOctalString(int i)
  • public static String toHexString(int i)
• 十進制到其他進制
  • public static String toString(int i,int radix)
• 其他進制到十進制
  • public static int parseInt(String s,int radix)

JDK5的新特性

• 自動裝箱：把基本類型轉換為包裝類類型；

• 自動拆箱：把包裝類類型轉換為基本類型

• JDK1.5以后，簡化了定義方式。

  • Integer x = new Integer(4);可以直接寫成
  • Integer x = 4;//自動裝箱。
  • x = x + 5;//自動拆箱。通過intValue方法。

• 需要注意：

  • 在使用時，Integer x = null;上面的代碼就會出現NullPointerException。

public class IntegerDemo {
    public static void main(String[] args) {
        // 定義了一個int類型的包裝類類型變量i
        // Integer i = new Integer(100);
        Integer ii = 100;
        ii += 200;
        System.out.println("ii:" + ii);

        // 通過反編譯后的代碼
        // Integer ii = Integer.valueOf(100); //自動裝箱
        // ii = Integer.valueOf(ii.intValue() + 200); //自動拆箱，再自動裝箱
        // System.out.println((new StringBuilder("ii:")).append(ii).toString());

        Integer iii = null;
        // NullPointerException
        if (iii != null) {
            iii += 1000;
            System.out.println(iii);
        }
    }
}

Integer的面試題

• Integer i = 1; i += 1;做了哪些事情
• 緩沖池(看程序寫結果)
  • 注意：Integer的數據直接賦值，如果在-128到127之間，會直接從緩沖池里獲取數據

public class IntegerDemo {
    public static void main(String[] args) {
        Integer i1 = new Integer(127);
        Integer i2 = new Integer(127);
        System.out.println(i1 == i2);
        System.out.println(i1.equals(i2));
        System.out.println("-----------");

        Integer i3 = new Integer(128);
        Integer i4 = new Integer(128);
        System.out.println(i3 == i4);
        System.out.println(i3.equals(i4));
        System.out.println("-----------");

        Integer i5 = 128;
        Integer i6 = 128;
        System.out.println(i5 == i6);
        System.out.println(i5.equals(i6));
        System.out.println("-----------");

        Integer i7 = 127;
        Integer i8 = 127;
        System.out.println(i7 == i8);
        System.out.println(i7.equals(i8));

        // 通過查看源碼，我們就知道了，針對-128到127之間的數據，做了一個數據緩沖池，如果數據是該范圍內的，每次并不創建新的空間
        // Integer ii = Integer.valueOf(127);
    }
}

Character類

Character類概述

• Character類概述
  • Character 類在對象中包裝一個基本類型 char 的值,此外，該類提供了幾種方法，以確定字符的類別（小寫字母，數字，等等），并將字符從大寫轉換成小寫，反之亦然

Character類構造方法

• 構造方法
  • public Character(char value)

Character類成員方法

• public static boolean isUpperCase(char ch)
• public static boolean isLowerCase(char ch)
• public static boolean isDigit(char ch)
• public static char toUpperCase(char ch)
• public static char toLowerCase(char ch)

練習題：

• 統計一個字符串中大寫字母字符，小寫字母字符，數字字符出現的次數。(不考慮其他字符)

    public static void main(String[] args) {
        // 定義三個統計變量。
        int bigCount = 0;
        int smallCount = 0;
        int numberCount = 0;

        // 鍵盤錄入一個字符串。
        Scanner sc = new Scanner(System.in);
        System.out.println("請輸入一個字符串：");
        String line = sc.nextLine();

        // 把字符串轉換為字符數組。
        char[] chs = line.toCharArray();

        // 歷字符數組獲取到每一個字符
        for (int x = 0; x < chs.length; x++) {
            char ch = chs[x];

            // 判斷該字符
            if (Character.isUpperCase(ch)) {
                bigCount++;
            } else if (Character.isLowerCase(ch)) {
                smallCount++;
            } else if (Character.isDigit(ch)) {
                numberCount++;
            }
        }

        // 輸出結果即可
        System.out.println("大寫字母：" + bigCount + "個");
        System.out.println("小寫字母：" + smallCount + "個");
        System.out.println("數字字符：" + numberCount + "個");
    }
}