【Java】【基礎篇】day13：String類

前言

本期任務：畢向東老師Java視頻教程學習筆記（共計25天）

• 原視頻鏈接：黑馬程序員_畢向東_Java基礎視頻教程
• day01：編寫HelloWorld程序
• day02：操作符與條件選擇語句
• day03：循環語句與函數
• day04：數組
• day07：繼承、抽象類與接口
• day08：多態
• day09：異常處理
• day11：多線程
• day12：線程安全與同步機制
• day13：String類
• day14：集合（ArrayList，LinkedList，HashSet）
• day15：集合（TreeSet）和泛型）
• day16：集合（HashMap、TreeMap）
• day17：集合框架的工具類（Arrays、Collections）
• day18：IO流（字符流讀寫）
• day19：IO流（字節流、轉換流讀寫）
• day20：IO流（File對象）

---

代碼

/*

String類適用於描述字符串事物。
那麼它就提供了多個方法對字符串進行操作。

常見的操作有哪些？
"abcd"

1，獲取。
	1.1 字符串中的包含的字符數，也就是字符串的長度。
		int length():獲取長度。
	1.2 根據位置獲取位置上某個字符。
		char charAt(int index):
	1.3 根據字符獲取該字符在字符串中位置。
		int indexOf(int ch):返回的是ch在字符串中第一次出現的位置。
		int indexOf(int ch, int fromIndex) :從fromIndex指定位置開始，獲取ch在字符串中出現的位置。

		int indexOf(String str):返回的是str在字符串中第一次出現的位置。
		int indexOf(String str, int fromIndex) :從fromIndex指定位置開始，獲取str在字符串中出現的位置。

		int lastIndexOf(int ch) ：


2，判斷。
	2.1 字符串中是否包含某一個子串。
		boolean contains(str):
		特殊之處：indexOf(str):可以索引str第一次出現位置，如果返回-1.表示該str不在字符串中存在。
				所以，也可以用於對指定判斷是否包含。
				if(str.indexOf("aa")!=-1)

				而且該方法即可以判斷，有可以獲取出現的位置。

	2.2 字符中是否有內容。
		boolean isEmpty(): 原理就是判斷長度是否爲0.
	2.3 字符串是否是以指定內容開頭。
		boolean startsWith(str);
	2.4 字符串是否是以指定內容結尾。
		boolean endsWith(str);
	2.5 判斷字符串內容是否相同。複寫了Object類中的equals方法。
		boolean equals(str);
	2.6 判斷內容是否相同，並忽略大小寫。
		boolean equalsIgnoreCase();

3，轉換。
	3.1 將字符數組轉成字符串。
		構造函數：String(char[])
				  String(char[],offset,count):將字符數組中的一部分轉成字符串。

		靜態方法：
				static String copyValueOf(char[]);
				static String copyValueOf(char[] data, int offset, int count)

				static String valueOf(char[]):


	3.2 將字符串轉成字符數組。**
		char[] toCharArray():

	3.3 將字節數組轉成字符串。
			String(byte[])
			String(byte[],offset,count):將字節數組中的一部分轉成字符串。

	3.4 將字符串轉成字節數組。
			byte[]  getBytes():
	3.5 將基本數據類型轉成字符串。
		static String valueOf(int)
		static String valueOf(double)

		//3+"";//String.valueOf(3);

		特殊：字符串和字節數組在轉換過程中，是可以指定編碼表的。

4，替換
	String replace(oldchar,newchar);

5，切割
	String[] split(regex);

6，子串。獲取字符串中的一部分。
	String substring(begin);
	String substring(begin,end);

7，轉換，去除空格，比較。
	7.1 將字符串轉成大寫或則小寫。
		 String toUpperCase();
		 String toLowerCase();

	7.2 將字符串兩端的多個空格去除。
		String trim();

	7.3 對兩個字符串進行自然順序的比較。
		int compareTo(string);


*/

/*
1，模擬一個trim方法，去除字符串兩端的空格。
	思路：
	1，判斷字符串第一個位置是否是空格，如果是繼續向下判斷，直到不是空格爲止。
		結尾處判斷空格也是如此。
	2，當開始和結尾都判斷到不是空格時，就是要獲取的字符串。



2，將一個字符串進行反轉。將字符串中指定部分進行反轉，"abcdefg";abfedcg
	思路：
	1，曾經學習過對數組的元素進行反轉。
	2，將字符串變成數組，對數組反轉。
	3，將反轉後的數組變成字符串。
	4，只要將或反轉的部分的開始和結束位置作爲參數傳遞即可。


*/


