补坑：Java的字符串String类（1）

常用方法

字符串构造

来看看源码里面String的构造方法

普通字符串

        //"hello" 是字符串常量，没有\0标记结尾
        String str = "hello";
        System.out.println(str);//hello

        String str2 = new String();
        System.out.println(str2);//没有输出

        String str3 = new String("pppp");
        System.out.println(str3);//pppp

字符串数组

        char[] array = {'a','b','c'};
        String str4 = new String(array);
        System.out.println(str4);//abc

        char[] array1 = {'a','b','c'};
        String str5 = new String(array1,1,2);
        System.out.println(str5);//bc

⚠String是引用类型，内部并不存储字符串本身，String类实例变量

也就是说，一个String其实是长这样的

我们来尝试分析这段代码

String s1 = new String("hello");
String s2 = new String("world");
String s3 = s1;

假设s1的地址是0x9，new String之后在堆中创建一个新的String，value是0x8，把"hello"扔给这个String，那这个"hello"的地址也是0x8，s1根据value的地址找到"hello"对象

字符串长度 

辨析

        String str4 = "";
        System.out.println(str4.length());
        String str5 = null;
        System.out.println(str5.length());

str4指向的是一个空的字符串，空的字符串也是字符串，也是有长度的，只不过长度为0

str5不指向任何一个字符串，那它怎么可能会有长度呢

我们也可以用isEmpty()来检验

        String str4 = "";
        System.out.println(str4.isEmpty());
        String str5 = null;
        System.out.println(str5.isEmpty());

因为str4是空的字符串，那必然返回true，而str5什么都不指向，那就会返回空指针异常 

、

---

字符串比较

equals()

辨析：这个打印的结果是true吗？

        String s1 = new String("hello");
        String s2 = new String("hello");
        System.out.println(s1 == s2);

答案是false，== 比较的是s1和s2的地址，因为s1和s2本来在申请内存空间的时候，地址就不一样，怎么可能相等

那我们就要邀请String里面的一个方法.equals()来帮忙字符串比较了

    public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

从代码我们可以看出来，equals是按照字符串里的字符一个一个进行比较的，返回值是布尔类型

compareTo()

假设我有两个字符串，我想要比较这两个字符串谁大谁小

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

String里面实现了Comparable接口，那就可以调用compareTo方法轻松帮助我们解决问题

     System.out.println(s1.compareTo(s2));

该方法返回类型是int类型，如果s1>s2返回正数；s1=s2返回0；s1<s2返回负数

所以我们一般用>0或=0或<0来进行字符串比较

平时我们在输入验证码的时候，系统在比较两个字符串是否相等的时候是忽略大小写的

其实就是调用compareToIgnoreCase方法

---

字符串查找

charAt()

如果数字给大了，下标越界

indexOf()

从头到后查找字符第一次出现的下标

 也可以找子串在主串的位置

从指定位置开始查找

lastIndexOf()

倒着往回找

这就能延伸到BF算法和KMP算法，我后续会出博客，欢迎大家关注

---

字符串转化

1.数值和字符串转化

valueOf()方法，支持多种形式的数值，都能将其转化成字符串

        String s = String.valueOf(19.9);
        System.out.println(s);

那字符串怎么转成数字呢？

        int data = Integer.parseInt("198");
        System.out.println(data);

哪种数据类型对应哪种parsexx，假如给parseInt传入19.8，程序会报错数值格式错误

2.字符串大小写转化

toUpperCase()小写转大写；toLowerCase()大写转小写

        String s1 = "hello";
        //转变为大写不是在原来的基础上转变
        //转变成大写后是一个新的对象
        //如果只打印s1的话还只是小写
        String ret = s1.toUpperCase();
        System.out.println(ret);

3.字符串转数组

上面我们提到了数组怎么转成字符串(直接new String(array)暴力转换), 其实字符串也可以转数组(使用toCharArray())

toCharArray() 方法返回值是一个char类型的数组，所以我们要用一个新的array来接收它

4.格式化

        String s = String.format("%d-%d-%d",2023,11,9);
        System.out.println(s);

---

字符串替换

先来看看replace方法

比如这个，字符串里面所有的ab都被99代替了

replaceFirst()：将首个内容进行替换

这里只对第一个ab进行了替换，其他ab都不动

---

字符串拆分

split()：分割字符串

        String str = "hello abc world";
        String[] ret = str.split(" ");//将上面的字符串按照空格拆分
        for (int i = 0; i < ret.length; i++) {
            System.out.println(ret[i]);
        }

问题：

