【JAVA】String类

作者主页：paper jie_的博客

本文作者：大家好，我是paper jie，感谢你阅读本文，欢迎一建三连哦。

本文录入于《JAVASE语法系列》专栏，本专栏是针对于大学生，编程小白精心打造的。笔者用重金(时间和精力)打造，将javaSE基础知识一网打尽，希望可以帮到读者们哦。

其他专栏：《JAVA》《算法详解》《C语言》等

内容分享：本期将会对JAVA中的String类进行分享

目录

String类的引出

String类的常用方法

字符串构造

String对象的比较

比较是否引用的是同一个对象

boolean aquals（Object o）比较方法：按照字典序比较

int compareTo(String s)方法：按照字典序进行比较

字符串查找

转换

数值与字符串转换

大小写转换

字符串与数组转换

格式化

字符串替换

字符串拆分

字符串截取

去处空格

字符串的不可变性

String设计成不可变的原因

字符串的修改

StringBuilder和StringBuffer

String，StringBuilder，StringBuffer的区别

---

String类的引出

C语言中，我们发现里面是没有字符串类型的，要想表达字符串只能通过字符数组或者字符指针，可以用它的标准库提供的字符串函数完成操作，但是这种将数据和操作数据方法分离的方式它不符合面向对象的思想，因此java中专门提供了String类。

String类的常用方法

字符串构造

String类提供的构造方法一般有三种：

public class Test {
    public static void main(String[] args) {
        //使用常量串构造
        String s1 = "hello word";
        System.out.println(s1);
        
        //直接new一个String对象
        String s2 = new String("hello word");
        System.out.println(s2);
        
        //使用字符数组进行构造
        char[] array = {'h','e','l','l','0'};
        String s3 = new String(array);
    }
}

这里要注意一个地方：

String是一个引用类型，内部并不会存储字符串本身，我们可以看看string类的源码：

    public static void main(String[] args) {
 
// s1和s2引用的是不同对象 s1和s3引用的是同一对象
        String s1 = new String("hello");
        String s2 = new String("world");
        String s3 = s1;
 
        System.out.println(s1.length()); // 获取字符串长度---输出5
        System.out.println(s3.isEmpty()); // 如果字符串长度为0，返回true，否则返回false
    }

画图分析：

String对象的比较

字符串的比较，java中提供了4种方式

比较是否引用的是同一个对象

对内置类型，==比较的是变量中的值，对于引用类型==比较的是引用中的地址：

    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 10;
// 对于基本类型变量，==比较两个变量中存储的值是否相同
        System.out.println(a == b); // false
        System.out.println(a == c); // true
// 对于引用类型变量，==比较两个引用变量引用的是否为同一个对象
        String s1 = new String("hello");
        String s2 = new String("hello");
        String s3 = new String("world");
        String s4 = s1;
        System.out.println(s1 == s2); // false
        System.out.println(s2 == s3); // false
        System.out.println(s1 == s4); // true
    }

boolean aquals（Object o）比较方法：按照字典序比较

String类重写父类Object中的equals方法，Object类中equals方法默认按==比较，String重写equals方法后，按照以下规则比较：

