二十五、常用API之String和StringBuilder

一、String类

Java 提供了 String 类来创建和操作字符串
String类就是：字符串类，java程序中的所有的字符串值”abc”都是该类的实例 、字符串是常量，值创建后不能更改

String 类包括的方法

可用于检查序列的单个字符、比较字符串、搜索字符串、提取子字符串、创建字符串副本并将所有字符全部转换为大写或小写

常用的构造方法：

(1) String():创建一个新的String对象表示一个空的字符序列 ””

(2) String(String original):创建一个String对象，使其表示一个与参数相同的字符序列，新创建的字符串对象是该参数字符串的副本

(3) String(char[] value):将参数数组中的内容，转为字符串

(4) String(char[] value,int offset,int count): 从指定offset位置开始，向后count个元素转为字符串

(5) String(byte[] bytes):

(6) String(byte[] bytes,int offset,int count):

public class Demo01 {
    public static void main(String[] args) {
        //"abc"存储在常量池  是一个常量字符串 相同的字符串在常量池中只存储一份 s1中存储的是“abc”在常量池中的地址
        String s1 = "abc";
        String s2 = "abc";
        System.out.println(s1 == s2);//==比较的是地址值  true
        s1 = "bcd";//会改变“abc”本身吗 不会 字符串是不可以被改变的，是一个字符串常量
        //s1变的只是  s1这个引用中存储的常量地址变了
        System.out.println(s1 == s2);  //  输出false
        
        String s3 = new String("abc");
        //new 开辟了新的空间，将常量池中的abc复制一份存储到new开辟的空间中
        //s3中记录的是new这块空间的地址
        System.out.println(s2 == s3);  //false
        //String类重写了equals方法比较的是字符串的内容是否相同
        System.out.println(s2.equals(s3)); //true

        char[] cs = {'书','源','真','骚'};
        //通过String的构造方法可以将字符数组转为字符串
        
        String s4 = new String(cs);
        System.out.println(s4);  //书源真骚

        //还可以将字符数组的一部分，转为字符串
//        (4)String(char[] value,int offset,int count):
        //参数1：要转换的数组
        //参数2: 从哪个索引位置开始转换
        //参数3: 转换的个数
        //从索引2开始两个字符
        String s5 = new String(cs,2,2);
        System.out.println(s5);  //真骚

        byte[] b = {97,98,99,100};
        String s6 = new String(b);
        System.out.println(s6); //abcd
        //也可以像字符数组那样
        String s7 = new String(b,2,2);
        System.out.println(s7);//cd
    }
}

1、String类中的获取功能

1、length(): 获取字符串的长度(个数), 返回值 int

2、charAt(int index):，获取到指定index索引上的字符，返回值是char

3、subString(int beginIndex):截取字符串的一部分，返回一个新的字符串，从beginIndex索引开始到后面的所有的字符

4、subString(int beginIndex,int endIndex)：从begin位置开始到end-1之间进行截取，形成一个新的字符串，含头不含尾

5、indexOf(String str):获取str第一次出现的索引位置，返回值是int，没有找到就返回-1

6、indexOf(String str,int fromIndex):从指定位置开始寻找，返回在指定位置后第一次索引，返回值为int，没有找到返回-1

public class Demo02 {
    public static void main(String[] args) {
        //获取字符个数
        String str = "今天天气没40度，7月3号大降温，好消息25度";
        System.out.println(str.length());//23
        //由字符个数，可以得到索引范围   0~length()-1  0~22
        //获取指定索引的字符
        System.out.println(str.charAt(1));
        for (int i = 0; i < str.length(); i++) {
            System.out.println(str.charAt(i));
        }

        String str2 = "好好学习，天天加班";
        //截取某一段字符串，subString(int begin) 从指定位置开始到字符串结束 返回一个新的字符串
        String substring = str2.substring(5);//截取到的返回一个新的
        System.out.println(substring);//天天加班

        //截取某一段字符串，从指定位置开始，到指定位置结束，含头不含尾
        String substring1 = str2.substring(5, 7);
        System.out.println(substring1);//天天

        //indexOf(String str) 返回参数字符串在调用者中的第一次出现的索引位置
        //美羊羊对着喜羊羊喊喊
        String s = "喜羊羊不要不要不要啊，快停下来";
        int index = s.indexOf("不要");
        System.out.println(index);//2

        //从指定位置开始 向后寻找
        int index2 = s.indexOf("不要", 3);
        System.out.println(index2);//4
    }
}

2、String类判断的方法

