【JavaSE】String类型


public class Text {
    public static void main(String[] args) {
        //使用常量字符串构造
        String s = "She is a beauty";
        System.out.println(s);
        //直接 new String 对象
        String s1 = new String("Wow!");
        System.out.println(s1);
        //使用字符数组进行构造
        char[] ch = {'S','O','S'};
        String s2 = new String(ch);
        System.out.println(s2);
    }
}

需要注意的是：

1. 由于 String 是引用类型，内部并不存储字符串本身，在 String 类的实现源码中，String 类实例变量如下：

可见，字符串实际是保存在字符数组中的。


public class Text {
    public static void main(String[] args) {
        String s1 = new String("We'll meet again");
        String s2 = new String("The oak tree");
        String s3 = s1;
    }
}

对于上述代码中，s1 和 s2 引用的是不同的对象，而 s1 和 s3 引用的是相同的对象：

2. 在 Java 中，使用双引号 " " 引起来的，也是 String 的对象

        System.out.println("try everything".length());

2.2 String 类对象的比较

字符串的比较是常见操作之一，比如：字符串排序。Java中总共提供了4中方式：

2.2.1 == 比较是否引用同一个对象

注意：对于基本数据类型，== 比较的是变量中的值；对于引用类型，== 比较的是引用中的地址。


    public static void main(String[] args) {
        String s1 = new String("We'll meet again");
        String s2 = new String("We'll meet again");
        String s3 = new String("The oak tree");
        String s4 = s1;
 
        System.out.println(s1 == s2);
        System.out.println(s1 == s4);
        System.out.println(s2 == s3);
}

输出

false
true
false

2.2.2 使用 equals 方法

String类重写了父类 Object 中 equals 方法，Object 中 equals 默认按照 == 比较，String 重写equals 方法后，按照如下规则进行比较，比如： s1.equals(s2)


    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. 从前往后逐个字符进行比较，只要有一个不同，就返回false
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

下面看一个简单的例子，了解一下 String 类 equals 方法吧：


    public static void main(String[] args) {
        String s1 = new String("oops");
        String s2 = new String("oops");
        String s3 = new String("Oops");
 
        System.out.println(s1 == s2);
        System.out.println(s2 == s3);
        System.out.println(s1.equals(s2));
        System.out.println(s2.equals(s3));
    }

输出

false
false
true
false

但如果是 equalsIgnoreCase 方法，则可以忽略大小写

        System.out.println(s2.equalsIgnoreCase(s3));

输出

true

2.2.3 compareTo 方法

与 equals 不同的是，equals 返回的是 boolean 类型，而 compareTo 返回的是 int 类型。具体比较方式：

1. 先按照字典次序大小比较，如果出现不等的字符，直接返回这两个字符的大小差值

2. 如果前 k 个字符相等( k 为两个字符长度最小值)，返回值两个字符串长度差值


    public int compareTo(String anotherString) {
        int len1 = value.length;
        int len2 = anotherString.value.length;
        int lim = Math.min(len1, len2);
        char v1[] = value;
        char v2[] = anotherString.value;
 
        int k = 0;
        while (k < lim) {
            char c1 = v1[k];
            char c2 = v2[k];
            // 1. 先按照字典次序大小比较，如果出现不等的字符，直接返回这两个字符的大小差值
            if (c1 != c2) {
                return c1 - c2;
            }
            k++;
        }
        //2. 如果前 k 个字符相等( k 为两个字符长度最小值)，返回值两个字符串长度差值
        return len1 - len2;
    }

下面看一下一个简单的例子：


    public static void main(String[] args) {
        String s1 = new String("oops");
        String s2 = new String("oops");
        String s3 = new String("oops!");
        String s4 = new String("Oops");
        System.out.println(s1.compareTo(s2));
        System.out.println(s2.compareTo(s3));
        System.out.println(s3.compareTo(s2));
        System.out.println(s2.compareTo(s4));
        System.out.println(s3.compareTo(s4));
        System.out.println(s2.compareToIgnoreCase(s4));
}

输出

0
-1
1
32
32
0

可见，对于完全相同的字符串，返回 0 ，对于前 k 个字符相同的字符串，输出字符串长度之差，有正负之分，而在前 k 个字符中，存在不同的字符，则根据字典序返回差值。

同样对于 compareToIgnoreCase 方法而言，忽略大小写

2.3 字符串的查找

字符串查找也是字符串中非常常见的操作，String类提供的常用查找的方法：

方法	功能
char charAt(int index)	返回index位置上字符，如果index为负数或者越界，抛出 IndexOutOfBoundsException异常
int indexOf(int ch)	返回ch第一次出现的位置，没有返回-1
int indexOf(int ch, int fromIndex)	从fromIndex位置开始找ch第一次出现的位置，没有返回-1
int indexOf(String str)	返回str第一次出现的位置，没有返回-1
int indexOf(String str, int fromIndex)	从fromIndex位置开始找str第一次出现的位置，没有返回-1
int lastIndexOf(int ch)	从后往前找，返回ch第一次出现的位置，没有返回-1
int lastIndexOf(int ch, int fromIndex)	从fromIndex位置开始找，从后往前找ch第一次出现的位置，没有返回-1
int lastIndexOf(String str)	从后往前找，返回str第一次出现的位置，没有返回-1
int lastIndexOf(String str, int fromIndex)	从fromIndex位置开始找，从后往前找str第一次出现的位置，没有返回-1

