String&StringBuilder的使用

itzhuzhu.

已于 2022-05-05 10:16:14 修改

阅读量433

点赞数

分类专栏： JavaSE 文章标签： StringBuilder java javase

于 2021-08-21 10:37:42 首次发布

本文链接：https://blog.csdn.net/weixin_45477086/article/details/119835332

版权

JavaSE 专栏收录该内容

60 篇文章 7 订阅

订阅专栏

`String`

String 类在 java.lang 包下，所以使用的时候不需要导包
String这个类比较特殊, 打印其对象名的时候, 不会出现内存地址，而是该对象所记录的真实内容.
面向对象-继承, Object类
特点：
Java 程序中所有的双引号字符串，都是 String 类的对象
字符串不可变，它们的值在创建后不能被更改，平常用的不是更改是替换
String的值不可变，但可被共享

常用String构造方法：

public String() : 创建一个空白字符串对象，不含有任何内容
public String(char[] chs) : 根据字符数组的内容，来创建字符串对象
public String(String original) : 根据传入的字符串内容，来创建字符串对象
String s = “abc”; 直接赋值的方式创建字符串对象，内容就是abc

常用方法：

public int length()：返回此字符串的长度

代码演示：

    public static void main(String[] args) {
        // public String() : 创建一个空白字符串对象，不含有任何内容
        String s1 = new String();
        System.out.println(s1);

        // public String(char[] chs) : 根据字符数组的内容，来创建字符串对象
        char[] chs = {'i','t','z','h','u','z','h','u'};
        String s2 = new String(chs);
        System.out.println(s2);

        // public String(String original) : 根据传入的字符串内容，来创建字符串对象
        String s3 = new String("1998");
        System.out.println(s3);
    }

面试题：

当字符串之间使用+号拼接的时候，系统底层会自动创建一个StringBuilder对象，然后调用其append方法完成拼接，拼接后再调用其toString方法转换为String类型，然后和常量池的s1对比就发现了不一样，所以答案是false

    public static void main(String[] args) {
        String s1 = "abc";
        String s2 = "ab";
        String s3 = s2 + "c";
        System.out.println(s1 == s3);
    }

Java存在常量优化机制，所以在编译的时候（javac）就会将"a" + “b” + “c"拼接为"abc”，所以答案是ture

        String s1 = "abc";
        String s2 = "a" + "b" + "c";
        System.out.println(s1 == s2);

创建字符串对象的区别对比：

通过构造方法创建
通过 new 创建的字符串对象，每一次 new 都会申请一个内存空间，虽然内容相同，但是地址值不同

直接赋值方式创建
以“”方式给出的字符串，只要字符序列相同(顺序和大小写)，无论在程序代码中出现几次，JVM 都只会建立一个 String对象，并在常量池中维护

equals：

public boolean equals(String s) 比较两个字符串内容是否相同、区分大小写

== 比较基本数据类型：比较的是具体的值

== 比较引用数据类型：比较的是对象地址值

equals：比较字符串内容, 区分大小写

equalsIgnoreCase : 比较字符串内容, 忽略大小写

代码演示：

public class DemoEquals {
    public static void main(String[] args) {
        String s1 = "abc";
        String s2 = "ABC";
        String s3 = "abc";

        // equals : 比较字符串内容, 区分大小写
        System.out.println(s1.equals(s2));
        System.out.println(s1.equals(s3));

        // equalsIgnoreCase : 比较字符串内容, 忽略大小写
        System.out.println(s1.equalsIgnoreCase(s2));
    }
}

`遍历字符串：`

public int length()：返回此字符串的长度
public char charAt(int index)：返回指定索引处的char值，字符串的索引也是从0开始的
public char[] toCharArray( )：将当前字符串拆分为字符数组并返回

public class Test {
    public static void main(String[] args) {
        //  1. 键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入:");
        String s = sc.nextLine();
        // 2. 遍历字符串，首先要能够获取到字符串中的每一个字符
        for(int i = 0; i < s.length(); i++){
            // i : 字符串的每一个索引
            char c = s.charAt(i);
            System.out.println(c);
        }
    }
}

    public static void main(String[] args) {
        //  1. 键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入:");
        String s = sc.nextLine();
        // 2. 将字符串拆分为字符数组
        char[] chars = s.toCharArray();
        // 3. 遍历字符数组
        for (int i = 0; i < chars.length; i++) {
            System.out.println(chars[i]);
        }
    }

