Java详解String 字符串类以及String内存原理、StringBuilder类、StringJoiner类（附有代码+案例）

九.String 字符串类型

String:引用数据类型

9.0 String概述

java.lang.String 类代表字符串，java程序中的所有字符串文字(如“abc”)都为此类对象。

• 注意点：字符串内容是不会发生改变的，它的对象在创建后不能被更改

String name1 = "小孔";
String name2 = "你好";
 System.out.print(name1 + name2);//产生一个新的字符串"小孔你好"

String name3 = "大聪明"；
  name3 = "小聪明"；
  上面为两个字符串

    //2.使用new的方式来获取一个字符串对象
    //空参构造：可以获取一个空白的字符串对象
    String s2 = new String();
    System.out.println("@" + s2 + "!");//""

    //传递一个字符串，根据传递的字符串内容再创建一个新的字符串对象
    String s3 = new String("abc");
    System.out.println(s3);

    //传递一个字符数组，根据字符数组的内容再创建一个新的字符串对象
    //需求：我要修改字符串的内容。  abc  Qbc
    //abc -->  {'a','b','c'}  -->  {'Q','b','c'} --> "Qbc"
    char[] chs = {'a', 'b', 'c', 'd'};
    String s4 = new String(chs);
    System.out.println(s4);//abcd

    //传递一个字节数组，根据字节数组的内容再创建一个新的字符串对象
    //应用场景：以后在网络当中传输的数据其实都是字节信息
   //我们一般要把字节信息进行转换，转成字符串，此时就要用到这个构造了。
    byte[] bytes = {97, 98, 99, 100};
    String s5 = new String(bytes);
    System.out.println(s5);//abcd

}

9.1 字符串常用方法

public char[] toCharArray()      将字符串中的字符转换为字符数组

public char charAt(int index)     索引范围从0 到 length-1.
返回指定索引处的字符。

public String[] split(String regex)
public String[] split(String regex, int limit)
用于根据指定的分隔符将字符串分割为子字符串数组
regex：正则表达式，用于匹配分隔符。
limit：分割的最大次数。如果为负数，则表示不限制分割次数。

public class Note02 {
    public static void main(String[] args) {

        String str2 = "Hello";
        String str1 = "hello";

        // 返回字符串长度
        System.out.println(str1.length());//5

        //字符串比较
        System.out.println(str1.equals(str2));//false

        // 忽略大小写比较
        boolean  b = str1.equalsIgnoreCase(str2);
        System.out.println(b);//true

        // 字符串转换成小写
        String s = str2.toLowerCase();
        System.out.println(s);//hello

        // 转换成大写
        System.out.println(str1.toUpperCase());//HELLO

        // 返回第一次出现 l 的索引，从左往右找
        int index = str1.indexOf("l");
        System.out.println(index);//2

        int index1 = str1.indexOf(1);
        System.out.println(index1);//-1

        // 返回最后出现 l 的索引，从右往左找
        int index2 = str1.lastIndexOf("l");
        System.out.println(index2);//3

        // 从3索引提取元素，默认到末尾
        String substring = str1.substring(3);
        System.out.println(substring);//lo

        // 从3索引提取元素，到末尾
     String substring1 = str1.substring(3, str1.length());
        System.out.println(substring1);//lo

        // 提取1到3索引的元素，包左不包右
        String substring2 = str1.substring(1, 3);
        System.out.println(substring2);//el

        // 返回前后不含空格的字符串，中间的不算
        String str3 = "  ni hao ";
        String trim = str3.trim();
        System.out.println(trim);//ni hao

        // concat拼接字符串
        String concat = str1.concat(str2);
        System.out.println(concat);//helloHello

        // 截取邮箱后缀
        String email = "666@qq.c.om";
        //先找到最后一个.出现的位置，再加一
        int index5 = email.lastIndexOf(".") + 1;
        String substring3 = email.substring(index5);
        System.out.println(substring3);//om
      
      // replace(被替换字符串 ,字符串)：替换字符串
        String str4 = "今天天气很好,天气万里无云";
        String str5 = str4.replace("天气", "**");
        System.out.println(str5);//今天**很好,**万里无云

        // replaceAll(正则表达式/字符串，字符串): 全部替换
        String str6 = "今天1天气2很好3";
        String newStr6 = str6.replaceAll("\\d", "\\$");
        System.out.println(newStr6);//今天$天气$很好$

        // split(分隔符号)
        String str7 = "张三,小明,李四";
        String[] splits = str7.split(",");
        System.out.println(Arrays.toString(splits));
        //[张三, 小明, 李四]
      
       // charAt(索引)：字符串根据索引转成 单个字符
        char c = str7.charAt(0);
        System.out.println(c);//张
      
       // toCharArray():将字符串中的字符转换为字符数组
        char[] chars = str7.toCharArray();
        System.out.println(Arrays.toString(chars));
        //[张, 三, ,, 小, 明, ,, 李, 四]
      
       // endsWith(字符串)：判断尾部是否包含该字符串
        String str8 = "11.png";
        boolean png = str8.endsWith("png");
        System.out.println(png);//true

        // startsWith(字符串)：判断头部是否包含该字符串
        boolean b1 = str8.startsWith("1");
        System.out.println(b1);//true

    }
}

