Java的字符串（下）

案例.敏感词替换

public class StringTest7 {
    public static void main(String[] args) {
        String[] talk = {"TMD","CNM","SB"};
        String arr = "TMD,CNM,SB去食";
        for (int i = 0; i < talk.length; i++) {

          arr = arr.replace(talk[i],"*******" );
        }
        System.out.println(arr);
    }
}

运行结果：,,*******去食

Stringbulider

Stringbuilder概述
Stringbuilder 可以看作一个容器，创建之后里面的内容是可变的
作用：提高字符串的操作效率
Stringbuilder构造方法

StringBuilder sb = new StringBuilder("abc");

StringBuilder的对象------abc
Stringbuilder的常用方法

public StringBuilder appened（任意类型添加数据）：添加数据
public StringBuilder reverse（）：反转数据内容
public int length（）：返回长度
public String toString（）通过toString（）就可以实现把StringBuilder转换为String
sout（sb）打印的属性值不是地址值

StringBuilder的基本应用

1.创建对象
2.添加字符串
3.再把Stringbuilder变回字符串
//链式编程
//当我们在调用一个方法的时候，不需要用变量接受的时候，可以继续调用其他方法
链式编程的演示代码

int len = getString().substring(1).replace(A,Q).length();
System.outprintln(len);

链式编程案例：

public class StringTest8 {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append("lss").append(" ").append("love").append(" ").append("tjk");
        System.out.println(sb);
    }
}

运行结果：
lss love tjk

练习.对称字符串

使用StringBuilder的使用场景
//1.字符串的拼接
//2.字符串的反转

import java.util.Scanner;

public class StringTest8 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String str = sc.next();
        StringBuilder sb = new StringBuilder();
        String str1 = sb.append(str).reverse().toString();
        if (str.equals(str1)) {
            System.out.println("该字符串是对称字符串");
        } else {
            System.out.println("该字符串不是对称字符串");
        }
    }
}

运行结果1：
请输入一个字符串：
123
该字符串不是对称字符串
运行结果2：
请输入一个字符串：
123321
该字符串是对称字符串

练习.拼接字符串

//1.定义数组
//2.调用方法把数组转换为字符串

import javax.swing.*;

public class StringTest9 {
    public static void main(String[] args) {
         int[] arr = {1,2,3};
        String newarr = fun(arr);
        System.out.println(newarr);
    }
    public static String fun(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]).append(", ");
            }
        }
        sb.append("]");
        return  sb.toString();
    }
}

运行结果：
[1, 2, 3]

StringJoiner

为什么学习StringJoiner：速度快又方便
String概述：
Stringjoiner跟StringBuilder一样，也可以看成一个容器，创建之后里面的内容是可变的
作用：提高字符串的操作效率，而且代码写的特别简洁，但是目前市场上很少有人用
原因：JDK才出现
StringJoiner的构造方法

StringJoiner构造演示：

StringJoiner sj = new StringJoiner("---")
//1---2---3

StringJoiner sj = new StringJoiner(",","[","]");
//[1,2,3]

StringJoiner的成员方法

编写流程：
//1.创建对象
//2.添加元素
//3.打印
可以在最后根据结果修改创建对象中的参数

总结

1.String：表示字符串的类，定义很多操作字符串的方法
2.StringBuilder：一个可变的操作字符的容器，可以高效拼接字符串，还可以将容器里面的内容反转
3.StringJoiner
JDK8出现的一个可变的操作字符串的容器，可以高效，方便的拼接字符串。在拼接的时候，可以指定间隔符号，开始符号，结束符号。

字符串原理（1，2，3，4，5）

扩展底层原理（1，2）

应用比较时主要用的是：equals方法
扩展底层原理（3）
含有两种不同情况拼接方法：
1.右边无变量值：


2.右边有变量值：
查看底层代码可知：里面有new关键字，所以此方法效果慢，效率低
此方法十分浪费时间由于每一次使用都需要预估行数与距离
注意：

System.out.println(s1 == s2);
//判断的是地址值

字符串在拼接的时候，如有变量：
无论是哪种版本JDK8之前还是JDK8之后，都会产生一个新的字符串对象
判断地址值是否相同时，看右边有无变量，看串池内是否有相同的内容，如果有可以进行复制，那么两者的地址值相同

扩展底层原理5：StringBuilder源代码分析:
方法capacity表示获取容量
查看源代码可得，此方法具有自动扩容的性质

扩展底层原理（5）：
StringBuilder源码分析
默认创建一个长度一个为16的字节数组
添加的内容长度小于16，直接存
添加的内容长度大于16，直接存
添加的内容大于16会扩容（原来的容量*2+2）
如果扩容之后还不够，以实际长度为准

字符串原理总结

综合练习

import java.util.Scanner;

public class StringTest10 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String str = sc.next();
        boolean flag = fun1(str);
        if (flag) {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < str.length(); i++) {
                char c = str.charAt(i);
                int num = c - '0';
                String str1 = fun2(num);
                sb.append(str1);
            }
            String k = sb.toString();
            System.out.println("转换后字符串为：" + k);
        } else {
            System.out.println("该字符串不符合要求；");
        }

    }


    public static boolean fun1(String str) {
        if (str.length() > 9) {
            return false;
        } else {
            {
                for (int i = 0; i < str.length(); i++) {
                    char ch = str.charAt(i);
                    if (ch < '0' || ch > '9') {
                        return false;
                    }
                }

            }
        }
        return true;
    }

    public static String fun2(int num) {
        String[] change = {"Ⅰ", "Ⅱ", "Ⅲ", "Ⅳ", "Ⅴ", "Ⅵ", "Ⅶ", "Ⅷ", "Ⅸ" };
        return change[num - 1];

    }
}

运行结果：请输入一个字符串：
123456789
转换后字符串为：ⅠⅡⅢⅣⅤⅥⅦⅧⅨ

案例.调整字符串

方法1：

public class StringTest11 {
    public static void main(String[] args) {
        String strA = "abcde";
        String strB = "bcdea";
        boolean result = check(strA, strB);
        System.out.println(result);
    }
    public static boolean check(String strA, String strB){
        for (int i = 0; i < strA.length(); i++) {
            strA = rotateString(strA);
            if (strA.equals(strB)){
                return true;
            }
        }
        return false;
    }
    public static String rotateString(String str){
        char first = str.charAt(0);
        String end = str.substring(1);
        return end + first;
    }
}

运行结果：true
方法2：

public class StringTest11 {
    public static void main(String[] args) {
        String strA = "abcde";
        String strB = "b";
        boolean result = check(strA, strB);
        System.out.println(result);
    }
    public static boolean check(String strA, String strB){
        for (int i = 0; i < strA.length(); i++) {
            strA = rotateString(strA);
            if (strA.equals(strB)){
                return true;
            }
        }
        return false;
    }
    public static String rotateString(String str){
        char[] array = str.toCharArray();
        char first = array[0];
        for (int i = 1; i < str.length(); i++) {
            array[i-1] = array[i];
        }
        array[array.length-1] = first;
        String  result = new String(array);
        return result;
    }
}