String类、StringBuilder类、StringBuffer类-CSDN博客

本文链接：https://blog.csdn.net/weixin_62988263/article/details/141363432

String类

使用时无需导包，String是不可变字符类----内容和长度不可修改

String类底层用的是字符数组（char[ ]），JDK9之后String底层用的是字节数组（byte[ ]）

构造方法

常用构造方法：

方法	说明
String（）	创建一个没有任何内容的字符串对象
String(char[ ] chs)	根据字符数组的内容，来创建一个字符串对象
String（char[ ] chs,int offset,int count)	创建一个字符串对象，字符串的内容是字符数组中下标从offset开始的count个字符
String（byte[ ] bytes）	根据字节数组的内容，来创建一个字符串对象
String(byte[ ] bytes,int offset,int count)	创建一个字符串对象，字符串的内容是字节数组中下标从offset开始的count个字节
String str=“aba";	直接赋值的方式创建字符串对象，内容是aba，并未使用任何构造方法

public class StringDemo {
    public static void main(String[] args) {
        String s1=new String();
        System.out.println(s1);

        System.out.println(new String(new char[]{'a','b','a','b','a','b'}));
        System.out.println(new String(new char[]{'a','a','a','a','a','a','a','a',97,'a'},1,4));
        System.out.println(new String(new byte[]{99,'a','a','a','a'}));
        System.out.println("==========================");

        char[] ch={'a','b','c','d'};
        String str1=new String(ch);
        String str2=new String(ch);
        System.out.println(str1==str2);

        String str3="abcd";
        String str4="abcd";
        System.out.println(str4==str3);
        System.out.println(str1==str2);
        System.out.println(str1==str3);
        System.out.println(str1);
    }
}

在ASCII码中，a是97、A是65

String常用方法

判断字符串内容是否相同 equals

相同返回true，不同返回false

public boolean equals(Object obj)  //判断当前字符串对象是否和参数中的字符串内容相同
public boolean equalsIgnoreCase(String anotherString)   //判断当前字符串对象是否和参数中的字符串内容相同，比较的时候忽略大小写

获取字符串长度 length

public int length()     //获取当前字符串的长度，即多少个字符。

获取字符串中指定位置的字符 charAt

public char charAt(int index)   //获取指定下标的字符。下标从0开始，最大下标是length()-1

字符串比较 compareTo

public int compareTo(String anotherString)  //比较2个字符串的大小
public int compareToIgnoreCase(String anotherString)    //比较2个字符串的大小，忽略大小写

字符串拼接 concat

 public String concat(String str)    //返回一个由当前字符串和参数str拼接而成的新字符串。当前字符串内容不变。
+ //"+"也可以做字符串拼接。推荐使用 +

判断是否包含某字符串 contains、startswith、endswith

public boolean contains(String str);  //判断字符串中是否包含指定的 字符串
public boolean startsWith(String str);  //判断字符串是否以指定的字符串开头
public boolean endsWith(String str);    //判断字符串是否以指定的字符串结尾

获取指定字符串的下标 indexOf、lastIndexOf

toIndex、fromIndex可以超出字符串的查找范围

public int indexOf(int ch); //获取指定[字符]的下标,查找范围是:下标0到字符串.length()-1; 从前往后找,返回第一个匹配内容的下标, 如果找不到匹配的内容, 返回-1
public int indexOf(String subStr);//获取指定[字符串]的下标,查找范围是:下标0到字串.length()-1;从前往后找,返回第一个匹配内容的下标, 如果找不到匹配的内容, 返回-1
public int indexOf(int ch, int fromIndex); //获取指定[字符]的下标,查找范围是:下标fromIndex到字符串.length()-1;从前往后找,返回第一个匹配内容的下标, 如果找不到匹配的内容, 返回-1
public int indexOf(String subStr, int fromIndex); //获取指定[字符串]的下标,查找范围是:下标fromIndex到字符串.length()-1;从前往后找,返回第一个匹配内容的下标,如果找不到匹配的内容, 返回-1
public int lastIndexOf(int ch);//获取指定[字符]的下标,查找范围是:下标0到字符串.length()-1;从前往后找,返回最后一个匹配内容的下标,如果找不到匹配的内容, 返回-1
public int lastIndexOf(int ch, int toIndex);//获取指定[字符]的下标,查找范围是:下标0到toIndex;从前往后找,返回最后一个匹配内容的下标,如果找不到匹配的内容, 返回-1
public int lastIndexOf(String subStr);//获取指定[字符串]的下标,查找范围是:下标0到字符串.length()-1;从前往后找,返回最后一个匹配内容的下标,如果找不到匹配的内容, 返回-1
public int lastIndexOf(String subStr, int toIndex);//获取指定[字符串]的下标,查找范围是:下标0到toIndex;从前往后找,返回最后一个匹配内容的下标,如果找不到匹配的内容, 返回-1

字符串替换 replace

 public String replace(char oldChar,char newChar)    //字符替换