public class Note03 {
    public static void main(String[] args) {
        // 课堂练习 ：判断邮箱格式是否正确
        String email = "66@qq.com";

        // 查找@出现的索引
        int index1 = email.indexOf("@");
        // 查找 . 出现的索引
        int index2 = email.indexOf(".");

        // 判断是否以 com/cn/net 结尾
        boolean com = email.endsWith("com");
        boolean cn = email.equals("cn");
        boolean net = email.endsWith("net");

        // 判断@ 和 . 之间是否存在一个字符以上
        int i = index2 - index1;

        //index1 和index2 大于等于 0 是为了保证存在
        // index1 < indes2 为了保证 @ 仔 . 之前
        //index1 >=1 为了保证 @ 前至少有两个字符
        //i>1 保证@ 和 . 之间存在一个字符以上
        if (index1 >= 0 && index2 >= 0 && index1 < index2 && index1 >=1 && i>1){
               if (com || cn || net){
                   System.out.println("格式正确");
               }

        }else {
            System.out.println("格式错误");
        }
        // main ending....
    }
}

9.2 String内存图

9.2.1直接赋值

• 字符串存在堆内存里的字符串常量池（即 串池）并且有内存地址，通过等号将内存地址值赋给等号左边，如下图所示，s1和s2通过 地址值匹配对应的字符串。

• 当执行到String s2 = "abc"时，会去串池里检查是否有"abc",如果有，会复用此时"abc"的地址值。此时s1和s2指向同一个地址值。

• 当使用双引号直接赋值时，系统会检查该字符串在串池中是否存在。如果不存在会创建新的地址空间，如果存在则复用。

• String= " "；表示在堆中开辟了一块空间，来存储空字符串

• String=null;表示没有在堆中开辟开辟空间

9.2.2new出来

• 每new 一次会会在堆中开辟一小块空间
• s1 和s2记录的是地址值

9.3字符串比较

== 比的是什么？

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

• 引用数据类型比较的是地址值

//基本数据类型比较的是具体的数据值,如：
int a = 10;
int b = 20;
System.out.print(a==b);// false

========================================================
  
 //引用数据类型比较的是地址值,如：
 String s1 = new String("abc");
 String s2 = new String("abc");
System.out.print(s1==s2);// false

 String s1 = "abc";
 String s2 = "abc";
//s1 和s2指向同一块内存地址空间。
System.out.print(s1==s2);// true

============================================================
String s1 = new String("abc");//记录堆里面的地址值
 String s2 = "abc";// 记录串池中的地址值
System.out.print(s1==s2);// false

