Java =》 String类

作者 ：ふり

专栏 ：JavaSE

格言 ： I came ; I saw ; I conquer

文章目录

• 一、常用方法
• • 1.1 字符串构造
  • 1.2 String对象的比较
  • 1.3 字符串查找
  • 1.4 转化
  • 1.5 字符串替换
  • 1.6 字符串拆分
  • 1.7 字符串截取
  • 1.8 其他操作方法
  • 1.9 字符串常量池
  • • 1.9.1 创建对象的思考
    • 1.9.2 字符串常量池(StringTable)
  • 1.10 字符串的不可变性
  • 1.11 字符串修改
• 二、 StringBuilder和StringBuffer
• • 2.1 StringBuilder的介绍
  • 2.2 面试题：
• 三、 String类oj

一、常用方法

1.1 字符串构造

String类提供的构造方式非常多，常用的就以下三种：

public class Test {
    public static void main(String[] args) {
        //使用常量构造
        String str1 = "hello";
        System.out.println(str1);

        //直接 new 一个 String 对象
        String str2 = new String("abc");
        System.out.println(str2);

        //使用字符数组构造
        char[] arr = {'a','b','c'};
        String str3 = new String(arr);
        System.out.println(str3);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

• 其他方法需要用到时，大家参考Java在线文档：String官方文档

---

【注意】

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

---

public class Test {
    public static void main(String[] args) {
         s1和s2引用的是不同对象 s1和s3引用的是同一对象
        
        String s1 = new String("hello");
        String s2 = new String("world");
        String s3 = s1;
    }
}
1
2
3
4
5
6
7
8
9

---

2. 在Java中“”引起来的也是String类型对象。

        //可以算出字符串长度
        System.out.println(s1.length());
        //判断字符串长度是否为 0  ，0 =》 true  ,否则是 false
        System.out.println(s1.isEmpty());
1
2
3
4

---

1.2 String对象的比较

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

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

public class Test {
    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
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

2. boolean equals(Object anObject) 方法

• 按照字典序比较字典序：字符大小的顺序String类重写了父类Object中equals方法，Object中equals默认按照==比较，String重写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;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

• 代码例子

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

        String s1 = new String("hello");
        String s2 = new String("what");
        String s3 = new String("world");
        String s4 = s1;
        System.out.println(s1.equals(s2)); // false
        System.out.println(s2.equals(s3)); // false
        System.out.println(s1.equals(s4)); // true
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

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

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

1. 先按照字典次序大小比较，如果出现不等的字符，直接返回这两个字符的大小差值
2. 如果前k个字符相等(k为两个字符长度最小值)，返回值两个字符串长度差值

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
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

4. int compareToIgnoreCase(String str) 方法：与compareTo方式相同，但是忽略大小写比较

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.compareToIgnoreCase(s2)); // 不同输出字符差值   为 -1
        System.out.println(s1.compareToIgnoreCase(s3)); // 相同输出 0
        System.out.println(s1.compareToIgnoreCase(s4)); // 前k个字符完全相同，输出长度差值 为 -3
    }
}

1
2
3
4
5
6
7
8
9
10
11
12

---

1.3 字符串查找

