Java基础09 —— 字符序列--String、StringBuilder、StringBuffer区别及其方法介绍

Java基础09 —— 字符序列

字符串类型

字符与字符串

字符类型(char)是Java中的基本数据类型，占2个字节16位，默认值是 ‘\u0000’ 。字符是用单引号引住的单个符号.

// 字符
char c = 'A'; //单引号
char cA = 65; //数字
char c1 = '\u8888'; //Unicode码
System.out.println(c); //A
System.out.println(cA); //A
System.out.println(c1);//袈

字符串(String)是用双引号引住的任意个字符，是引用数据类型，默认值是null 。字符串其实就是字符组成的序列

字符串声明

String 变量名 = "初始值";
String 变量名 = new String("初始值");

举例：

String str = "张三"; // 字面量 比较常用
String str1 = new String("张三"); // 字符串对象

字符序列

多个字符按照一定的顺序组成的列表就叫作字符序列，字符串 java.lang.String 可以用来表示多个字符,用 “” 引

起来。

JDK13 新增文本块(预览)，在 JDK15 正式在字符串支持文本块，用 “”" 表示

// Text Block 文本块声明
String season = """
				winter""";


//H i , LF(换行) SP(空格) " B o b " LF(换行)
String salutation = """
                    Hi,
                    "Bob"
                    """;
                        
// 输出为空
String empty = """
               """;

// 文本块 “”“ 字符内容 ”“”
   String text = """
                 序号    姓名
                 1      张三
                 "snadnlasmkl"
                 """;
   System.out.println(text);

String 字符串

StringBuffer 字符串缓冲区，是线程安全的

StringBuilder 字符串构造器，非线程安全的

CharBuffer 字符缓冲区

以上都实现了 CharSequence 接口

String类

字符串具有不可变特性；

public final static String是用final修饰的类，在java中用final修饰的类不能被继承，也就是说String没有子类。

在java中，关键字final表示最终的。可以用来修饰类、方法、变量。

被final修饰的类，不能被继承

被final修饰的方法，不能被重写

被final修饰的变量，不能变，如果是基本数据类型不能被重新赋值，如果是引用数据类型不能改变引用。

字符串不可变原因

字符串的底层是一个数组，jdk1.8之前是char类型的数组，jdk1.9及之后的版本是byte类型的数组。,不管是 jdk 8 及以前还是 jdk 9 及以后版本， value 属性都是 final 的。就说明，字符串一旦声明就不可变。所以字符串拥有不可变性。

改变原因：主要是为了节约 String 占用的内存，占用内存少引发另外一个好处就是减少 GC 次数。

**解释：**在java程序的堆里，String占用的空间最大，并且绝大多数String只有Latin-1字符，这些Latin-1字符只需要1字节就够了。在jdk9之前,jvm使用char类型的数组存储，char占用2个字节，即使字符串只需要1字节/字符，但依旧会按照2字节/字符进行存储，浪费了一半的内存空间。

jdk9的解决办法就是，一个字符串出来的时候判断，它是不是只有Latin-1字符，如果是，就按照1字节/每字符进行内存分配，如果不是就按照2字节/每字符规格进行分配（UTF-16编码）,提高了内存使用率。

为什么用 UTF-16 而不用 UTF-8 呢

这就要从这两个字符集的设计说起了。UTF-8 实际上是对空间利用效率最高的编码集，它是不定长的，可以最大限度利用内存和网络。但是这种编码集只能用于传输和存储，并不适合拿来做 String 的底层实现。因为 String 有随机访问的方法，所谓随机访问，就是 charAt 、 subString 这种方法。如果字符串中的每个字符占用的内存是不定长的，那么进行随机访问的时候，就需要从头开始数每个字符的长度，才能找到你想要的字符。

使用 UTF-16 编码将它们表示并存储为每个字符2个字节。

对于 JDK9 和更高版本，默认情况下，如果 String 的行为已更改为对字符串使用紧凑表示形式。

String常用方法

1.构造方法

方法名	描述
String()	初始化新创建的 String对象，使其表示空字符序列
String(byte[] bytes)	通过使用平台的默认字符集解码指定的字节数组来构造新的 String
String(byte[] bytes, Charset charset)	构造一个新的String用指定的字节的数组解码charset
String(byte[] bytes, String charsetName)	构造一个新的String用指定的字节的数组解码charsetName
String(char[] value)	构造一个新的String由指定的字符的数组构成
String(String original)	初始化新创建的String对象，使其表示与参数相同的字符序列; 换句话说，新创建的字符串是参数字符串的副本
String(StringBuffer buffer)	分配一个新的字符串，其中包含当前包含在字符串缓冲区参数中的字符序列
String(StringBuilder builder)	分配一个新的字符串，其中包含当前包含在字符串构建器参数中的字符序列

2.实例方法