• equals:比较内容完全一样

  比较对象的内容是否相同。

  equals()方法存在于Object类中，而Object类是所有类的父类。在Object类中定义了equals方法

• equalsIgnoreCase：忽略大小写

  public static void main(String[] args) {
        //1.创建两个字符串对象
        String s1 = new String("abc");
        String s2 = "Abc";
    
    //2.==号比较
    //基本数据类型：比的是数据值
    //引用数据类型：比的是地址值
    System.out.println(s1 == s2);//false
    
     //3.比较字符串对象中的内容是否相等
    boolean result1 = s1.equals(s2);
    System.out.println(result1);// false

    //4.比较字符串对象中的内容是否相等，忽略大小写
    //1 一 壹 这不行
    //忽略大小写只能是英文状态下的a A
    boolean result2 = s1.equalsIgnoreCase(s2);
    System.out.println(result2);//true
}

9.4 字符串遍历

字符串的长度：字符串对象.length( )；

 public static void main(String[] args) {
        // 键盘录入一个字符串，遍历该字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String str = sc.next();
        for (int i = 0; i < str.length(); i++) {
            // i 索引 
            // 字符串str调用charAt方法
            char c = str.charAt(i);
            System.out.println(c);// a  b  c
        }

9.4.1 统计字符串大小写及数字

• 键盘录入一个字符串，

  统计该字符串中的大写字母、小写字母、数字字符的出现次数

public static void main(String[] args) {
        // 键盘录入
        Scanner sc =new Scanner(System.in);
        System.out.print("请输入一个字符串：");
        String str = sc.next();

        // 统计变量
        int bigCount = 0;
        int smallCount = 0;
        int numCount= 0;

        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            //char类型的变量在参与计算的时候自动类型提升为int 查询ascii码表
            if(c >= 'a' && c<= 'z'){
                smallCount++;
            } else if (c >= 'A' && c<= 'z') {
                bigCount++;
            } else if (c >= '0' && c <= '9') {// 或者c >= 48 && c <= 57
                numCount++;
            }
        }
        System.out.println("大写字母有："+bigCount);
        System.out.println("小写字母有："+smallCount);
        System.out.println("数字有："+numCount);

    }

9.4.2 拼接字符串

• 定义一个方法，把int数组中的数据按照指定格式拼接成一个字符串返回，调用该方法，并在控制台输出结果

例如：数组为 int[] arr = {1,2,3}
执行方法后的输出结果为：[1,2,3]

package demo8;

public class Test08_04 {
    public static void main(String[] args) {
        int[] arr = {1,2,3};
        String s = arrToStr(arr);
        System.out.println(s);
    }
  //定义方法
    public static String arrToStr(int[] arr){
        if (arr == null){
            return "";
        }
        if (arr.length == 0){
            return "[]";
        }
        String res = "[";
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length-1){
                res = res + arr[i];
            }else {
                res = res + arr[i]+",";
            }
        }
        res  = res +"]";
        return res;
    }
}

9.4.3字符串反转

定义一个方法，实现字符串反转

键盘录入一个字符串，调用该方法后，在控制台输出结果

例如：录入abc 输出cba

 public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String strr = sc.next();
        String result = fanzhun(strr);
        System.out.println(result);

    }
    public static String fanzhun(String str){
        String res = "";
      //倒着输出
        for (int i = str.length()-1; i >= 0; i--) {
            char  c = str.charAt(i);
            res = res + c;
        }
        return res;
    }
}

9.5 StringBuilder类

9.5 StringBuilder类

StringBuilder StringBuffer用法一样

对字符串频繁修改(如字符串连接)时，使用StringBuffer类可以大大提高程序执行效率。

StringBuffer  ：速度慢，线程安全
StringBuilder ：速度快 ，线程不安全  

使用场景：字符串拼接、字符串反转

概述：StringBuilder 可以看成一个容器，创建之后里面的内容是可变的。