1、equals(Object obj):比较两个字符串中的内容是否相同，比较的是内容不是地址

2、equalsIgnoreCase(String otherStr):不区分大小写比较两个字符串中的内容，常用于验证码比较

3、startsWith(String str):判断是否以指定开头

4、endsWith(String str):判断是否以指定结尾

5、isEmpty():判断是否为空

public class Demo03 {
    public static void main(String[] args) {
        String str1 = "abc";
        String str2 = new String("abc");
        System.out.println(str1 == str2); //false 不是一个对象，地址不相同 
        System.out.println(str1.equals(str2));//true 重写过后的方法比较的是内容

        //不区分大小写比较
        String s = "aBCd";
        String s2 = "AbcD";
        System.out.println(s.equalsIgnoreCase(s2));//true

        //判断是否已指定开头
        String str3 = "https://www.4399.com";
        System.out.println(str3.startsWith("https://"));//true

        //判断是否已指定结尾
        String str4 = "作者与室友不可描述的小秘密.avi";
        System.out.println(str4.endsWith(".avi"));//true

        //判断一个字符串是否为空字符串
        String str5 = "";//叫做空  null表示没有任何引用指向他，就没有对象
        System.out.println(str5.isEmpty());//true

//        str5 = null; 空指针异常  NullPointerException
//        System.out.println(str5.isEmpty());
    }
}

3、String类型转换方法

1、getBytes(): 把字符串转为byte数组， 返回一个byte数组

2、toCharArray(); 把当前字符串转为字符数组，返回一个字符数组

3、toUpperCase():=把字符串中的英文全部提升为大写，返回一个新字符串

4、toLowerCase()：将字符串中的英文全部转为小写，返回一个新字符串

5、concat(String s):字符串的拼接，将指定的字符串和参数字符串进行拼接，用的比较少，因为**+也可以完成**

6、系列方法valueOf()：静态方法，可以将任意数据类型转为字符串类型，但是用的比较少，因为一般使用的时候 其他类型+ “” 也可以完成

public class Demo04 {
    public static void main(String[] args) {
        String s = "abcdef";
        //将一个字符串转为字节数组
        byte[] b = s.getBytes();
        for (int i = 0; i < b.length; i++) {
            System.out.print(b[i]+" ");//97 98 99 100 101 102 a
        }

        //转为字符数组
        char[] cs = s.toCharArray();
        for (int i = 0; i < cs.length; i++) {
            System.out.print(cs[i]+" ");//a b c d e f
        }

        //将字符串中的字母全部转为大写  返回一个新的字符串
        String s1 = s.toUpperCase();
        System.out.println(s1);//ABCDEF
        //将字符串中的字母全部转为小写
        String s2 = "ABcdEfg";
        String s3 = s2.toLowerCase();
        System.out.println(s3);//abcdefg

        //concat字符串拼接
        String str1 = "书源好帅啊";
        String str2 = "好想抱抱他呀";
        System.out.println(str1 + str2);
        System.out.println(str1.concat(str2));

        int a = 100;
        double d = 3.14;
        boolean boo = true;
        System.out.println("" + a);
        //valueOf 静态方法
        String s6 = String.valueOf(a);//100
        String s5 = String.valueOf(d);//3.14
        String s4 = String.valueOf(true);//true
        System.out.println(s4 + s5 + s6);//true3.14100
    }
}

4、String类的其他方法

1、replace(String oldStr,String newStr):将调用者中的老字符串替换为新字符串，返回值替换之后的字符串

2、trim(): 去除两端的空格或者制表符 只能去除两端 返回值是一个新字符串

3、split(String regex):将字符串按照参数字符串regex规则进行切割，返回值是一个String[]

public class Demo05 {
    public static void main(String[] args) {
        String s = "美羊羊刚又说喜羊羊非常非常不喜欢我";
        //非常不喜欢
        String replace = s.replace("非常非常不喜欢", "深爱着");
        System.out.println(replace);// 美羊羊刚又说喜羊羊深爱着我
        //去除两端的空格和制表符
        String user = "     ab c    ";
        String username = "ab c";
        System.out.println(user.trim().equals(username));//true

        //定义一个字符串，2022-6-29
        //想要单独的获取出年月日   年-月-日
        //可以使用-进行分割
        String str = "2022-6-29";
        String[] split = str.split("-");
        for (int i = 0; i < split.length; i++) {
            System.out.println(split[i]);
        }
    }
}

练习

1、键盘录入一个英文字符串，将英文字符串的首字母大写，其他字母全部转为小写

