【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"));
    }

}