描述字符串的類——String類

一浙于、String類

String類的特點：
字符串對象一旦被初始化就不會被改變

字符串定義的第一種方式——字符串常量池
字符串常量池中沒有就建立护盈，池中有，直接用

字符串常量池

擴展

2.字符串中的操作方法
(1)構(gòu)造方法

• String(byte[] bytes)
  將一個字節(jié)數(shù)組變成字符串

將一個字節(jié)數(shù)組變成字符串

• String(char[] value)
  分配一個新的String羞酗，使其表示字符數(shù)組參數(shù)中當前包含的字符序列腐宋。

栗子

• String(char[] value,int offset,int count)
  取自字符數(shù)組參數(shù)一個子數(shù)組的字符
  也就是：從哪開始，取幾個

栗子

(2)字符串功能

• 獲取

a) 獲取字符串中字符的個數(shù)（長度）
int length();

b) 根據(jù)位置獲取字符
char charAt(int index);

c) 根據(jù)字符獲取在字符串中的第一次出現(xiàn)的位置
int indexOf(int ch)
int indexOf(int ch,int fromIndex) //從指定位置進行ch的查找第一次出現(xiàn)的位置
int indexOf(String str) //索引字符串
int indexOf(String str,int fromIndex)
從后索引
int lastIndexOf(int ch)
int lastIndexOf(int ch,int fromIndex)
int lastIndexOf(String str)
int lastIndexOf(String str,int fromIndex)

吃個栗子消化下

d) 獲取字符串中的一部分字符串（子串）
String substring(int beginIndex int endIndex)
該子字符串從指定的beginIndex處開始檀轨，直到索引endIndex-1處的字符胸竞。
String substring(int beginIndex)

給你個栗子

• 轉(zhuǎn)換

a) 將字符串變成字符串數(shù)組（字符串切割）
String[] split(String regex)
涉及到正則表達式

字符串切割

b) 將字符串變成數(shù)組
char[] toCharArray();

將字符串變成數(shù)組

b) 將字符串轉(zhuǎn)換成字節(jié)數(shù)組
byte[] getBytes();

將字符串轉(zhuǎn)換成字節(jié)數(shù)組

c) 將字符串中的字母轉(zhuǎn)成大小寫
String toUpperCase(); //大寫
String toLowerCase(); //小寫

將字符串中的字母轉(zhuǎn)成大小寫

d) 將字符串中的內(nèi)容進行替換
String replace(char oldChar,char newChar);

將字符串中的內(nèi)容進行替換

e) 將字符串兩端的空白去除
String trim();

去除字符串兩端字符

f) 將字符串進行連接
String concat(String str);

將字符串進行連接

• 判斷

a) 兩個字符串內(nèi)容是否相同
Boolean equals(Object obj);
忽略大小寫比較字符串內(nèi)容
Boolean equalsIgnoreCase(String str)；

兩個字符串比較

b)字符串中是否包含指定字符串
Boolean contains(String str);

字符串中是否包含指定字符串

c) 字符串是否以指定字符串開頭参萄，是否以指定字符串結(jié)尾
Boolean startsWith(string);
Boolean endsWith(string);

字符串是否以指定字符串開頭卫枝，是否以指定字符串結(jié)尾

• 比較

按字典順序比較兩個字符串
int compareTo(String str);
int compareToIgnoreCase(String str);//不分大小寫
相等，返回0拧揽；小于剃盾，返回小于0的值腺占；大于淤袜，返回大于0的值。

按字典順序比較兩個字符串

• indexOf()方法
  用于返回字符（串）在當前字符串中首次出現(xiàn)的索引位置衰伯。不存在返回-1
  lastIndexOf()方法
  用于從當前字符串的末尾開始向前查找首次出現(xiàn)的規(guī)定的字符（串）

吃幾個大栗子

1.字符串數(shù)組排列

/*1.給定一個字符串數(shù)組铡羡，按照字典順序進行從小到大的排列
{"nba","abc","vba","zz","qq","haha"}
*/
/*
 * 思路：
 * 1.對數(shù)組排序∫饩ǎ可以用選擇/冒泡烦周。
 * 2.for嵌套和比較及換位。
 * 3.字符串對象比較怎顾。
 * */
public class StringPractise {
    public static void main(String[] args) {
        String[] arr = { "nba", "abc", "vba", "zz", "qq", "haha" };
        printArray(arr);
        sortString(arr);
        printArray(arr);
    }

    private static void sortString(String[] arr) {
        for (int i = 0; i < arr.length; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[i].compareTo(arr[j]) > 0)// 字符串比較用compareTo
                    swap(arr, i, j);
            }
        }
    }

    private static void swap(String[] arr, int i, int j) {
        String temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    private static void printArray(String[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i != arr.length - 1)
                System.out.print(arr[i] + ",");
            else
                System.out.println(arr[i] + "]");
        }
    }
}

第一個栗子的味道

2.子串的次數(shù)

/*一個子串在整串中出現(xiàn)的次數(shù)
 * "nbaernbatynbauinbaopnba"
 * 
 * 思路：
 * 1.要找的子串是否存在读慎，如果存在獲取其出現(xiàn)的位置。用indexOf
 * 2.找到了槐雾，記錄出現(xiàn)的位置并在剩余的字符串中繼續(xù)查找該子串夭委，
 * 而剩余字符串的起始位置是出現(xiàn)位置+子串的長度。
 * 3.以此類推募强，通過循環(huán)完成查找株灸，如果找不到就是-1崇摄，
 * 并對i每次找到用計數(shù)器記錄
 * */