作用：提高字符串的操作效率。

StringBuilder类的对象可以看成一个容器,通过自有的方法调用给容器添加数据。

9.5.1StringBuilder 构造方法

//调用无参构造
   StringBuilder sb = new StringBuilder();

//调用有参构造
StringBuilder sb = new StringBuilder("abc");

9.5.2StringBuilder常用方法

如下案例：

public static void main(String[] args) {
            // 创建对象，调用有参
             StringBuilder sb = new StringBuilder("张三");
            System.out.println(sb);//张三
        }

 public static void main(String[] args) {
        // 创建对象
        StringBuilder sb = new StringBuilder();

        //2.添加元素
        sb.append(1);
        sb.append(2.3);
        sb.append(true);
        System.out.println(sb);//12.3true

        //反转
        //打印
        //因为StringBuilder是Java已经写好的类
      //java在底层对他做了一些特殊处理。打印对象不是地址值而是属性值。
        sb.reverse();
        System.out.println(sb);//eurt3.21

        //获取长度
        int len = sb.length();
        System.out.println(len);//8
    }

 public static void main(String[] args) {
            // 创建对象
             StringBuilder sb = new StringBuilder();

            //2.添加字符串
 sb.append("aaa").append("bbb").append("ccc").append("ddd");
            System.out.println(sb);//aaabbbcccddd

            //3.再把StringBuilder变回字符串
            String str = sb.toString();
            System.out.println(str);//aaabbbcccddd

        }

 public static void main(String[] args) {
/*
将一个数字字符串转换成逗号分隔的数字串，即从右边开始每三个数字用逗号分隔
如，输入12345678  输出 12，345，678
 */
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入：");
        String next = sc.next();

        StringBuffer sb = new StringBuffer();
        sb.append(next);

        for (int i = next.length()-3; i >0; i = i-3) {
            sb.insert(i,",");
        }
        System.out.println(sb);

    }
}

9.5.3 StringBuilder练习

9.5.3.1对称字符串

键盘接受一个字符串，判断是否是对称字符串。

 public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String str = sc.next();

        // StringBuilder sb= new StringBuilder();
        // sb.append(str);
        // sb.reverse();
        // sb.toString();
        String res = new StringBuilder().append(str).reverse().toString();

        if (str.equals(res)){
            System.out.println("是对称字符串");
        }else {
            System.out.println("不是对称字符串");
        }
    }

9.5.3.2拼接字符串

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

调用方法，并在控制台输出

如：int[] arr = {1,2,3} 执行方法后为 : [1,2,3]

 public static void main(String[] args) {
        int[] arr = {1,2,3};
        String res = toGetString(arr);
        System.out.println(res);
    }

    public static String toGetString(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]+",");
            }
        }
        sb.append("]");
        // String s = sb.toString();
        // return s;
        return sb.toString();

    }

9.6 StringBuffer类

用法和StringBuilder一样

9.7 StringJoiner类

StringJoiner跟StringBuilder一样，可以看成一个容器，创建以后里面的内容是可变的。

作用：提高字符串的操作效率，

JDK8出现的

StringJoiner的构造方法

StringJoiner的成员方法

import java.util.StringJoiner;
public class Note {
    public static void main(String[] args) {
        StringJoiner sj = new StringJoiner("---");
        //2.添加元素
        sj.add("aaa").add("bbb").add("ccc");
        //3.打印结果
        System.out.println(sj);//aaa---bbb---ccc
    }
}

import java.util.StringJoiner;
public class Note {
    public static void main(String[] args) {
        StringJoiner sj = new StringJoiner(", ","[","]");
        //2.添加元素
        sj.add("aaa").add("bbb").add("ccc");
				
        int len = sj.length();
        System.out.println(len);//15

        //3.打印
        System.out.println(sj);//[aaa, bbb, ccc]

        String str = sj.toString();
        System.out.println(str);//[aaa, bbb, ccc]
    }
}