package day13;

public class StringTest {
    public static void main(String[] args) {
        String s = "      ab    cd     ";
        System.out.println("(" + s + ")");
        System.out.println("(" + myTrim(s) + ")"); // 輸出去除兩端空格之後的結果
        System.out.println("(" + myReverse(s) + ")"); // 輸出去除兩端空格之後的結果


    }

    public static String myTrim(String s) {
        /*
        1，判斷字符串第一個位置是否是空格，如果是繼續向下判斷，直到不是空格爲止。
		結尾處判斷空格也是如此。
	    2，當開始和結尾都判斷到不是空格時，就是要獲取的字符串。
	    */

        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);

    }

    public static String myReverse(String s) {
        /*
        	1，曾經學習過對數組的元素進行反轉。
            2，將字符串變成數組，對數組反轉。
            3，將反轉後的數組變成字符串。
            4，只要將或反轉的部分的開始和結束位置作爲參數傳遞即可。
        */

        return new String(reverseArray(s.toCharArray()));

    }

    public static char[] reverseArray(char[] array) {
        for (int start = 0, end = array.length - 1; start < end; start++, end--) {
            swap(array, start, end);
        }
        return array;
    }

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


}

/*
3，獲取一個字符串在另一個字符串中出現的次數。
	"abkkcdkkefkkskk"


	思路：
	1，定義個計數器。
	2，獲取kk第一次出現的位置。
	3，從第一次出現位置後剩餘的字符串中繼續獲取kk出現的位置。
		每獲取一次就計數一次。
	4，當獲取不到時，計數完成。



*/

package day13;

public class StringTest2 {
    public static void main(String[] args) {
        String str = "kkabkkcdkkefkks";
        System.out.println("count：" + getSubCount(str, "kk"));
        System.out.println("count：" + getSubCount(str, "kkk"));
    }

    public static int getSubCount(String str, String key) {
        int count = 0;
        int index;

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

        return count;

    }
}

/*
4，獲取兩個字符串中最大相同子串。第一個動作：將短的那個串進行長度一次遞減的子串打印。
	"abcwerthelloyuiodef"
	"cvhellobnm"
	思路：
		1，將短的那個子串按照長度遞減的方式獲取到。
		2，將每獲取到的子串去長串中判斷是否包含，
			如果包含，已經找到！。
*/

package day13;

public class StringTest3 {
    public static void main(String[] args) {
        String s1 = "ab";
        String s2 = "cvhellobnm";
//        String s1 = "abcwerthelloyuiodef";
//        String s2 = "cvhellobnm";
        System.out.println(getMaxSubString(s1, s2));
    }

    public static String getMaxSubString(String s1, String s2) {
        /*
        	1，將短的那個子串按照長度遞減的方式獲取到。
            2，將每獲取到的子串去長串中判斷是否包含，
                如果包含，已經找到！。

            總結：遍歷min的所有可能的子串
        */

        // 事先確定長短字符串
        String min, max;
        min = s1.length() > s2.length() ? s2 : s1;
        max = min == s2 ? s1 : s2;

        for (int x = min.length(); x > 0; x--) {
            for (int y = 0, z = x - y - 1; z <= min.length() - 1; y++, z++) {
                if (max.contains(min.substring(y, z)))
                    return min.substring(y, z);
            }
        }
        return "";

    }
}

/*
對字符串中字符進行自然順序排序。

思路：
1，字符串變成字符數組。
2，對數組排序，選擇，冒泡，Arrays.sort();
3，將排序後的數組變成字符串。



"vcz1bdAa+cs"-->abccdsvz




作業：
"12 0 99 -7 30 4 100 13"
要求對字符串中的數值進行排序。生成一個數值從小到大新字符串。

"-7 0 4 12 13 30 99 100"


*/

package day13;

class Arrays {


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

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


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

    }

    //        冒泡排序;
    public static void bubbleSort(String[] arr) {
        for (int x = 0; x < arr.length - 1; x++) {
            for (int y = 0, z = 1; z <= arr.length - 1 - x; y++, z++) {
                if (Integer.parseInt(arr[y]) > Integer.parseInt(arr[z])) {
                    swap(arr, y, z);
                }
            }
        }

    }


    public static String sort(char[] arr) {
//        2，對數組排序，選擇，冒泡，Arrays.sort();
//        3，將排序後的數組變成字符串。
        bubbleSort(arr);
        return new String(arr);
    }

    public static String sort(String[] arr) {
//        2，對數組排序，選擇，冒泡，Arrays.sort();
//        3，將排序後的數組變成字符串。
        bubbleSort(arr);
        return String.join(" ", arr);
    }

}


