java String(字符串),StringBuilder(字符串缓冲区),StringJoiner(字符串拼接 JDK1.8之后)

String字符串

1.String

1.1 String概述

String类就是用来表示字符串的

特点:

1. 字符串字面值(“abc” ,“今天天气真好” , “123”) 都是String类的对象
2. 一旦被创建就不可以更改

1.2 String类的构造方法

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

public class StringDemo2 {
    public static void main(String[] args) {
        //1，public String();   空参
        String s1 = new String();//此时就相当于是一个""
        System.out.println("--------------");
        System.out.println(s1);
        System.out.println("------------");

        //2，public String(char [] chs) ： 根据字符数组的内容创建字符串对象
        char [] chars = {'a','b','c'};
        String s2 = new String(chars);
        System.out.println(s2);//abc

        //3.public String(String original) ： 根据传入字符串的内容创建字符串对象
        String s3 = new String("abc");
        System.out.println(s3);//abc

        //4.String s = "abc"; 直接赋值的方式创建字符串对象
        String s4 = "bcd";
        System.out.println(s4);//bcd
    }
}

重点

1. 把一个字符数组转换成字符串的构造方法
2. 使用字符串字面值直接赋值的方式去创建字符串对象

1.3 字符串的内存原理

1. 字符串字面值直接赋值

String s1 = "abc" ;
String s2 = "abc" ;

首先会使用"abc"上字符常量池(jdk1.7以前是存在于方法区中,jdk1.8之后存放在堆内存中)中去查找,如果不存在就会创建"abc",然后把这个对象的地址值赋值给引用变量.如果存在,则直接将地址值赋值给引用变量.

2. 把一个字符数组转换成字符串的构造方法

char[] chs = {'a' , 'b' , 'c'} ;
String s1 = new String(chs) ;
String s2 = new String(chs) ;

只要是new出来的东西,肯定存放在对内存中

3. 使用携带字符串对象的构造方法创建对象

String s = new String("abc");

上述创建了两个对象,一个是堆内存new出来的,一个是字符串常量池中的

String s1 = new String("abc") ;
String s2 = "abc" ;

上述创建了两个对象,一个是堆内存中new出来的,另一个是字符常量池中的  Ps:字面值赋值,只要字符串常量池中存在,就不会新建,而new出来的,只要有new就必须在堆内存中新建一个对象

String s1 = new String("bcd") ;
String s2 = "abc" ;

上述创建了三个对象,一个是堆内存中new出来的,第二个是字符串常量池中的"bcd",第三个则是字符串常量池中的"abc"  Ps: new出来的会在堆内存中创建一个对象,并且在字符串常量池中寻找,没有则创建

1.4 成员方法

1.4.1 判断的相关方法

“==”

• 比较基本数据类型:比较的就是数据值
• 比较引用数据类型:比较的是地址值

String s1 = "abc" ;
String s2 = "abc" ;
System.out.println(s1 == s2);   // true

String s3 = new String("abc") ;
String s4 = "abc" ;
System.out.println(s3 == s4);   // false

如果想比较两个字符串的内容是否相同,就需要使用字符串中的方法

public boolean equals(Object anObject)    // 比较两个字符串的内容是否相等

1.4.2 字符串的遍历

遍历: 获取字符串中的每一个字符,然后将其输出在控制台

• 思路1: 获取每一个字符串,直接打印在控制台

public char charAt(int index)		// 获取指定索引处的字符, 字符串中的索引是从0开始，最大索引就是字符串的长度-1
public int length()					// 获取字符串的长度    

• 思路2 :把字符串转换成字符数组,然后遍历数组

public char[] toCharArray()			// 把一个字符串转换成字符数组

代码实现

public class StringDemo13 {

    public static void main(String[] args) {

        // 定义一个字符串
        String s = "asdfghj" ;

        // 按照思路一进行遍历操作
//        System.out.println(s.charAt(0));
//        System.out.println(s.charAt(1));
//        System.out.println(s.charAt(2));
//        System.out.println(s.charAt(3));
//        System.out.println(s.charAt(4));
//        System.out.println(s.charAt(5));
//        System.out.println(s.charAt(6));

        for(int i = 0 ; i < s.length() ; i++) {
            System.out.println(s.charAt(i));
        }

        System.out.println("-----------------------------------");

        // 按照思路二进行遍历操作
        // public char[] toCharArray()			# 把一个字符串转换成字符数组
        char[] chs = s.toCharArray() ;
        for(int i = 0 ; i < chs.length ; i++) {
            System.out.println(chs[i]);
        }

    }

}

1.4.3 String常用方法

方法名	说明
public boolean equals(Object anObject)	比较字符串的内容
public char charAt(int index)	返回指定索引处的 char 值
public int length()	返回此字符串的长度
public char[] toCharArray()	将字符串拆分为字符数组后返回
public String substring(int beginIndex, int endIndex)	根据开始和结束索引进行截取，得到新的字符串（包含头，不包含尾）
public String substring(int beginIndex)	从传入的索引处截取，截取到末尾，得到新的字符串
public String replace(CharSequence target, CharSequence replacement)	使用新值，将字符串中的旧值替换，得到新的字符串
public String[] split(String regex)	根据传入的规则切割字符串，得到字符串数组