`用户登录案例：`

public class Test1 {
    /*
        需求：已知用户名和密码，请用程序实现模拟用户登录。
              总共给三次机会，登录之后，给出相应的提示
     */
    public static void main(String[] args) {
        // 1. 已知用户名和密码，定义两个字符串表示即可
        String username = "admin";
        String password = "123456";
        // 2. 键盘录入要登录的用户名和密码，用 Scanner 实现
        Scanner sc = new Scanner(System.in);
        // 4. 用循环实现多次机会，这里的次数明确，采用for循环实现
        for(int i = 1; i <= 3; i++){
            System.out.println("请输入用户名:");
            String scUsername = sc.nextLine();
            System.out.println("请输入密码:");
            String scPassword = sc.nextLine();
            // 3. 拿键盘录入的用户名、密码和已知的用户名、密码进行比较，给出相应的提示。
            if(username.equals(scUsername) && password.equals(scPassword)){
                System.out.println("登录成功");
                break;
            }else if (i == 3) {
                System.out.println("您的登录次数已达到今日上限, 请明天再来");
            } else {
                System.out.println("登录失败,您还剩余" + (3 - i) + "次机会");
            }
        }
    }
}

`统计字符次数案例：`

    public static void main(String[] args) {
        // 1. 键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入:");
        String s = sc.nextLine();
        // 2. 要统计三种类型的字符个数，需定义三个统计变量，初始值都为0
        int bigCount = 0;
        int smallCount = 0;
        int numCount = 0;
        // 3. 遍历字符串，得到每一个字符
        char[] chars = s.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            char c = chars[i];
            // 4. 判断该字符属于哪种类型，然后对应类型的统计变量+1
            if(c >= 'A' && c <= 'Z'){
                bigCount++;
            }else if(c >= 'a' && c <= 'z'){
                smallCount++;
            }else if(c >= '0' && c <= '9'){
                numCount++;
            }
        }

        // 5. 输出三种类型的字符个数
        System.out.println("大写字母字符:" + bigCount);
        System.out.println("小写字母字符:" + smallCount);
        System.out.println("数字字母字符:" + numCount);
    }

`手机号屏蔽-字符串截取：`

public String substring(int beginIndex, int endIndex)：从beginIndex开始截取到endIndex结束，得到新字符串并返回（包含头，不包含尾，所以要加一个索引才能正常逻辑截取）

public String substring(int beginIndex)：从传入的索引处截取，截取到末尾，得到新的字符串

    public static void main(String[] args) {
        // 1. 键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入手机号:");
        String telString = sc.nextLine();
        // 2. 截取字符串前三位
        String start = telString.substring(0,3);
        // 3. 截取字符串后四位
        String end = telString.substring(7);
        // 4. 将截取后的两个字符串，中间加上****进行拼接，输出结果
        System.out.println(start + "****" + end);
    }

`敏感词替换-字符串替换：`

String replace(CharSequence target, CharSequence replacement)
将当前字符串中的target内容，使用replacement进行替换，返回新的字符串

    public static void main(String[] args) {
        // 1. 键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入:");
        String s = sc.nextLine();
        // 2. 替换敏感词
        String result = s.replace("TMD","***");
        // 3. 输出结果
        System.out.println(result);
    }

`切割字符串：`

String[] split(String regex) ：根据传入的字符串作为规则进行切割将切割后的内容存入字符串数组中，并将字符串数组返回

    public static void main(String[] args) {
     	// 例如：itzhuzhu,23 通过逗号切割出来有效数据
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入学生信息:");
        String stuInfo = sc.nextLine();

        // 1. 根据空格切割字符串
        String[] sArr = stuInfo.split(" ");

        // 2. 从得到的字符串数组中取出元素内容，通过Student类的有参构造方法封装为对象
        Student stu = new Student(sArr[0],sArr[1]);

        // 3. 调用对象getXxx方法，取出数据并打印。
        System.out.println(stu.getName() + "..." + stu.getAge());
    }

`判断前缀与后缀：`