public class StringTest4 {

    public static void main(String[] args) {
        String str = "vcz1bdAa+cs";
        System.out.println(str);
        System.out.println(Arrays.sort(str.toCharArray()));

        String str1 = "12 0 99 -7 30 4 100 13";
        System.out.println(str1);
        System.out.println(Arrays.sort(str1.split(" ")));

    }
}

/*
StringBuffer是字符串緩衝區。

是一個容器。
特點：
1，長度是可變化的。
2，可以字節操作多個數據類型。
3，最終會通過toString方法變成字符串。



C create U update R read D delete

1，存儲。
	StringBuffer append():將指定數據作爲參數添加到已有數據結尾處。
	StringBuffer insert(index,數據):可以將數據插入到指定index位置。


2，刪除。
	StringBuffer delete(start,end):刪除緩衝區中的數據，包含start，不包含end。
	StringBuffer deleteCharAt(index):刪除指定位置的字符。

3，獲取。
	char charAt(int index)
	int indexOf(String str)
	int lastIndexOf(String str)
	int length()
	String substring(int start, int end)

4，修改。
	StringBuffer replace(start,end,string);
	void setCharAt(int index, char ch) ;


5，反轉。
	StringBuffer reverse();

6，
	將緩衝區中指定數據存儲到指定字符數組中。
	void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)


JDK1.5 版本之後出現了StringBuilder.

StringBuffer是線程同步。
StringBuilder是線程不同步。

以後開發，建議使用StringBuilder

升級三個因素：
1，提高效率。
2，簡化書寫。
3，提高安全性。

*/


package day13;

public class StringBufferDemo {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("abcdef");

        char[] chs = new char[6];

        //字符從該序列複製到目標字符數組 dst 。
        sb.getChars(1, 4, chs, 1);

        for (int x = 0; x < chs.length; x++) {
            System.out.println("chs[" + x + "]=" + chs[x] + ";");
        }

//        draw(3, 6);
//        draw(8, 9);

        sb.insert(1, "qq");
        System.out.println(sb.toString());

        sb.setCharAt(2, 'k');
        System.out.println(sb.toString());

        sb.replace(1, '4', "java");
        System.out.println(sb.toString());

        sb.delete(1, 3);
        System.out.println(sb.toString());
        sb.deleteCharAt(1);
        System.out.println(sb.toString());
        sb.delete(0, sb.length());
        System.out.println(sb.toString());


    }

    public static void draw(int row, int col) {
        StringBuilder sb = new StringBuilder();
        for (int x = 0; x < row; x++) {
            for (int y = 0; y < col; y++) {
                sb.append("*");
            }
            sb.append("\r\n");
        }
        System.out.println(sb.toString());
    }


}

/*
基本數據類型對象包裝類。

byte	Byte
short	short
int		Integer
long	Long
boolean Boolean
float	Float
double	Double
char	Character



基本數據類型對象包裝類的最常見作用，
就是用於基本數據類型和字符串類型之間做轉換

基本數據類型轉成字符串。

	基本數據類型+""

	基本數據類型.toString(基本數據類型值);

	如： Integer.toString(34);//將34整數變成"34";


字符串轉成基本數據類型。

	xxx a = Xxx.parseXxx(String);

	int a = Integer.parseInt("123");

	double b = Double.parseDouble("12.23");

	boolean b = Boolean.parseBoolean("true");

	Integer i = new Integer("123");

	int num = i.intValue();




十進制轉成其他進制。
	toBinaryString();
	toHexString();
	toOctalString();


其他進制轉成十進制。
	parseInt(string,radix);


*/


package day13;

public class IntegerDemo {

    public static void main(String[] args) {
        // 整數類型的最大值
        System.out.println("int max：" + Integer.MAX_VALUE);

        //將一個字符串轉換成整數
        System.out.println(Integer.parseInt("123"));

        // 將一個整數轉換成一個二進制的數
        System.out.println(Integer.toBinaryString(-6));

        // 將一個整數轉換成十六進制的數
        System.out.println(Integer.toHexString(60));

        // 將一個十六進制的字符串轉換成整數
        System.out.println(Integer.parseInt("3c", 16));

        // 將字符串轉換成長整型
        System.out.println(Long.parseLong("123"));
    }

}