见以下例子：


    public static void main(String[] args) {
        String s = "ACDEFGHIJKABCDLMNOPQRBCDSTGHUVWSAYZ";
        System.out.println(s.charAt(15));
        System.out.println(s.indexOf('B'));
        System.out.println(s.indexOf('B',12));
        System.out.println(s.indexOf("BCD"));
        System.out.println(s.indexOf("BCD",20));
        System.out.println(s.lastIndexOf('A'));
        System.out.println(s.lastIndexOf('A',25));
        System.out.println(s.lastIndexOf("ABC"));
        System.out.println(s.lastIndexOf("GH",15));
    }

输出

M
11
21
11
21
32
10
10
5

2.4 字符串与别的数据类型的转换

2.4.1 数值和字符串的转换

1. 数字转换成字符串


    public static void main(String[] args) {
        String s1 = String.valueOf(1234567);
        String s2 = String.valueOf(1234.567);
        String s3 = String.valueOf(true);
        String s4 = String.valueOf('A');
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
        System.out.println(s4);
    }

输出

1234567
1234.567
true
A

2. 字符串转换成数字


    public static void main(String[] args) {
        int a = Integer.parseInt("12345");
        double b = Double.parseDouble("12.66");
        System.out.println(a);
        System.out.println(b);
    }

2.4.2 大小写转换


    public static void main(String[] args) {
        String s1 = "knock out";
        System.out.println(s1.toUpperCase());
        String s2 = "K.O.";
        System.out.println(s2.toLowerCase());
    }

2.4.3 字符串转换成数组

1. 字符串转数组


    public static void main(String[] args) {
        String s1 = "ooooooo";
        char[] ch = new char[s1.length()];
        ch = s1.toCharArray();
        for (int i = 0; i < s1.length(); i++) {
             System.out.print(ch[i]+" ");
        }
    }

输出

o o o o o o o

2. 数组转换成字符串

利用上述的例子，把 ch 这个数组重新转换成字符串：


        String s2 = new String(ch);
        System.out.println(s2);

2.4.4 字符串格式化


    public static void main(String[] args) {
        String s1 = String.format("%d-%d-%d",2022,11,29);
        System.out.println(s1);
    }

输出

2022-11-29

2.5 字符串的替换

使用一个指定的新的字符串替换掉已有的字符串数据，可用的方法如下：

方法	功能
String replaceAll(String regex, String replacement)	替换所有的指定内容
String replaceFirst(String regex, String replacement)	替换首个内容


    public static void main(String[] args) {
        String s = "aapphsaaaueaaauaaaks";
        System.out.println(s.replaceAll("a","x"));
        System.out.println(s.replaceFirst("pp","XXX0000xxxx"));
    }

输出

xxpphsxxxuexxxuxxxks
aaXXX0000xxxxhsaaaueaaauaaaks

需注意的是：

由于字符串是不可变对象, 替换不修改当前字符串, 而是产生一个新的字符串。

2.6 字符串的拆分

可以将一个完整的字符串按照指定的分隔符划分为若干个子字符串，方法如下：

方法	功能
String[] split(String regex)	将字符串全部拆分
String[] split(String regex, int limit)	将字符串以指定的格式，拆分为limit组


    public static void main(String[] args) {
        String s = "What do you do for a living?";
        String[] ret = s.split(" ");
        for(String ss : ret){
            System.out.print(ss+"   ");
        }
    }

输出

What do you do for a living?

字符串还可以部分拆分：


    public static void main(String[] args) {
        String s = "Judy❤Nick❤They live together and forever!❤❤~~";
        String[] ret = s.split("❤",3);
        for(String ss : ret){
            System.out.println(ss);
        }
    }

输出

Judy
Nick
They live together and forever!❤❤~~

拆分是特别常用的操作，一定要重点掌握。另外有些特殊字符作为分割符可能无法正确切分，需要加上转义。

比如拆分IP地址时，遇到的 . ，这个符号就需要转义。


    public static void main(String[] args) {
        String s = "192.452.135.1";
        String[] ret = s.split("\\.");
        for(String ss : ret){
            System.out.println(ss);
        }
    }

输出

192
452
135
1

需要注意的是：

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

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

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


    public static void main(String[] args) {
        String s = "192\\452\\135\\1";
        System.out.println(s);
        String[] ret = s.split("\\\\");
        for(String ss : ret){
            System.out.println(ss);
        }
        String s1 = "192*452*135*1";
        System.out.println(s1);
        String[] ret1 = s1.split("\\*");
        for(String ss1 : ret1){
            System.out.println(ss1);
        }
    }

输出