equals方法的源码：

    public boolean equals(Object anObject) {
// 1. 先检测this 和 anObject 是否为同一个对象比较，如果是返回true
        if (this == anObject) {
            return true;
        } // 2. 检测anObject是否为String类型的对象，如果是继续比较，否则返回false
        if (anObject instanceof String) {
// 将anObject向下转型为String类型对象
            String anotherString = (String) anObject;
            int n = value.length;
// 3. this和anObject两个字符串的长度是否相同，是继续比较，否则返回false
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
// 4. 按照字典序，从前往后逐个字符进行比较
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

int compareTo(String s)方法：按照字典序进行比较

与equals方法不同是，equals返回的是对还是错，而compareTo返回的是整数。比较方式：

1 先按照字典序比较，出现不同的字符，返回这两个字符的大小差值。

2 如果一直到一个字符串比较完字符都相等的话但他们的长度不同，则返回值是这两个字符串的长度差值

public class Test {
        public static void main(String[] args) {
            String s1 = new String("abc");
            String s2 = new String("ac");
            String s3 = new String("abc");
            String s4 = new String("abcdef");
            System.out.println(s1.compareTo(s2)); // 不同输出字符差值-1
            System.out.println(s1.compareTo(s3)); // 相同输出 0
            System.out.println(s1.compareTo(s4)); // 前k个字符完全相同，输出长度差值 -3
        }
}

字符串查找

字符串查找String类提供了许多查找方法：

public class Test {
    public static void main(String[] args) {
        //通过下标找字符
        String s1 = "abcdefgh";
        char ch = s1.charAt(2);
        System.out.println(ch);
 
        //通过字符找下标
        int index1 = s1.indexOf('c');
        System.out.println(index1);
 
        //跳着找
        int index2 = s1.indexOf('e', 3);
        System.out.println(index2);
 
        //通过子字符串找第一次出现的下标
        int index3 = s1.indexOf("def");
        System.out.println(index3);
 
        //跳着找子字符串返回第一次出现的下标
        int index4 = s1.indexOf("def", 2);
        System.out.println(index4);
        
        //倒着找字符
        int lastindex1 = s1.lastIndexOf('c');
        System.out.println(lastindex1);
 
        //跳着倒着找字符
        int lastindex2 = s1.lastIndexOf('c', 5);
        System.out.println(lastindex2);
 
        //倒着找字符串
        int lastindex3 = s1.lastIndexOf("ef");
        System.out.println(lastindex3);
 
        //倒着跳着找字符串
        int lastindex4 = s1.lastIndexOf("ef", 6);
        System.out.println(lastindex4);
    }

转换

数值与字符串转换

数字转字符串：

    public static void main(String[] args) {
        //数字转字符串
        String s1 = String.valueOf(1111);
        String s2 = String.valueOf(11.11);
        String s3 = String.valueOf(true);
        String s4 = String.valueOf(new person("baga", 19));
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
        System.out.println(s4);
    }

字符串转数字：

    public static void main(String[] args) {
        //字符串转数字 integer Double 是包装类型
        int data = Integer.parseInt("12345");
        double data2 = Double.parseDouble("12.43");
        System.out.println(data);
        System.out.println(data2);
    }

大小写转换

    public static void main(String[] args) {
        //大写转小写
        String s1 = "hello word";
        String str1 = s1.toUpperCase();
        System.out.println(str1);
        //小写转大写
        String s2 = "HELLO WORD";
        String str2 = s2.toLowerCase();
        System.out.println(str2);
    }

字符串与数组转换

public static void main(String[] args) {
        //字符串转数组
        String s1 = "hello word";
        char[] ch = s1.toCharArray();
        for (int i = 0; i < ch.length; i++) {
            System.out.print(ch[i]+" ");
        }
 
        //数组转字符串
        char[] array = new char[]{'f','f','f','o','o','o'};
        String s2 = new String(array);
        System.out.println(s2);
    }

格式化

    public static void main(String[] args) {
        String s = String.format("%d %d %d ", 12, 34, 56);
        System.out.println(s);
    }

字符串替换

    public static void main(String[] args) {
        String s1 = "asdfasfasafaiughesfsfafil";
        //替换全部的子字符
        String str1 = s1.replaceAll("fa", "000");
        System.out.println(str1);
        //替换第一个个子字符
        String str2 = s1.replaceFirst("fd", "99");
        System.out.println(str2);
    }

字符串拆分

    public static void main(String[] args) {
        //全部拆分
        String s1 = "hello word wo lai le";
        String[] str = s1.split(" ");
        for (int i = 0; i < str.length; i++) {
            System.out.println(str[i]);
        }
        System.out.println();
        //拆分部分
        String[] str2 = s1.split(" ", 3);
        for (int i = 0; i < str2.length; i++) {
            System.out.println(str2[i]);
        }
    }

使用特殊符号"|","*","+"需要用一个斜杠表示，而两个斜杠表示一个斜杠

多个字符分割时，用竖线|隔开

字符串截取

从一个完整的字符串中截取部分内容

    public static void main(String[] args) {
        //从指定索引到末尾
        String s1 = "sadfdsag";
        String str1 = s1.substring(3);
        System.out.println(str1);
        //截取部分内容 遵循左闭右开规则
        String str2 = s1.substring(1, 3);
        System.out.println(str2);
 
    }

1. 索引从0开始 

2. 注意前闭后开区间的写法, substring(0, 5) 表示包含 0 号下标的字符, 不包含 5 号下标 

去处空格

trim会去除字符串开头和结尾的空白字符（空格，换行，制表符）

    public static void main(String[] args) {
        String s1 ="   hello werd sad   ";
        String str = s1.trim();
        System.out.println(str);
    }

字符串的不可变性

String类是一种不可变的对象，它的内容是不可以改变的。字符串它为什么不能改变呢？

1 String类它在设计的时候就是不可以改变的。字符串实现描述中已经说的很明白了：

通过1观察源码，我们发现：

String类中的字符实际保存在内部维护的value字符数组中

String类被final修饰，不可以被继承

value被final修饰，表明value自身的值是不能被改变的，也就是不可以引用其他字符数组，但是它空间中的内容可以改变。

所有涉及到修改字符串的操作，都是创建一个新对象，改变的是新对象

栗子：

注意：

这里字符串不能修改不是因为value被final修饰了，final修饰只是类是表示不能被继承，修饰引用类型表示不能引用其他对象，但是引用对象里面的内容还是可以修改的。

不能修改是因为value被private修饰，只能被当前类访问，在当前类的外部是访问不到的。

栗子：

public static void main(String[] args) {
final int array[] = {1,2,3,4,5};
array[0] = 100;
System.out.println(Arrays.toString(array));
// array = new int[]{4,5,6}; // 编译报错：Error:(19, 9) java: 无法为最终变量array分配值
}

String设计成不可变的原因

方便实现字符串对象池 ，如果String类可变，那么对象池就需要考虑拷贝的问题了

不可变对象的线程是安全的

不可变对象更方便缓存hash code，作为key的时候可以更高效的保存到HashMap中

字符串的修改

对于String类对象进行修改，它是不能直接修改的，会创建新的对象，效率就会变得地下，特别是在循环中使用的时候。

public static void main(String[] args) {
        String s = "hello";
        s = s + "word";
        System.out.println(s);
    }

我们可以通过cmd观察底层实现逻辑：

通过观察，发现它在这中间创建了一些临时变量，因此效率地下

public static void main2(String[] args) {
        long start = System.currentTimeMillis();
        String s = "";
        for(int i = 0; i < 10000; ++i){
            s += i;
        } long end = System.currentTimeMillis();
        System.out.println(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(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(end - start);
    }

通过结果就可以发现他们相差的时间巨大，我们看看底层的执行逻辑：

因此，我们需要尽量避免对String类的直接需要，要修改尽量使用StringBuffer和StringBuilder

StringBuilder和StringBuffer

因为String类的不可改变性，为了方便字符串的修改，java中提供了StringBuilder和Stringbuffer两个类。他们两个类的功能差不多相同。方法和String其实也差不多

    public static void main(String[] args) {
        StringBuilder sb1 = new StringBuilder("hello");
        StringBuilder sb2 = sb1;
// 追加：即尾插-->字符、字符串、整形数字
        sb1.append(' '); // hello
        sb1.append("world"); // hello world
        sb1.append(123); // hello world123
        System.out.println(sb1); // hello world123
        System.out.println(sb1 == sb2); // true
        System.out.println(sb1.charAt(0)); // 获取0号位上的字符 h
        System.out.println(sb1.length()); // 获取字符串的有效长度14
        System.out.println(sb1.capacity()); // 获取底层数组的总大小
        sb1.setCharAt(0, 'H'); // 设置任意位置的字符 Hello world123
        sb1.insert(0, "Hello world!!!"); // Hello world!!!Hello world123
        System.out.println(sb1);
        System.out.println(sb1.indexOf("Hello")); // 获取Hello第一次出现的位置
        System.out.println(sb1.lastIndexOf("hello")); // 获取hello最后一次出现的位置
        sb1.deleteCharAt(0); // 删除首字符
        sb1.delete(0,5); // 删除[0, 5)范围内的字符
        String str = sb1.substring(0, 5); // 截取[0, 5)区间中的字符以String的方式返回
        System.out.println(str);
        sb1.reverse(); // 字符串逆转
        str = sb1.toString(); // 将StringBuffer以String的方式返回
        System.out.println(str);
    }

String和StringBuffer，StringBuilder的区别就是前者不能修改，后两者可以修改。需要频繁修改字符串可以考虑使用后两者。

这里需要注意几点：

String类和Stringbuffer，StringBuilder不能直接转化

String转换为StringBilder，StringBuffer需要使用后者的构造方法或者append（）方法、

StringBuilder和Stringbuffer转换为String需要调用toString方法

String，StringBuilder，StringBuffer的区别

String的内容不可以修改，而StringBuilder和StringBuffer可以修改内容

他们的大部分功能是相同的

StringBuffer是同步操作，线程是安全的；StringBuilder未同步操作，线程是不安全的

因为StringBuffer需要不断的关锁开锁，性能略低于StringBuilder

---