public class StringPractise2 {
    public static void main(String[] args) {
        String str = "nbaernbatynbauinbaopnba";
        String key = "nba";

        int count = getKeyStringCount(str, key);
        System.out.println("count=" + count);
    }

    public static int getKeyStringCount(String str, String key) {
        // 1.定義計數(shù)器
        int count = 0;
        // 2.定義變量，記錄key出現(xiàn)的位置
        int index = 0;

        while ((index = str.indexOf(key)) != -1) {
            str = str.substring(index + key.length());
            count++;
        }
        return count;
    }
}

第二種方法

public class Stringdemo {
      public static void main(String[] main){
          String str = "nbaernbatynbauinbaopnba";
          String key = "nba";
          int count = 0;
          int index = 0;
          while(index != -1){
              index = str.indexOf(key,index+key.length());
              count++;
          }
          System.out.println(count);
      }
}

這個在數(shù)據(jù)結(jié)構(gòu)中叫匹配模式慌烧！

第二個栗子的味道逐抑！

3.最大相同的子串。

/*
 * 3.兩個字符串中最大相同的子串
 * "qwerabcdtyuiop"
 * "xabcdvbn"
 * 
 * 思想：
 * 1.取最大字符串屹蚊，先看短的字符串是否在長的字符串中
 * 如果存在厕氨，短的那個字符串就是最大字符串
 * 2.如果不是，就將短的子串進行長度遞減的方式去子串淑翼，再在長串中判斷是否存在
 * 如果存在就找到了腐巢！
 * */
public class StringPractise3 {
    public static void main(String[] args) {
        String s1 = "qwerabcdtyuiop";
        String s2 = "xabcdvbn";

        String s = getMaxSubstring(s1, s2);
        System.out.println("s=" + s);
    }

    public static String getMaxSubstring(String s1, String s2) {
        for (int i = 0; i < s2.length(); i++) {
            for (int a = 0, b = s2.length() - i; b != s2.length() + 1; a++, b++) {
                String sub = s2.substring(a, b);
                //System.out.println(sub);//打印得到字符串（見小栗子）
                if(s1.contains(sub))
                    return sub;
            }
        }
        return null;
    }
}

小栗子

第三個大栗子的味道

4.去除兩端空白

/*
 * 4.模擬一個trim功能一致的方法.去除字符串兩端的空白
 * 
 * 思路
 * 1.定義兩個變量
 * 一個作為從頭開始判斷字符串空格的角標。start++
 * 一個作為從尾開始判斷字符串空格的角標玄括。end--
 * 2.判斷到不是空格為止冯丙，去頭尾之間的字符串即可
 * */
public class StringPractise4 {

    public static void main(String[] args) {
        String s = "   ab  c   ";
        s = myTrim(s);
        System.out.println("-" + s + "-");
    }
    public static String myTrim(String s) {
        int start = 0;
        int end = s.length() - 1;
        while (start <= end && s.charAt(start) == ' ') {
            start++;
        }
        while (start <= end && s.charAt(end) == ' ') {
            end--;
        }
        return s.substring(start, end + 1);
    }
}

第四個栗子的味道

二、StringBuffer（字符串緩沖區(qū)）

StringBuffer:就是字符串緩沖區(qū)
用于存儲數(shù)據(jù)的容器

• 特點
  1.長度可變
  2.可以存儲不同類型的數(shù)據(jù)
  3.最終要轉(zhuǎn)成字符串進行使用
  4.可以對字符串進行修改

• StringBuffer是一個容器遭京，所具備的功能：
  增刪改查 C(create)U(update)R(read)D(delete)

1.添加：

StringBuffer append(data)

創(chuàng)建緩沖區(qū)

方法調(diào)用鏈

StringBuffer insert(index,data)

插入

2.刪除：

StringBuffer delete(start,end)
包含頭胃惜，不包含尾
StringBuffer deleteCharAt(int index)
刪除指定位置的元素

刪除指定位置元素

清空緩沖區(qū)

3.查找：

char charAt(index);
int indexOf(string);
int lastIndexOf(string);

4.修改：

替換
StringBuffer replace(start,end,string);
void setCharAt(index,char);

替換

無返回值的替換

• 其他方法

截取長度
StringBuffer setLength();

長度截取

內(nèi)容反轉(zhuǎn)
StringBuffer reverse()

反轉(zhuǎn)

三、StringBuilder

StringBuilder和StringBuffer的功能一樣哪雕，用法一樣
不同的是
StringBuffer：是線程同步的船殉。通常用于多線程
StringBuilder：是線程不同步的。通常用于單線程斯嚎，提高效率

最后再給你個栗子吃

/*
 * 將1個int數(shù)組變成字符串
 * 用String做
 * */
public class StringPractise {
    public static void main(String[] args) {
        int[] arr = { 3, 2, 1, 4, 8 };
        String s = arrayToString(arr);
        System.out.println(s);
    }

    public static String arrayToString(int[] arr) {
        String str = "[";
        for (int i = 0; i < arr.length; i++) {
            if (i != arr.length - 1)
                str += arr[i] + ",";
            else
                str += arr[i] + "]";
        }
        return str;

    }
}

上述方法會產(chǎn)生無數(shù)個常量

/*
 * 將1個int數(shù)組變成字符串
 * 用StringBuilder來做
 * */
public class StringBuilderPractise {
    public static void main(String[] args) {
        int[] arr = { 3, 2, 1, 4, 8 };
        String s = arrayToString_2(arr);
        System.out.println(s);
    }

    public static String arrayToString_2(int[] arr) {
        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] + "]");
        }
        return sb.toString();
    }
}

此方法只會產(chǎn)生一個數(shù)組
因此建議用容器

栗子的味道利虫！