public class Test {
    public static void main(String[] args) {
        String s = "aaabbbcccaaabbbccc";

        System.out.println(s.charAt(3)); // 'b'
        
        System.out.println("====================================");

        System.out.println(s.indexOf('c')); // 6

        System.out.println(s.indexOf('c', 10)); // 15

        System.out.println(s.indexOf("bbb")); // 3

        System.out.println(s.indexOf("bbb", 10)); // 12

        System.out.println("====================================");

        System.out.println(s.lastIndexOf('c')); // 17

        System.out.println(s.lastIndexOf('c', 10)); // 8

        System.out.println(s.lastIndexOf("bbb")); // 12

        System.out.println(s.lastIndexOf("bbb", 10)); // 3

    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

---

1.4 转化

1. 数值和字符串

• 数值转字符串

class Student {
    String name;
    int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class Test {
    public static void main(String[] args) {
        //数字转换成字符串
        String str = String.valueOf(123);
        System.out.println(str);
        
        //布尔类型转字符串
        String str1 = String.valueOf(true);
        System.out.println(str1);

        //把学生类转换成字符串
        String str3 = String.valueOf(new Student("黄桃",6));
        System.out.println(str3);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

• 字符串转数字

public class Test {
    public static void main(String[] args) {
        //字符串转换成整数
        int val1 = Integer.parseInt("123");
        //效果一样
        //int val1 = Integer.valueOf("123");
        System.out.println(val1 + 1);

        double val2 = Double.parseDouble("15.6");
       //效果一样
       // double val2 = Double.valueOf("15.6");
        System.out.println(val2 + 1.5);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

---

2. 大小写转换

public class Test {
    public static void main(String[] args) {
        //小写转大写
       String str = "helloSD";
       System.out.println(str.toUpperCase());//HELLOSD

       //大写转小写
       String str1 = "JIHFa";
        System.out.println(str1.toLowerCase());//jihfa
    }
}

1
2
3
4
5
6
7
8
9
10
11
12

---

3. 字符串转数组

import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
        
       String str1 = "JIHFa";

        char[] str2 = str1.toCharArray();
        System.out.println(Arrays.toString(str2)); //[J, I, H, F, a]
    }
}

1
2
3
4
5
6
7
8
9
10
11
12

---

4. 格式化

public class Test {
    public static void main(String[] args) {
        String s = String.format("%d-%d-%d",2022,8,11);//2022-8-11
        System.out.println(s);
    }
}

1
2
3
4
5
6
7

---

1.5 字符串替换

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

public class Test {
    public static void main(String[] args) {
       String str1 = "abcabcabcabacabcabc";
       String ret = str1.replace('a','d');

        System.out.println(ret);//dbcdbcdbcdbdcdbcdbc

        String ret1 = str1.replace("ab","pq");
        System.out.println(ret1);//pqcpqcpqcpqacpqcpqc

        String ret2 = str1.replaceAll("abc","pl");
        System.out.println(ret2);//plplplabacplpl

        String ret3 = str1.replaceFirst("abc","poiu");
        System.out.println(ret3);//poiuabcabcabacabcabc
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

注意事项: 由于字符串是不可变对象, 替换不修改当前字符串, 而是产生一个新的字符串.

---

1.6 字符串拆分

• 可以将一个完整的字符串按照指定的分隔符划分为若干个子字符串

import java.util.Arrays;

public class Test {
    public static void main(String[] args) {
       String str1 = "zhanr&wangshiji&lisi&ht";
       String[] ret = str1.split("&");
        System.out.println(Arrays.toString(ret));//[zhanr, wangshiji]
        
        String[] ret1 = str1.split("&",2);
        System.out.println(Arrays.toString(ret1));//[zhanr, wangshiji&lisi&ht]

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

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

public class Test {
    public static void main(String[] args) {
        String str = "192.168.1.1" ;
        String[] result = str.split("\\.") ;
        for(String s: result) {
            System.out.println(s);
        }
//        192
//        168
//        1
//        1
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

注意事项:

1. 字符"|“,”*“,”+"都得加上转义字符，前面加上 “\” .
2. 而如果是 “\” ，那么就得写成 “\\” .
3. 如果一个字符串中有多个分隔符，可以用"|"作为连字符.

public class Test {
    public static void main(String[] args) {
        String str = "name=zhangsan&age=18" ;
        String[] result = str.split("&") ;
        for (int i = 0; i < result.length; i++) {
            String[] temp = result[i].split("=") ;
            System.out.println(temp[0]+" = "+temp[1]);
        }
        //name = zhangsan
        //age = 18
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

---

1.7 字符串截取

代码示例: 观察字符串截取

public class Test {
    public static void main(String[] args) {
        String str = "helloworld" ;
        System.out.println(str.substring(5));  //world
        System.out.println(str.substring(0, 5));          //hello
    }
}

1
2
3
4
5
6
7
8

注意事项:

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

1.8 其他操作方法

public class Test {
    public static void main(String[] args) {
        String str = " hello world " ;
        System.out.println("["+str+"]");                      //[ hello world ]
        System.out.println("["+str.trim()+"]");               //[hello world]
    }
}

1
2
3
4
5
6
7
8

---

1.9 字符串常量池

1.9.1 创建对象的思考

下面两种创建String对象的方式相同吗？

public class Test {
    public static void main(String[] args) {
        String str1 = "wshj";
        String str2 = "wshj";
        String str3 = new String("wshj");
        String str4 = new String("wshj");

        System.out.println(str1 == str2);   
        System.out.println(str3 == str4);   
        System.out.println(str1 == str3);   
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

---

• 在Java程序中，字面类型的常量经常频繁使用，为了使程序的运行速度更快、更节省存，Java为8种基本数据类型和String类都提供了常量池。

• “池” 是编程中的一种常见的, 重要的提升效率的方式, 我们会在未来的学习中遇到各种 “内存池”, “线程池”, “数据库连接池” …

比如：家里给大家打生活费的方式

1. 家里经济拮据，每月定时打生活费，有时可能会晚，最差情况下可能需要向家里张口要，速度慢
2. 家里有矿，一次性打一年的生活费放到银行卡中，自己随用随取，速度非常快 方式2，就是池化技术的一种示例，钱放在卡上，随用随取，效率非常高。常见的池化技术比如：数据库连接池、线程池等。

为了节省存储空间以及程序的运行效率，Java中引入了：

1. Class文件常量池：每个.Java源文件编译后生成.Class文件中会保存当前类中的字面常量以及符号信息
2. 运行时常量池：在.Class文件被加载时，.Class文件中的常量池被加载到内存中称为运行时常量池，运行时常 量池每个类都有一份
3. 字符串常量池

---

1.9.2 字符串常量池(StringTable)

1. 直接使用字符串常量进行赋值

public class Test {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "hello";
        System.out.println(s1 == s2); // true
    }
}

1
2
3
4
5
6
7
8

---

2. 通过new创建String类对象

public class Test {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "hello";
        String s3 = new String("hello");
        String s4 = new String("hello");
        System.out.println(s1 == s2); // true
        System.out.println(s1 == s3); // false
        System.out.println(s3 == s4); // false
    }
}

1
2
3
4
5
6
7
8
9
10
11
12

• 结论：只要是new的对象，都是唯一的。

---

3. intern方法

• intern 是一个native方法(Native方法指：底层使用C++实现的，看不到其实现的源代码)，该方法的作用是手动将创建的String对象添加到常量池中。

public class Test {
    public static void main(String[] args) {
        char[] ch = new char[]{'a', 'b', 'c'};
        String s1 = new String(ch);                 // s1对象并不在常量池中
        s1.intern();                                // s1.intern()；调用之后，会将s1对象的引用放入到常量池中
        String s2 = "abc";                          // "abc" 在常量池中存在了，s2创建时直接用常量池中"abc"的引用
        System.out.println(s1 == s2);               //true
    }
}

1
2
3
4
5
6
7
8
9
10

• 不加 intern
  
• 加上 intern
  

• 面试题：请解释String类中两种对象实例化的区别 JDK1.8中

1. String str = “hello”
   只会开辟一块堆内存空间，保存在字符串常量池中，然后str共享常量池中的String对象
2. String str = new String(“hello”)
   会开辟两块堆内存空间，字符串"hello"保存在字符串常量池中，然后用常量池中的String对象给新开辟 的String对象赋值。
3. String str = new String(new char[ ]{‘h’, ‘e’, ‘l’, ‘l’, ‘o’})
   先在堆上创建一个String对象，然后利用copyof将重新开辟数组空间，将参数字符串数组中内容拷贝到 String对象中

---

1.10 字符串的不可变性

String是一种不可变对象. 字符串中的内容是不可改变。字符串不可被修改，是因为：

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

• 【纠正】
• 网上有些人说：字符串不可变是因为其内部保存字符的数组被final修饰了，因此不能改变。
• 这种说法是错误的，不是因为String类自身，或者其内部value被final修饰而不能被修改。
• final修饰类表明该类不想被继承，final修饰引用类型表明该引用变量不能引用其他对象，但是其引用对象中的内容是可以修改的。

String类中的字符实际保存在内部维护的value字符数组中，该图还可以看出：

1. String类被final修饰，表明该类不能被继承
2. value被修饰被final修饰，表明value自身的值不能改变，即不能引用其它字符数组，但是其引用空间中 的内容可以修改。

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

1.11 字符串修改

• 注意：尽量避免直接对String类型对象进行修改，因为String类是不能修改的，所有的修改都会创建新对象，效率非常低下。

public class Test {
    public static void main(String[] args) {
        String s = "hello";
        s += " world";
        System.out.println(s);                // 输出：hello world
    }
}

//  3个临时对象
1
2
3
4
5
6
7
8
9

• 这种方式不推荐使用，因为其效率非常低，中间创建了好多临时对象。

---

二、 StringBuilder和StringBuffer

2.1 StringBuilder的介绍

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

public class Test {
    public static void main(String[] args) {
        StringBuilder stringBuilder = new StringBuilder("hello");
        System.out.println(stringBuilder);      //hello

        String s = stringBuilder.toString();
        System.out.println(s);                 //hello

        stringBuilder.reverse();
        System.out.println(stringBuilder);     //olleh

    }
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

从上述例子可以看出：String和StringBuilder最大的区别在于String的内容无法修改，而StringBuilder的内容可以修改。频繁修改字符串的情况考虑使用StringBuilder。

• 注意：String和StringBuilder类不能直接转换。如果要想互相转换，可以采用如下原则:
• String变为StringBuilder: 利用StringBuilder的构造方法或append()方法
• StringBuilder变为String: 调用toString()方法

2.2 面试题：

1. String、StringBuffer、StringBuilder的区别

• String的内容不可修改，StringBuffer与StringBuilder的内容可以修改.
• StringBuffer与StringBuilder大部分功能是相似的
• StringBuffer采用同步处理，属于线程安全操作；而StringBuilder未采用同步处理，属于线程不安全操作

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

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

---

三、 String类oj

1. 第一个只出现一次的字符

class Solution {
    public int firstUniqChar(String s) {
        int[] count = new int[256];
       char[] ch = s.toCharArray();
       
       //计算每一个字符出现的次数
        for(int i = 0;i < ch.length;i++) {
            count[s.charAt(i)]++;     
        }
        for (int i = 0; i < ch.length; i++) {
            if(count[s.charAt(i)] == 1) {
                return i;
            }
        }
        return -1;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

2. 最后一个单词的长度

import java.io.InputStream;
import java.util.Scanner;

public class Main{
     public  static void  main(String [] args) throws Exception{
         Scanner scanner = new Scanner(System.in);
         String s = scanner.nextLine();
         //找到最后一个空格
         int lastIndex = s.lastIndexOf(" ");
         //字符串的长度 减去 最后一个空格的位置 减一
         int length = s.length() - lastIndex - 1;
         System.out.println(length);
     }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

• 或者使用 substring(截取部分内容)

int len = s.substring(s.lastIndexof(" ") + 1,s.length()).length();
1

3. 检测字符串是否为回文

class Solution {
    public static boolean isValid(char ch) {
        if((ch >= 'a' && ch <= 'z') || (ch >= '0' && ch <= '9')) {
            return true;
        }
        return false;
    }
    public boolean isPalindrome(String s) {
        //全部转换成小写
        s = s.toLowerCase();
        int left = 0;
        int right = s.length() - 1;
        while(left < right) {
            // 确保字符都是有效字符
            while((left < right) && !isValid(s.charAt(left))) {
                left++;
            }
            while((left < right) && !isValid(s.charAt(right))) {
                right--;
            }
            if(s.charAt(left) != s.charAt(right)) {
                return false;
            }else {
                left++;
                right--;
            }
        }
        return true;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30