startsWith：方法用于检测字符串是否以指定的前缀开始。
endsWith：方法用于判断字符串是否以指定后缀结尾

        List<String> list2 = new ArrayList<String>();
        list2.add("韩信2");
        list2.add("李白2");
        list2.add("猴子2");
        list2.add("猴子2");
        list2.add("露娜2");
        list2.add("露娜2");
        list2.add("宫本2");
        list2.stream().filter(s -> s.startsWith("韩")).forEach(System.out::println);
         list2.stream().filter(s -> s.endsWith("娜")).forEach(System.out::println);

`StringBuilder：`

StringBuilder 是一个可变的字符串类，可以把它看成是一个容器，这里的可变指的是 StringBuilder 对象中的内容是可变的

`StringBuilder类和String类的区别：`

String类：内容是不可变的，执行速度慢
StringBuilder类：内容是可变的，执行速度飞快

`StringBuilder类的常用构造方法：`

方法名	说明
public StringBuilder()	创建一个空白可变字符串对象，不含有任何内容
public StringBuilder(String str)	根据字符串的内容，来创建可变字符串对象

    public static void main(String[] args) {
        //public StringBuilder()：创建一个空白可变字符串对象，不含有任何内容
        StringBuilder sb = new StringBuilder();
        System.out.println("sb:" + sb);
        System.out.println("sb.length():" + sb.length());

        //public StringBuilder(String str)：根据字符串的内容，来创建可变字符串对象
        StringBuilder sb2 = new StringBuilder("hello");
        System.out.println("sb2:" + sb2);
        System.out.println("sb2.length():" + sb2.length());
    }

`StringBuilder类的常用成员方法：`

方法名	说明
public StringBuilder append(任意类型)	添加数据，并返回对象本身
public StringBuilder reverse()	返回相反的字符序列
public int Length	返回长度（字符出现的个数）
public String toString()	通过 toString() 就可以实现把 StringBuilder 转换为 String

    public static void main(String[] args) {

        StringBuilder sb = new StringBuilder();

        StringBuilder sb1 = sb.append("itzhuzhu");
        System.out.println(sb);
        StringBuilder sb2 = sb.append(1998);
        System.out.println(sb);
        StringBuilder sb3 = sb.append(199.8);
        System.out.println(sb);
        StringBuilder sb4 = sb.append(true);
        System.out.println(sb);

        // 这里可以看到结果是一样的，就可以证明是可变的，调用sb1~sb4其实就是调用sb本身
        System.out.println(sb1 == sb2);
        System.out.println(sb3 == sb4);

        // 链式编程：如果一个方法返回的是对象类型就可以一直向下调用方法，简化步骤
        System.out.println(sb1.append("1").append("2").append("3"));

        System.out.println("反转后" + sb.reverse());
        System.out.println("字符个数为：" + sb.length());

        String s = sb.toString();
        // 打印效果是一样的，但是数据类型是不同的
        System.out.println("转为String类型后：" + s);
    }

`StringBuilder原理：`

String添加字符串会先在常量池找有没有这个字符，没有的话就会在001开辟空间存这个字符串，如果有拼接的话会直接转成StringBuilder，然后再用toString转回String，所以使用String速度会比较慢一点
在这里插入图片描述
StringBuilder添加字符会直接开辟一个StringBuilder地址，然后会在一个StringBuilder中进行拼接字符，就算进行一万次的拼接也就一个内存地址，而用String会有多个，所以StringBuilder速度会比较快

`StringBuilder和String相互转换：`

StringBuilder转换为String

public String toString()：通过 toString() 就可以实现把 StringBuilder 转换为String

String转换为StringBuilder

public StringBuilder(String s)：通过构造方法就可以实现把 String 转换为 StringBuilder

    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        String s = arrayToString(arr);
        System.out.println("s:" + s);
    }

    //定义一个方法，用于把 int 数组中的数据按照指定格式拼接成一个字符串返回

    public static String arrayToString(int[] arr) {
        //在方法中用 StringBuilder 按照要求进行拼接，并把结果转成 String 返回
        StringBuilder sb = new StringBuilder("[");

        for (int i = 0; i < arr.length; i++) {
            // 是最后一个就拼接括号，不是最后一个就拼接逗号
            if (i == arr.length - 1) {
                sb.append(arr[i]).append("]");
            } else {
                sb.append(arr[i]).append(",");
            }
        }
        return sb.toString();
    }