Java =》 String类_java 》=-CSDN博客

本文链接：https://blog.csdn.net/qq_55694452/article/details/126287963

作者：ふり

专栏：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);
    }
}

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

【注意】

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

在这里插入图片描述

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

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

1.2 String对象的比较

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

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

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

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

代码例子

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

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

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

先按照字典次序大小比较，如果出现不等的字符，直接返回这两个字符的大小差值
如果前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
    }
}

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.3 字符串查找

方法	功能
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 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.4 转化

数值和字符串

数值转字符串

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

字符串转数字

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

大小写转换

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

字符串转数组

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

格式化

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.5 字符串替换

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

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

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.6 字符串拆分

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

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

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]

    }
}

拆分是特别常用的操作. 一定要重点掌握. 另外有些特殊字符作为分割符可能无法正确切分, 需要加上转义.
拆分 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
    }
}

注意事项:

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

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.7 字符串截取

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

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

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

注意事项:

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

1.8 其他操作方法

方法	功能
String trim()	去掉字符串中的左右空格,保留中间空格

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.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);   
    }
}

在这里插入图片描述

在Java程序中，字面类型的常量经常频繁使用，为了使程序的运行速度更快、更节省存，Java为8种基本数据类型和String类都提供了常量池。
“池” 是编程中的一种常见的, 重要的提升效率的方式, 我们会在未来的学习中遇到各种 “内存池”, “线程池”, “数据库连接池” …

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

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

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

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

1.9.2 字符串常量池(StringTable)

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

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

在这里插入图片描述

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

在这里插入图片描述

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

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

不加 intern
加上 intern

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

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

1.10 字符串的不可变性

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

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

在这里插入图片描述

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

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

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

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

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个临时对象

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

二、 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

    }
}

在这里插入图片描述

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

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

2.2 面试题：

String、StringBuffer、StringBuilder的区别

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

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

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

在这里插入图片描述

三、 String类oj

第一个只出现一次的字符

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

最后一个单词的长度

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

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

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

检测字符串是否为回文

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