2 StringBuilder

2.1概述

StringBuilder常常将其称之为字符串缓冲区,在这个StringBuilder所存储的字符串是可变的,可以吧StringBuilder理解成一个容器.

可以提高字符串拼接的效率

2.2 构造方法

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

示例

public class StringBuilderDemo2 {
    
    public static void main(String[] args) {
        
        //1.利用空参来创建对象
        StringBuilder sb1 = new StringBuilder();
        System.out.println(sb1);

        //2.利用有参来创建对象
        StringBuilder sb2 = new StringBuilder("itheima");
        System.out.println(sb2);
    }
}

2.3 成员方法

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

示例

public class StringBuilderDemo3 {
    public static void main(String[] args) {
      method1();
      method2();
      method3();
      method4();
      method5();
    }

    private static void method5() {
        //4.toString()  把StringBuilder容器变成字符串
        StringBuilder sb = new StringBuilder();
        sb.append("aaa").append("bbb");
        String s = sb.toString();
        System.out.println(s);
    }

    private static void method4() {
        //3.length 返回长度 --- 容器中字符的个数
        StringBuilder sb = new StringBuilder();
        sb.append("aaa").append("bbb");
        System.out.println(sb.length());
        sb.append("1");
        System.out.println(sb.length());
    }

    private static void method3() {
        //2.reverse 反转容器中的内容
        StringBuilder sb = new StringBuilder();
        sb.append("123").append("abc");
        System.out.println(sb);//123abc
        sb.reverse();
        System.out.println(sb);//cba321
    }

    private static void method2() {
        //1.append 添加 并返回对象本身
        StringBuilder sb1 = new StringBuilder();
        /*StringBuilder sb2 = sb1.append("aaa");
        System.out.println(sb1);
        System.out.println(sb2);

        //==号比较的是地址值.
        System.out.println(sb1 == sb2);//true*/

        //链式编程
        sb1.append("aaa").append("bbb").append("ccc").append("ddd");
        System.out.println(sb1);
    }

    private static void method1() {
        //1.append 添加
        StringBuilder sb = new StringBuilder();
        sb.append("aaa");
        sb.append(123);
        System.out.println(sb);
    }
}

3 StringJoiner

3.1 概述

StringJoiner是JDK1.8以后提供的一个类,使用这个类可以简化字符串的拼接操作(按照指定的规则进行字符串的拼接).效率也比较高.

3.2 构造方法

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

示例

public class StringJoinerDemo2 {
    public static void main(String[] args) {
        //1.定义一个数组
        int [] arr = {1,2,3};
        //2,创建一个StringJoiner容器的对象    [1, 2, 3]
                //间隔符号: 逗号空格
                //开始符号: [
                //结束符号: ]
        StringJoiner sj = new StringJoiner(", ","[","]");
        //遍历数组添加到StringJoiner当中
        for (int i = 0; i < arr.length; i++) {
            sj.add(arr[i] + "");
        }

        System.out.println(sj);
    }

    private static void method2() {
        //1.三个参数的构造  public StringJoiner (间隔符号，开始符号，结束符号)
        StringJoiner sj = new StringJoiner("---","[","]");
        //添加元素
        sj.add("aaa").add("bbb").add("ccc");
        //输出结果
        System.out.println(sj);//[aaa---bbb---ccc]
    }

    private static void method1() {
        //1.一个参数的构造  public StringJoiner (间隔符号)
        StringJoiner sj = new StringJoiner("@@@");
        //添加元素
        sj.add("aaa");
        sj.add("bbb");
        sj.add("ccc");
        //输出结果
        System.out.println(sj);//aaa@@@bbb@@@ccc
    }
}

3.3 常用方法

方法名	说明
public StringJoiner add (添加的内容)	添加数据，并返回对象本身
public int length()	返回长度 ( 字符出现的个数)
public String toString()	返回一个字符串（该字符串就是拼接之后的结果）

示例

public class StringJoinerDemo04 {

    public static void main(String[] args) {

        // 创建一个StringJoiner对象
        StringJoiner sj = new StringJoiner("," , "[" , "]") ;

        // 添加元素
        sj.add("itheima").add("itcast");

        // 获取StringJoiner中字符的个数
        System.out.println(sj.length());

        // 把StringJoiner转换成字符串
        // public String toString()
        String result = sj.toString() ;
        System.out.println(result);

        // 输出
        System.out.println(sj);


    }

}

3.4 字符串的拼接原理

第一种拼接方式: 用’+'进行拼接

• 常量进行拼接

String s1 = "abc" + "bcd" ;

在java中存储常量优化机制，也就是说在编译期是s1的值就是  abcbcd

• 变量进行拼接

String s1 = "abc" ;
String s2 = s1 + "bcd" ;
String s3 = s2 + "aaa" ;

底层其实是在堆内存中创建了一个StringBuilder对象进行实现的, 只要出现了一个+号至少会在堆内存中创建一个StringBuilder

第二种拼接方式: 用StringBuilder进行拼接

在内存中产生一个StringBuilder对象