public String replace(CharSequence target,CharSequence replacement)     //字符串替换

字符串的分割与合并

public String[] split(String regex,int limit) //字符串以regex为分割线分割成多个小段，返回一个字符串数组.limit为分割后的数组的最大长度

public static String join(CharSequence delimiter,CharSequence... s) //将多个字符串合并成一个，合并的时候添加指定的连接符
public static String join(CharSequence delimiter, Iterable<? extends CharSequence> elements)  //将字符串数组合并成一个，合并的时候添加指定的连接符

字符串子串 subString

public String subString(int beginIndex) //获取从beginIndex开始到字符串结尾的子串
public String subString(int beginIndex, int endIndex) //获取从beginIndex到endIndex之间的子串，不含下标为endIndex的字符

字符串改变大小写 toLowerCase、toUpperCase

public String toLowerCase()    //将字符串改成全小写
public String toUpperCase()   //将字符串改成全大写

String是不可变字符串，创建之后，它的内容以及长度就固定了，不可以修改。改变大小写实际上是创建了新的字符串。

删除字符串左右两侧空白 trim

 public String trim()    //删除字符串左右两侧的空白(空格、换行符\n、缩进符\t)

其他类型转字符串 valueOf

public static String valueOf(数据类型 变量名)  //将其他数据类型的数据转换为字符串
通过""+变量进行转换，例如：int a = 10;  String str = a + "";

方法测试：

public class StringMethod {
    public static void main(String[] args) {
        String str1="abcd";
        char[] ch={'a','b','c','d','e','f','g','h','i','j'};
        String str2="abcd";
        String str3=new String(ch);

        System.out.println("判断字符串内容是否相同 equals");
        System.out.println("str1.equals(str2) = " + str1.equals(str2));
        System.out.println("str1.equalsIgnoreCase(\"ABCD\") = " + str1.equalsIgnoreCase("ABCD"));//忽略大小写
        System.out.println("获取字符串长度  length");
        System.out.println("str2.length() = " + str2.length());
        System.out.println("str3.length() = " + str3.length());

        System.out.println("\"获取字符串中指定位置的字符  charAt\" = " + "获取字符串中指定位置的字符  charAt");
        System.out.println("str2.charAt(2) = " + str2.charAt(2));
        System.out.println("str3.charAt(8) = " + str3.charAt(8));

        System.out.println("字符串比较  compareTo");
        System.out.println("str1.compareTo(str2) = " + str1.compareTo(str2));
        System.out.println("str1.compareTo(str3) = " + str1.compareTo(str3));
        System.out.println("str1.compareToIgnoreCase(\"ABCD\") = " + str1.compareToIgnoreCase("ABCD"));
        System.out.println("str1.compareToIgnoreCase(\"ABCd\") = " + str1.compareToIgnoreCase("ABCd"));
        System.out.println("str1.compareToIgnoreCase(\"ABCE\") = " + str1.compareToIgnoreCase("ABCE"));

        System.out.println("\"字符串拼接  concat\" = " + "字符串拼接  concat");
        System.out.println("str3.concat(str3) = " + str3.concat(str3));
        System.out.println("str3 = " + str3);

        System.out.println("判断是否包含某字符串  contains、startswith、endswith");
        System.out.println("str1.contains(\"ab\") = " + str1.contains("ab"));
        System.out.println("str1.contains(\"ac\") = " + str1.contains("ac"));
        System.out.println("str1.startsWith(\"a\") = " + str1.startsWith("a"));
        System.out.println("str1.endsWith(\"d\") = " + str1.endsWith("d"));
        System.out.println("str1.startsWith(\"bc\",1) = " + str1.startsWith("bc", 1));

        System.out.println("获取指定字符串的下标  indexOf、lastIndexOf");
        System.out.println("str1.indexOf(\"ab\") = " + str1.indexOf("ab"));
        System.out.println("str1 = " + str1);
        System.out.println("str3.indexOf(\"cd\") = " + str3.indexOf("cd"));
        System.out.println("str3 = " + str3);
        System.out.println("str3.indexOf('a') = " + str3.indexOf('a'));
        System.out.println("str3.indexOf(\"d\",3) = " + str3.indexOf("d", 3));
        System.out.println("str3.indexOf(\"d\",-1) = " + str3.indexOf("d", -1));
        System.out.println("str3.indexOf(\"d\",4) = " + str3.indexOf("d", 4));
        System.out.println("str3.lastIndexOf('d') = " + str3.lastIndexOf('d'));
        System.out.println("str3.lastIndexOf('e',9) = " + str3.lastIndexOf('e', 9));
        System.out.println("str3.lastIndexOf('e',9) = " + str3.lastIndexOf('e', 19));

        System.out.println("\"字符串替换  replace\" = " + "字符串替换  replace");
        System.out.println("str3.replace('a','d') = " + str3.replace('a', 'd'));
        System.out.println("str3.replace(\"abc\",\"ooo\") = " + str3.replace("abc", "ooo"));
        System.out.println("str3.replace(\"abc\",\"ooo\") = " + str3.replace("aboc", "ooo"));

        System.out.println("\"字符串的分割与合并  split、join\" = " + "字符串的分割与合并  split、join");
        System.out.println("str3.split(\"c\")[0] = " + str3.split("c")[0]);
        System.out.println("str3.split(\"c\")[0] = " + str3.split("c")[1]);
        System.out.println("str3.split(\"\",2).length = " + str3.split("", 2).length);
        String[] str4=null;
        System.out.println("str3.split(\"\",5).length = " +  str3.split("", 5).length);
        str4=str3.split("",15);
        for (int i=0;i<str4.length;i++){
            System.out.print(str4[i]+"\t");
        }
        System.out.println();
        System.out.println("str3.join( \"%\",str1,str4[6],str3) = " + str3.join("%", str1, str4[6], str3));
        System.out.println("字符串子串  subString");
        System.out.println("str3.substring(3) = " + str3.substring(3));
        System.out.println("str3.substring(2,5) = " + str3.substring(2, 5));
        System.out.println("\"字符串改变大小写\" = " + "字符串改变大小写");
        System.out.println("字符串改变大小写  toLowerCase、toUpperCase");
        System.out.println("str3.toUpperCase() = " + str3.toUpperCase());
        System.out.println("\"ASSDDF\".toLowerCase() = " + "ASSDDF".toLowerCase());
        System.out.println("删除字符串左右两侧空白   trim");
        System.out.println("\" 1 1 \" =" + " 1 1 ");
        System.out.println("\" 1 . 1 \".trim() =" + " 1 . 1 ".trim());
        System.out.println("\"\\n\\t   1.1\".trim() =" + "\n\t   1.1\n\t".trim());
    }
}