public class Demo06 {
    public static void main(String[] args) {
//        1、键盘录入一个英文字符串，将英文字符串的首字母大写，其他字母全部转为小写
        //键盘了录入
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一段英文字符串");
        String next = sc.next();
        //先获取首字母
        String s1 = next.substring(0, 1);
        //获取剩余的字母
        String s2 = next.substring(1);
        String s3 = s1.toUpperCase();//将首字母大写
        String s4 = s2.toLowerCase();//将剩余字母小写
        System.out.println(s3 + s4);
        //链式编程，只要返回值是某个类型，就可以继续调用该类型的方法
        String concat = next.substring(0, 1).toUpperCase().concat(next.substring(1).toUpperCase());
        System.out.println(concat);
    }
}

二、StringBuilder

StringBuilder可变的字符序列，允许修改字符串中的内容，在类中提供了修改成员变量的方法有大量的append，insert方法，可以操作任意类型的数据 、在底层维护的是一个char数组，他的可变都是在修改数组中的内容，本质上类中定义了一个Value属性，是char[]

StringBuilder和String的区别：

(1) String是不可变的，没有提供修改成员的方法，StringBuilder是可变的，因为提供了修改的方法

(2) String长度也是不可以变的，StringBuilder的长度可以发生变化，可以认为是一个可以伸缩的容器，用于存储字符串

1、StringBuilder的构造方法

1、StringBuilder():空参数构造，默认会生成一个16大小的字符数组 32个字节

2、StringBuilder(String str):使用指定的字符串初始化StringBuilder对象，此时申请的数组长度为str.length() + 16

3、StringBuilder(int capacity):通过参数指定数组的大小

4、获取容积的方法capacity() 获取当前容器的大小

5、length(); 获取当前容器的字符的个数

public class Demo07 {
    public static void main(String[] args) {
        //默认空参是16大小的字符数组
        StringBuilder sb = new StringBuilder();
        //获取容积
        System.out.println(sb.capacity());//16
        //获取字符个数
        System.out.println(sb.length());//0

        //StringBuilder(String str) 容积 str.length + 16
        StringBuilder sb1 = new StringBuilder("abc");
        System.out.println(sb1.capacity());//19
        System.out.println(sb1.length());//3

        //指定容积
        StringBuilder sb2 = new StringBuilder(10);
        System.out.println(sb2.capacity());//10
        sb2.append("123456789");
        System.out.println(sb2.length());//9
        System.out.println(sb2.capacity());//10
        sb2.append("a");
        sb2.append("aa");
        //如果原来的存储不下了，就会扩容  (原来的大小+1) * 2
        System.out.println(sb2.length());//12
        System.out.println(sb2.capacity());//22
    }
}

2、StringBuilder的添加功能

1、append(任意类型)：在StringBuilder对象后面拼接任意数据

2、insert(int index,任意类型): 在指定的位置拼接数据，index范围不能越界，0~容积-1

public class Demo08 {
    public static void main(String[] args) {
        //向StringBuilder末尾添加数据
        StringBuilder sb = new StringBuilder("123456");
        //insert（）在指定的位置拼接数据，index范围不能越界，0~容积-1
        sb.insert(1,"喜羊羊啊");
        System.out.println(sb);
        //插入的时候必须保证前面有元素
//        sb.insert(13,"哎哎哎");
        System.out.println(sb);
        char[] c = {'你','好','啊'};
        sb.insert(0,c);
        System.out.println(sb);
        Object o = new Object();
        sb.insert(0,o);
        System.out.println(sb);
    }
    //快速封装方法 ctrl + alt + m
    private static void test(StringBuilder sb) {
        sb.append("周三啦");
        sb.append("好快啊");
        sb.append("过周日就马上一年就结束了");
        System.out.println(sb);
    }
}

3、StringBuilder的删除功能和修改

1、deleteCharAt(int index):删除指定位置（索引）的字符

2、delete(int start, int end):删除指定范围的字符，含头不含尾

3、replace(int start,int end,String str):把指定位置strat开始到end-1的位置的内容，替换为str，含头不含尾

4、reverse():将原来的字符串反转

public class Demo09 {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("张三不喜欢李四");
        sb.deleteCharAt(2);
        System.out.println(sb);
        //含头补含尾  索引位置
        sb.delete(2,4);
        System.out.println(sb);
        //替换
        sb.replace(0,2,"三三");
        System.out.println(sb);
        sb.reverse();//反转
        System.out.println(sb);
    }
}