为什么用"."号分割字符串后打印出来没结果呢？

⚠1. 字符"|","*","+"都得加上转义字符，前面加上 "\\" .

2. 而如果是 "\\" ，那么就得写成 "\\\\" .

3. 如果一个字符串中有多个分隔符，可以用"|"作为连字符.

给你这个字符串，把每个单词拆分出来

String str = "name=zhangsan&age=18" ;

第一种写法，用|把两个分割判断符号分开来

        String[] ret = str.split("=|&");
        for (int i = 0; i < ret.length; i++) {
            System.out.println(ret[i]);
        }

第二种写法：多次分割法

        String[] ret = str.split("&");
        for (int i = 0; i < ret.length; i++) {
            System.out.println(ret[i]);
            String x = ret[i];
            //在第一次分割的基础上按照"="进行第二次分割
            String[] ret2 = x.split("=");
            for (int j = 0; j < ret2.length; j++) {
                System.out.println(ret2[j]);
            }
        }

---

字符串截取

substring(): 两个参数代表区间，一个参数代表从哪里开始截

        String str = "ababc";
        String ret = str.substring(0,3);//截取字符串范围[0,3)
        System.out.println(ret);

        String ret1 = str.substring(2);
        System.out.println(ret1);

其他的方法

---

字符串的不可变性

String类在设计时就是不可变的

String被final修饰，表示这个类不能被继承

而String的两个实例变量均被private修饰，外部根本拿不到这两个值，也无法修改

⚠String的不可变不是因为value被final修饰了，final修饰引用类型表明该引用变量不能引用其他对象，但是其引用对象的内容是可以修改的，接下来我们就来讲讲具体是怎么修改的。

---

String的修改

看看下面的例子

        String str = "hello";
        //System.out.println(str);//hello
        str = str + "abc";
        System.out.println(str);//helloabc

hello加上一个abc变成helloabc的过程，不是说把str的值进行修改（因为被private修饰根本拿不到value），而是创建了一个新的对象“helloabc"，再让str指向这个新对象

但是如果单纯采用String产生新对象的方法来修改字符串，这样的效率是十分低下的，因为会创建一堆新对象。其实java编辑器采用了另一种方法

我们拿上面的代码去窥探它的底层 

底层看不懂？我用代码来翻译一下

    public static void main(String[] args) {
        String str = "hello";
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append(str);
        stringBuilder.append("abc");
        str = stringBuilder.toString();
        System.out.println(str);
    }

底层代码构造了一个新的对象stringBuilder，传统的String对象是不可变的，但是有了StringBuilder这个可变对象，字符串就可以被修改了，而且效率很高（原因看下面）。那我们接下来就来讲讲StringBuilder这个对象

---

StringBuilder和StringBuffer

我们首先来比较一下String自创新String对象和采用StringBuilder或StringBuffer的效率

    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        String s = "";
        for(int i = 0; i < 10000; ++i){
            s += i;
        }
        long end = System.currentTimeMillis();
        System.out.println("String: "+(end - start));

        start = System.currentTimeMillis();
        StringBuffer sbf = new StringBuffer("");
        for(int i = 0; i < 10000; ++i){
            sbf.append(i);
        }
        end = System.currentTimeMillis();
        System.out.println("StringBuffer: "+(end - start));
        
        start = System.currentTimeMillis();
        StringBuilder sbd = new StringBuilder();
        for(int i = 0; i < 10000; ++i){
            sbd.append(i);
        }
        end = System.currentTimeMillis();
        System.out.println("StringBuilder: "+(end - start));
    }

看看内层

内层里面每一次循环StringBuilder一直存在，说明这个对象在创建之后就一直靠它来修改字符串，相比起String那种不断创建新对象再销毁旧对象的方法，这种方式显然效率更高。

StringBuffer也是这个道理

StringBuilder和StringBuffer的区别

StringBuilder的append方法底层

Stringbuffer的append方法底层

StringBuffer多了一个synchronized，表示保证线程安全，也就是说StringBuffer是一个线程安全的类

线程安全是什么？

可以参考这篇文章什么是线程安全，你真的了解吗？ - 知乎

这里可以简单用个厕所的例子来解释。假设有一个人要上厕所，一个厕所只能容纳一个人，这个人可以当成一个线程。厕所得有门锁才能保证里面的人的安全吧，诶这个锁就是所谓的保障线程安全，能够保证外面的人（其他线程）进不来。当这个人上完厕所后出来锁打开，换下一个人进去锁又闭上

 

上面的synchronized其实可以当成一个锁，阻止别的线程进入