方法名	返回值	描述
charAt(int index)	char	返回指定索引处的字符
codePointAt(int index)	int	返回指定索引处的字符（Unicode代码点）。
compareTo(String anotherString)	int	按字典顺序比较两个字符串
compareToIgnoreCase(String str)	int	按字典顺序比较两个字符串，忽略大小写
concat(String str)	String	将指定的字符串连接到该字符串的末尾
contains(CharSequence s)	boolean	当且仅当此字符串包含指定的s值序列时才返回true
endsWith(String suffix)	boolean	测试此字符串是否以指定的后缀结尾
startsWith(String prefix)	boolean	测试此字符串是否以指定的前缀开头
equals(Object)	boolean	比较字符串

常用方法进行分类： 查找字符的位置， 截取字符串， 拼接字符串等

字符串只能做+操作，表示拼接。任何类型的元素和字符串做+操作都表示字符串的拼接

contains()方法表示是否包含子元素，例如contains("wor")为true。

endsWith("内容")表示是否以某字符结尾，startsWith("内容")表示是否以某字符开头。

indexOf("字符")表示某个子串在字符串第一次出现的下标。-1表示未出现。

indexOf("字符"，3)表示某个字符从索引位开始第一次出现的位置

intern如果字符串在常量池中有，就返回常量池中的对象，如果没有就将对象放入常量池中，并将这个对象返回。

自动装箱操作是通过包装类.valueOf()进行的，自动拆箱操作是通过包装类对象.xxxValue()进行的。

//占位符 %s 字符串 %bboolean %cchar %dinteger %f 浮点数

字符串判断相等：字符串（String）是引用数据类型，所以使用 equals 方法进行比较

// 字符串拼接 +
String str = "hello";
Str = str+" world";  //  hello world

//  分隔字符串 spilt()  用`-`做分隔符，然后通过`split()`方法转换成逗号并输出。
str = "1-2-3-4-5-6";
String[] strs = str.split("-");
System.out.println(Arrays.toString(strs));

//  重复
str = "666";
str = str.repeat(3);
System.out.println(str);

// 替换
str = "abcdabcd";
str = str.replace("a","A");// 会替换所有的a变成A
str = str.replaceFirst("a", "A");//只会替换第一次出现的a变成A
System.out.println(str);

// 格式化
str = "我是%s".formatted("张三");
System.out.println(str);   // 我是张三

// 判断是否包含
boolean contains = str.contains("hello world");
System.out.println(contains);

// 是否以某个字符串结尾
String email = "xxxx@qq.com";
boolean end = email.endsWith(".com");
System.out.println(end);

// 是否以某个字符串开头
boolean start = email.startsWith("xxx");
System.out.println(start);

// 子串在字符串中第一次出现的位置(下标), -1 表示没出现
int index = str.indexOf("e");
System.out.println(index);
int hello = str.indexOf("le");
System.out.println(hello); // -1

// 从 fromIndex开始第一次出现的下标
index = str.indexOf("l", 3);
System.out.println(index);

// 最后一次出现的位置
index = str.lastIndexOf("l");
System.out.println(index); // 9

// 分隔字符串
str = "1-2-3-4-5-6";
String[] strs = str.split("-");
System.out.println(Arrays.toString(strs));

// 合并 static方法
str = String.join(".", "a", "b", "c", "d");
System.out.println(str);

isEmpty 和 isBlank 区别

isEmpty 当且仅当字符串长度为0时返回 true

isBlank 当字符串长度为0或字符串中全是空白字符时都是 true

intern（）用法

intern 如果字符串在常量池中有就返回常量池中的对象，如果没有就将对象放入常量池中,并将这个对象返回.

public class Demo07 {
	public static void main(String[] args) {
    /*
     intern 如果字符串在常量池中有就返回常量池中的对象，
            如果没有就将对象放入常量池中,并将这个对象返回
     */
        //        String str = "你好啊";
//
//
//        System.out.println(str);
//        System.out.println(System.identityHashCode(str));
//
//        String s = new String("你好啊").intern();
//
//        System.out.println(System.identityHashCode(s));
            // 1.
//        String str = "abc";
//
//        String s = new String("abc");
//
//        String s1 = s.intern();
//
//        System.out.println(str == s); // false
//        System.out.println(str == s1); // true
//        System.out.println(s == s1); // false  
        
             // 2.
//        String s = new String("abc");
//
//        String s1 = s.intern();
//
//        String str = "abc";
//
//        System.out.println(str == s); // false
//        System.out.println(str == s1); // true
//        System.out.println(s == s1); // false   
        
            // 3.
//        String  a = "a";
//        String s = new String(a + "bc");
//
//        String s1 = s.intern();
//
//        String str = "abc";
//
//        System.out.println(str == s); //  true
//        System.out.println(str == s1); // true
//        System.out.println(s == s1); //   true 
        
        // 4.
        String  a = "a";
        String s = new String(a + "bc");

        String str = "abc";

        String s1 = s.intern();
        System.out.println(str == s); //  false
        System.out.println(str == s1); // true
        System.out.println(s == s1); //   false

	}
}