192\452\135\1
192
452
135
1
192*452*135*1
192
452
135
1

2.7 字符串的截取

从一个完整的字符串之中截取出部分内容。可用方法如下：

方法	功能
String substring(int beginIndex)	从指定索引截取到结尾
String substring(int beginIndex, int endIndex)	截取部分内容，左闭右开


    public static void main(String[] args) {
        String s = "helloBite!";
        String ret = s.substring(5);
        String ret1 = s.substring(0,5);
        System.out.println(ret1);
        System.out.println(ret);
    }

输出

hello
Bite!

2.8 trim——去掉字符串开头和结尾的空白字符

public String trim()，其功能为去掉字符串中的左右空格，保留中间空格


    public static void main(String[] args) {
        String s = "       I'm still fighting!          ";
        System.out.println("["+s.trim()+"]");
    }

输出

[I'm still fighting!]

2.9 字符串的不变性

String是一种不可变对象，字符串中的内容是不可改变。为什么这么说呢？

1. String类在设计时就是不可改变的，String类实现描述中已经说明了

进入 String 类中，我们就可以看到：

String 这个类，被 final 修饰，同时成员变量 value 也被 final 修饰，这意味着：

1. String 类被 final 修饰，表明该类不能被继承

2. value 被 final 修饰，表明 value 自身的值不能改变，这个值就是字符数组的地址。这个地址不能变，意味着不能引用其它字符数组，但是其引用空间中的内容可以修改。

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

拿 substring 方法举例：

可以看到，起始为 0 时，返回的是同一字符串的地址，但如果起始不为 0 ，则会重新 new 一个String 对象，这时，就是另一个不同的地址了。

为什么 String 要设计成不可变的?(不可变对象的好处是什么?)

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

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

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

那如果想要修改字符串中内容，该如何操作呢？这就是下一节将要介绍的内容。

2.10 字符串的修改

学到这里，给大家一个建议，我们最好尽量避免直接对 String 类型对象进行修改，因为 String 类是不能修改的，所有的修改都会创建新对象，效率非常低下。

由于String的不可更改特性，为了方便字符串的修改，Java 中又提供 StringBuilder 和 StringBuffer类。这两个类大部分功能是相同的，这里介绍 StringBuilder 常用的一些方法

2.10.1 StringBuilder

可以看到，StringBuilder 也是一个被 final 修饰的类。与 String 类不同的是，StringBuilder 实例的对象是可以修改的：


    public static void main(String[] args) {
        StringBuilder str = new StringBuilder("abcdefg ");
        System.out.println(str);
        str.reverse();
        System.out.println(str);
        str.append(12345).append(" hijkl ").append(14.25);
        System.out.println(str);
    }

输出

abcdefg
gfedcba
gfedcba12345 hijkl 14.25

查找一下 append 方法的具体实现就会发现，返回值为当前对象。

再看一看 reverse 方法的具体实现，返回值也是当前对象

与上面的例子相结合，可以知道 String 和 StringBuilder 最大的区别在于 String 的内容无法修改，而 StringBuilder 的内容可以修改。频繁修改字符串的情况考虑使用 StringBuilder 。

String和StringBuilder类不能直接转换。如果要想互相转换，可以采用如下原则：

1. String 变为 StringBuilder : 利用 StringBuilder 的构造方法或 append() 方法

2. StringBuilder 变为 String : 调用 toString() 方法

问题来了，请问 StringBuilder 和 StringBuffer 有什么区别呢？

让我们查看 StringBuffer 类中的具体实现，发现除构造方法外，其他的所有方法都有一个 synchronized 修饰，比如：

synchronized 可以理解成锁。在多线程情况下，使用 StringBuffer 安全性更高，但相对 StringBuilder 来说，效率更低，耗费更多资源。所以在需要频繁修改字符串的情况下，单线程选择 StringBuilder ，多线程选择 StringBuffer。

2.11 面试题

1. String、StringBuffer、StringBuilder 的区别

· String 的内容不可修改，StringBuffer 与 StringBuilder 的内容可以修改.

· StringBuffer 与 StringBuilder 大部分功能是相似的

· StringBuffer 采用同步处理，属于线程安全操作；而 StringBuilder 未采用同步处理，属于线程不安全操作

以下总共创建了多少个String对象【前提不考虑常量池之前是否存在】

String str = new String("ab"); // 会创建多少个对象

String str = new String("a") + new String("b"); // 会创建多少个对象

答：

2 5

相关阅读:
【方向盘】Java EE几十种技术，“活着的”还剩几何（服务/安全/Java SE篇）
VisualStudio运行程序，点击应用程序时，弹出多个个窗体问题
 收藏品集团怎样应用自动化程序实现降本增效
 Windows操作系统搭建Lsky Pro
科赫曲线
 c++类与对象
 rust持续学习 Fn FnMut FnOnce
HashMap 是怎么解决哈希冲突的？
点云数据转pnts二进制数据
 JPG如何直接转PDF？分享几个简单小技巧
原文地址：https://blog.csdn.net/qq_41233305/article/details/128092894