StringBuilder类

StringBuilder是 Java中的可变字符串类，对字符串进行增、删、改操作，字符串本身会受到影响

常用方法

StringBuilder构造方法

方法	描述
StringBuilder()	创建一个初始容量为16的StringBuilder对象，里面没有任何内容
StringBuilder(int capacity)	创建一个指定容量的StringBuilder对象，里面没有任何内容
StringBuilder(String str)	创建一个内容为str的StringBuilder对象，初始容量大小为16+str.length()
StringBuilder( charSequence seq)	创建一个内容为seq的StringBuilder对象，初始容量大小为16+str.length()。charSequence是个接口，任何实现类都可以作为参数

capacity()是获取StringBuilder对象容量的方法返回值为int

获取字符串的长度 length

public int length()     //获取当前字符串的长度，即多少个字符。

获取字符串中指定位置的字符 charAt

public char charAt(int index)   //获取指定位置的字符。index取值范围是0~length()-1

字符串的追加

public StringBuilder append(数据类型 变量名)   //将指定的数据拼接到当前字符串的末尾，并返回当前字符串对象。

字符串的插入

public StringBuilder insert(int offset, 数据类型 变量)        //在原有字符串的基础是将数据插入到指定位置，返回值是自身。

字符串的删除

public StringBuilder delete(int start, int end) //删除下标从start到end的字符（不含下标end）
public StringBuilder deleteCharAt(int index)    //删除指定下标的单个字符

字符串内容的修改

public StringBuilder replace(int start, int end, String str)        //将字符串中下标从start到end（不含end）的内容替换成参数str的内容。

public void setCharAt(int index, char ch)   //将字符串中指定位置的字符替换为ch

字符串的反转

 public StringBuilder reverse()  //将自身内容倒序

字符串子串

public String subString(int start)  //获取从start开始到字符串结尾的子串
public String subString(int start, int end) //获取从start到end之间的子串，不含下标为end的字符
public String subSequence(int start, int end) //获取从start到end之间的子串，不含下标为end的字符

StringBuilder和String的互转

public StringBuilder(String str)        //String转StringBuilder----StringBuilder的构造方法
public String toString()    //StringBuilder转String

StringBuilder是Java中的可变字符串类。开发中，多数情况下String类就能满足我们的开发需求，如果需要对字符串自身进行修改，我们通常使用StringBuilder类。StringBuilder和String可以相互转换。

StringBuffer类

StringBuffer也是 Java中的可变字符串类，可变指的是字符串的内容可变，即对字符串进行增、删、改操作，字符串本身会受到影响。

StringBuffer在用法上和StringBuilder的完全相同。----API完全一样

StringBuffer除了内容可变之外，另外一个特点就是线程安全（也叫线程同步）。在多线程环境下，不同的线程对同一个字符串操作，结果不会紊乱。----多线程是后面的内容。

String是不可变字符串。

StringBuffer在多线程环境下访问是安全的（也称线程同步），不会出现紊乱。

StringBuilder在多线程环境下访问是不安全的（也称线程不同步），数据可能会紊乱。