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

文章目录

九.String 字符串类型
- 9.0 String概述
- 9.1 字符串常用方法
- 9.2 String内存图
- - 9.2.1直接赋值
  - 9.2.2new出来
- 9.3字符串比较
- 9.4 字符串遍历
- - 9.4.1 统计字符串大小写及数字
  - 9.4.2 拼接字符串
  - 9.4.3字符串反转
- 9.5 StringBuilder类
- - 9.5.1StringBuilder 构造方法
  - 9.5.2StringBuilder常用方法
  - 9.5.3 StringBuilder练习
  - - 9.5.3.1对称字符串
    - 9.5.3.2拼接字符串
- 9.6 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 int indexOf(int ch)	搜索第一个出现的字符ch（或字符串value），如果没有找到，返回-1
public int indexOf(String value)
public int lastIndexOf(int ch)	搜索最后一个出现的字符ch（或字符串value），如果没有找到，返回-1
public int lastIndexOf(String value)
public String substring(int index)	提取从位置索引开始的字符串部分
public String substring(int begin, int end)	提取beginindex和endindex之间的字符串部分
public String trim()	返回一个前后不含任何空格的调用字符串的副本，
Boolean equalsIgnoreCase()	忽略大小写比较
String toLowerCase()	将字符串转成小写
String toUpperCase()	将字符串装成大写
String concat(String)	拼接字符串，返回拼接后的字符串
String replace(被替换字符串 ,新字符串)	替换字符串，全部替换
String replaceAll(正则表达式,新字符串)	替换字符串，全部替换
String[] split(分隔符号)	分割字符串，返回字符串数组
char 字符串.charAt(索引)	根据字符串索引返回单个字符
Boolean endsWith(字符串)	判断尾部是否包含该字符串
Boolean startsWith(字符串)	判断头部是否包含该字符串

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

    }
}

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类

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

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

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

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

9.5.1StringBuilder 构造方法

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

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

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

9.5.2StringBuilder常用方法

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

如下案例：

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

        }

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 StringJoiner类

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

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

JDK8出现的

StringJoiner的构造方法

方法名	说明
public StringJoiner(间隔符号)	创建一个StringJoiner对象，指定拼接的间隔符号
public StringJoiner(间隔符号，开始符号，结束符号)	创建一个StringJoiner对象，指定拼接的间隔符号、开始符号、结束符号

StringJoiner的成员方法

方法名	说明
public StringJoiner add(添加内容)	添加数据，并返回对象本身
public int length（）	返回长度(字符出现的个数)
public String toString()	返回字符串

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]
    }
}