valueOf() 类方法

有很多重载方法。涵盖了所有的数据类型转换 字符串的方法；

字符串 <—> 基本数据类型

public class Demo08 {
	public static void main(String[] args) {
    /*
           valueOf() 类方法，有很多重载方法。涵盖了所有的数据类型转换 字符串的方法；

           字符串 <---> 基本数据类型
     */
    // 任意类型转换为字符串
    byte b = 1;
    String str = String.valueOf(b);
    String.valueOf(true);
    String.valueOf(1.1);

    // int <---> String

    // 字符串 --> int  包装类.valueOf
    Integer a = Integer.valueOf("11");
    Integer.parseInt("11");
    System.out.println(a);
    // int  --> 字符串  String.valueOf()
    String s = String.valueOf(a);
	}
}

StringBuffer和StringBuilder

二者都是继承自抽象类AbstractStringBuilder

StringBuffer 中很多方法和 String 中的方法类似在此不再赘述

StringBuffer 是线程安全的类，StringBuilder是非线程安全的; String 不可变，所以是线程安全

StringBuilder执行效率相对较高.

StringBuffer 从jdk1.0开始就提供了，而StringBuilder 是jdk1.5才提供的

两个类大部分实现都一样，不同点在于StringBuffer 中大部分方法都有 synchronized 修饰。synchronized 表示同步，修饰的方法表示同步方法。是多线程中一种线程安全的实现方法。

StringBuffer常用方法

方法名	返回值	描述
append(Object obj)	StringBuffer	追加 Object参数的字符串
capacity()	int	返回当前容量
trimToSize()	void	尝试减少用于字符序列的存储空间
delete(int start,int end)	StringBuffer	删除此序列的子字符串中的字符
reverse()	StringBuffer	导致该字符序列被序列的相反代替
toString()	String	返回表示此顺序中的数据的字符串

StringBuffer sb = new StringBuffer();
sb.append("a").append("b");

StringBuilder

一个可变的字符序列。 此类提供与 StringBuffer 相同的API，但不保证同步

在可能的情况下，建议使用 StringBuilder ，因为它在大多数实现中将更快

在使用 String 实例拼接(’ + ')时，编译器会使用 StringBuilder 来拼接字符串

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

            // 16个长度的字符构建器
            StringBuilder sb = new StringBuilder();
            // 创建指定长度的 StringBuilder 对象
            sb = new StringBuilder(3);
            // 创建指定内容的 StringBuilder 对象
            //        sb = new StringBuilder("hello");
            System.out.println(sb.capacity());

            // 修改 StringBuilder 内容
            sb.append("a");
            sb.append("b");

            // 链式调用
            sb.append("c").append("d").append("e");

            // 删除某个位置
            //        sb.deleteCharAt(0);
            // 删除某个范围
//        sb.delete(0, 2);
            sb.insert(3, "A");

            // 数组长度 arr.length 字符串 str.length()
            //        System.out.println(sb.length());
            // StringBuilder --> String
            String str = sb.toString();
            System.out.println(str);
            System.out.println(sb.capacity());

            sb.reverse();
            System.out.println(sb.toString());
        }
    }

valueOf() 类方法

有很多重载方法。涵盖了所有的数据类型转换 字符串的方法；

字符串 <—> 基本数据类型

public class Demo08 {
	public static void main(String[] args) {
    /*
           valueOf() 类方法，有很多重载方法。涵盖了所有的数据类型转换 字符串的方法；

           字符串 <---> 基本数据类型
     */
    // 任意类型转换为字符串
    byte b = 1;
    String str = String.valueOf(b);
    String.valueOf(true);
    String.valueOf(1.1);

    // int <---> String

    // 字符串 --> int  包装类.valueOf
    Integer a = Integer.valueOf("11");
    Integer.parseInt("11");
    System.out.println(a);
    // int  --> 字符串  String.valueOf()
    String s = String.valueOf(a);
	}
}

包装类

public class Demo09 {
	public static void main(String[] args) {
    /*
        包装类
            自动装箱操作是通过 包装类.valueOf 进行的
            自动拆箱操作是通过 包装类对象.xxxValue() 进行
        包装类结构
     */

    Integer a = 1;
    int b = a;
// 	Integer n = Integer.valueOf(1);
//  Integer num = new Integer(1);
//  Integer num1 = new Integer("12");
    Integer num = 100;//  Integer.valueOf(100)
    Integer num1 = 100; // Integer.valueOf(100)

    System.out.println(num == num1);

    num = 200; // new Integer()
    num1 = 200; // new Integer();
    System.out.println(num == num1);

    // Byte  Short Character(0~127)  Integer Long 都有缓存对象数组
    Character c = '(';

    System.out.println(Character.isMirrored('['));
    }
}