Javaでよく使われる文字列関連クラスの使い方-＆＃＆チュートリアル-php.cn

String 関連クラス

String、StringBuilder、および StringBuffer クラスは、3 つの文字列関連クラスです。

String クラスは不変の文字シーケンスを表し、StringBuilder クラスと StringBuffer クラスは変更可能な文字シーケンスを表します。

この3つのカテゴリの詳しい使い方は、筆記試験や面接、さらには実際の開発でも頻繁に使われるので、必ずマスターしておかなければなりません。

1. String クラスの使用

String の一般的なメソッド:

1.isEmpty() は、文字列が空の場合は true を返し、それ以外の場合は false

## を返します。 #2.length() 文字列の長さを計算します

3.isBlank() このメソッドは、指定された文字列が空であるか、空白のコードポイントのみが含まれている場合は true を返し、それ以外の場合は false

4 を返します。 startsWith() 括弧内の文字列で始まるかどうか

5.endsWith() 括弧内の文字列で終わるかどうか

6.toLowerCase() は、すべての英語文字を含む新しい文字列を生成します文字列内のすべての英語文字が大文字に変更されます。

7.toUpperCase() は新しい文字列を生成します。文字列内のすべての英語文字は大文字に変更されます。

8.charAt() は、指定されたインデックス位置を返します。文字の値。インデックスの範囲は 0~length()-1

9.substring(int startIndex) サブストリングはインデックス

10 から始まります。substring(int startIndex, int endIndex) は文字列を返します。この文字列はこの文字列の部分文字列です。

部分文字列は、指定された beginIndex で始まり、文字インデックス endIndex- 1

11.public int indexOf (int ch) 文字列 Index# 内で最初に出現した指定文字を返します。

##12.indexOf(String str, int fromIndex) 指定されたインデックスから開始して、指定された部分文字列が最初に出現する文字列内のインデックスを後方から返します。インデックス位置をクエリします。指定された文字列が初めて検出されました。インデックスは依然として前から後ろにカウントされていることに注意してください。

14.split() メソッド: 文字列を分割します。パラメータ正規表現はセパレータと呼ばれ、通常の正規表現を使用できます。

15.replace() を表す式は、文字列内の一部の文字を他の文字に置き換えたり、正規表現に一致する部分文字列を置き換えたりするために使用されます。大文字と小文字を区別します

16.replaceAll(String regex,String replace) 指定された正規表現に一致するこの文字列のすべての部分文字列を指定された置換で置き換えます。 regex - この文字列に一致する正規表現、replacement - 一致する各単語を置換します。

17.trim() は文字列の両側のスペースを削除します。

18.toCharArray() は変換します。文字列を文字配列

19.concat()メソッドに追加し、この文字列に指定されたchar値が含まれる場合にのみ、文字列

20.contains()の末尾に部分文字列を追加します。シーケンス、true

21 を返します。compareTo() は、比較前後の 2 つの文字列の ASCII コードの差を返します。2 つの文字列の最初の文字が異なる場合、このメソッドは、その ASCII コードを返します。最初の文字。差分値。最初の文字が同じ場合、差分が見つかるまで次の文字を比較し、異なる文字の ASCII コードの差分値を返します。 2 つの文字列の長さが同じでなく、比較できる文字がまったく同じである場合は、2 つの文字列の長さの差が返されます。

例 1:

package li.normalclass.stringclass;
 
import java.util.Arrays;
 
public class TestString {
    public static void main(String[] args) {
        // 1.如何创建String对象
        String str = "北京天安门abc";
 
        // 2.如何使用String对象
        // 2.1最简单的方法
        System.out.println(str.length() );//8  注意是字符的个数，不是字节的个数
 
        //如果字符串为空返回 true，否则返回 false
        System.out.println(str.isEmpty());//false
 
        //jdk11新增的方法,如果给定的字符串为空或仅包含空格代码点，则此方法返回 true ，否则返回 false
        System.out.println(str.isBlank());//false
 
        //是否已括号内的字符串为开始
        System.out.println(str.startsWith("北京天"));//true
 
        // 是否已括号内的字符串为结束
        System.out.println(str.endsWith("c"));//true
 
         //生成一个新的字符串,字符串的英文字符全部变小写
        System.out.println(str.toLowerCase()); //北京天安门abc
 
        //生成一个新的字符串,字符串的英文字符全部变大写
        System.out.println(str.toUpperCase());//北京天安门ABC
 
        /*
        注意：String是不可变字符序列，上面的方法改变的只是新生成的字符串，这里重新输出str，依旧是原来的字符
         */
        System.out.println(str);//北京天安门abc
 
 
        //2.2根据索引找子串
        //charAt()方法返回指定索引位置的char值。索引范围为0~length()-1
        char c = str.charAt(3);//注意下标从0开始
        System.out.println(c);//安
 
        //str.substring(int startIndex);
        //子字符串的下标从索引开始
        System.out.println(str.substring(2));//天安门abc
 
        //substring(int startIndex，int endIndex);
        /*返回一个字符串，该字符串是此字符串的子字符串。
         子串开始于指定beginIndex并延伸到字符索引endIndex- 1
          因此，子串的长度为endIndex-beginIndex
         */
        System.out.println(str.substring(5,8));//abc
 
        // 2.3根据子串找索引
        //public int indexOf(int ch)返回指定字符第一次出现的字符串内的第一个索引
        int index = str.indexOf("abc");
        System.out.println(index);//5
 
        //indexOf(String str, int fromIndex)
        //返回指定子串的第一次出现的字符串中的索引，从指定的索引开始。
        System.out.println(str.indexOf("门", 2));//4
 
        //从后向前查询第一次遇到的指定字符串的索引位置，注意索引还是从前往后数起
        System.out.println(str.lastIndexOf("北"));//0
 
        // 2.4其他方法
       /* str.concat();
        str.trim();
        str.split();
        str.replace();
        str.replaceAll()等
        */
 
        //split(String regex)
        //split()方法:分割字符串,参数regex称为分割符,可以使用正则表达式来表示
        String str2 = "Java,HTML,MySQL,Spring,java,Java";
        String arr [] = str2.split("S");
        System.out.println(Arrays.toString(arr));//[Java,HTML,My, QL,, pring,java,Java]
 
        //replace() 方法用于在字符串中用一些字符替换另一些字符，或替换一个与正则表达式匹配的子串。区分大小写
        System.out.println(str2.replace("Java","javase"));//javase,HTML,MySQL,Spring,java,javase
 
        //public String replaceAll(String regex,String replacement)
        //用给定的替换替换与给定的regular expression匹配的此字符串的每个子字符串。
        //regex - 要匹配此字符串的正则表达式, replacement - 要替换每个匹配的字
        String str3 = "abc,adc,afffc,rty,acc";
        String str4 = str3.replaceAll("a...c","#");
        System.out.println(str4);//abc,adc,#,rty,acc
 
        //trim()去掉字符串两边的空格
        String str5 = "  rbg  ni     men   hao    ";
        System.out.println(str5.length());//27
        System.out.println(str5.trim());//去掉字符串两端的空格  "rbg  ni     men   hao"
        System.out.println(str5.trim().length());//21
 
        //toCharArray()
        char [] chArr = str.toCharArray();//str = "北京天安门abc"
        System.out.println(chArr);
        System.out.println(chArr[2]);//天
 
 
        //concat()方法，在字符串的末尾追加子串
        String str6 = "北京市";
        str6 = str6.concat("紫禁城").concat("故宫").concat("博物院");
        System.out.println(str6);//北京市紫禁城故宫博物院
        
        //contains() 当且仅当此字符串包含指定的char值序列时，返回true
        System.out.println( str6.contains("博物院"));//true
        
        /*compareTo()方法
        返回比较的前后两个字符串的ASCII码的差值，如果两个字符串首字母不同，则该方法返回首字母的ASCII码的差值
        如果首字符相同，则比较下一个字符，直到有不同的为止，返回该不同的字符的ASCII码差值。
        如果两个字符串不一样长，可以参与比较的字符又完全一样，则返回两个字符串的长度差值。
        返回为正数表示a1>a2, 返回为负数表示a1<a2, 返回为0表示a1==a2
         */
        String str1 = "jsdy";
        String str2 = "jsdr";
 
        System.out.println(str1.compareTo(str2));//7
        
    }
}

ログイン後にコピー

例 2: 等号と二重等号==

package li.normalclass.stringclass;
 
public class TestString2 {
    public static void main(String[] args) {
        //equals
        String str1 = new String ("jsdy");
        String str2 = new String ("jsdy");
        System.out.println(str1==str2);//false
        System.out.println(str1.equals(str2));//true
 
        String str3 = "jsdy";
        String str4 = "jsdy";
        System.out.println(str3==str4);//ture!!!
        System.out.println(str3.equals(str4));//true
 
        String str5 = new String ("jsdy");
        String str6 = "jsdy";
        System.out.println(str5==str6);//false
        System.out.println(str5.equals(str6));//true
        
         String str7 = null;//没有指向任何内容
        String str8 = new String("");
        String str9 = "";//指向一个空字符串
        System.out.println(str9.length());//0
        //System.out.println(str7.length())-->java.lang.NullPointerException
        System.out.println(str8==str9);//false
        System.out.println(str8.equals(str9));//true
 
    }
}

ログイン後にコピー

分析:

String str3 = "jsdy";
String str4 = "jsdy";
System.out.println(str3==str4);//ture!!!

ログイン後にコピー

リテラル値文字列を使用して文字を作成する, JVM はまず文字列プールに行き、「jsdy」オブジェクトが存在するかどうかを確認します。

存在しない場合は、文字列プールに「jsdy」オブジェクトを作成してから、「jsdy」を追加します" をプールに追加します。このオブジェクトの参照アドレスは、"jsdy" オブジェクトの参照 str3 に返されるため、str3 はプール内の文字列オブジェクト "jsdy" を指します。

それが存在する場合、オブジェクトは作成されず、プール内の「jsdy」が直接追加されます。「このオブジェクトのアドレスが返され、参照 str4 に割り当てられます。」 str3 と str4 はどちらも同じ文字列プール内の「jsdy」オブジェクトを指しているため、結果は true になります。

String str1 = new String ("jsdy");
String str2 = new String ("jsdy");
System.out.println(str1==str2);//false
System.out.println(str1.equals(str2));//true

ログイン後にコピー

new キーワードを使用して文字列オブジェクトを作成する場合、JVM はまず文字列プール内で文字列オブジェクト "jsdy" を検索します。 "jsdy" オブジェクトを作成するには、ヒープ内に直接 "jsdy" 文字列オブジェクトを作成し、ヒープ内の "jsdy" オブジェクトのアドレスを参照 str1 に返します。このようにして、str1 はヒープに作成された文字列オブジェクト。この "jsdy" 文字列オブジェクト;

そうでない場合は、まず文字列プールに "jsdy" 文字列オブジェクトを作成し、次にヒープに "jsdy" 文字列オブジェクトを作成します。ヒープの追加文字列内の「jsdy」文字列オブジェクトのアドレスが返され、str1 参照に割り当てられます。このようにして、str1 はヒープ内に作成された「jsdy」文字列オブジェクトを指します。 str2 は、ヒープ内に作成された別の「jsdy」文字列オブジェクトを指します。 str1 と str2 は異なるオブジェクトを指す 2 つの参照であり、結果は当然 false になります。

他も同様です。

例 3:

//concat()方法，在字符串的末尾追加子串
        String str6 = "北京市";
        str6 = str6.concat("紫禁城");
        str6 = str6.concat("故宫");
        str6 = str6.concat("博物院");
        System.out.println(str6);//北京市紫禁城故宫博物院

ログイン後にコピー

Javaでよく使われる文字列関連クラスの使い方

上に示すように:

采用字面值的方式创建一个字符串时，JVM首先会去字符串池中查找是否存在"北京"这个对象，如果不存在，则在字符串池中创建"北京"这个对象，然后将池中"北京"这个对象的引用地址返回给"北京"对象的引用str6。使用concat（）方法可以追加子字符串，但是String是不可变长序列，所以是实际上是在常量池重新创建了一个对象，并把追加的字符串连同原字符串一同赋值给新的对象，然后将新对象的引用地址返回给str6，这样str6就指向了一个新的地址空间。每次使用concat（）方法追加子串都会经历上述过程，str6的指向不断改变，最终会指向最后一次开辟的对象地址。

因此使用concat（）追加子串的方法效率无疑是很低的，那么有没有一种办法可以直接在创建的对象里添加子串呢？这就是我们要涉及到的StringBuilder类

2.理解String类源码

String类是一个final类，意味着该类不能有子类

String类底层是一个字符数组value。各种方法的操作其实都是对该数组的操作。

Javaでよく使われる文字列関連クラスの使い方

String类的equals（）方法其实就是比较底层的字符数组的各个元素是否相同，只要发现一个元素不同，就返回false，如果所有字符都相同就返回true。但是如果两个变量都指向了同一个字符数组，则直接返回true。

String类的concat（）方法是创建一个新的字符数组，存放原来字符数组和新加入的字符数组内容，然后以该新数组创建一个新的字符串。

JDK9时String类底层由char数组变为byte数组，节省空间。同时通过一个coder成员变量作为编码格式的标识，使用LATIN1还是UFT-16，这个是在String生成时自动的，如果字符串中都是能用LATIN1就能表示的是0，否则就是UFT-16。

Javaでよく使われる文字列関連クラスの使い方

3.使用StringBuilder类

StringBuffer和StringBuilder非常类似，均代表可变的字符序列。

这两个类都是抽象类AbstractStringBuilder的子类，方法几乎一模一样

两个类的主要区别是：

StringBuffer JDK1.0提供的类，线程安全，做线程同步检查，效率较低
StringBuilder JDK1.5提供的类，线程不安全，不做线程同步检查，因此效率较高。建议采用此类

StringBuilder常用函数：

append() 向字符串后追加一个子串
reverse() 倒置
delete() 删除从start（包含）到end（不包含）位置的字符, start 为0~length-1
length() 获取字符的长度
toString() 将StringBuffer转成String
replace() 从start到end之间的字符串替换成新字符串
insert（）在指定的偏移量位置插入值
indexOf() 从头开始查找某个字符串在源字符串中第一次出现的位置并返回
setCharAt() 设置指定索引位置的字符
charAt() 返回指定索引位置上的字符
substring() 从start(包含)位置截取字符串返回一个新的String，它包含此序列当前所包含字符的子序列

例子：

package li.normalclass.stringbuilder;
 
/*
    StringBuilder用得比较多的基本上就是这三个常见操作：
    1.创建对象
        StringBuilder builder = new StringBuilder("xxx");
    2.末尾追加字符串
        builder.append("yyy");
    3.转换为字符串
        String str = builder.toString()
        System.out.println(str)
 */
public class TestStringBuilder1 {
    public static void main(String[] args) {
        //创建StringBuilder对象
 
        /*
        创建Builder对象时，底层的数组大小实际为输入的字符串长度个数+16
         */
        StringBuilder builder = new StringBuilder("北京");
 
        //length是字符的个数，capacity是底层数组的长度
        System.out.println(builder.length()+"\t"+ builder.capacity());//2  （2+16=）18
 
        //操作StringBuilder对象
        //操作：字符串末尾增加
 
        builder.append("故宫博物院");
        System.out.println(builder.length()+"\t"+ builder.capacity());//7  18
 
        builder.append("墙角下的");
        //---->这里扩容了，扩容方法是：当前字符串长度*2+2，在这里既是18*2+2=38
        System.out.println(builder.length()+"\t"+ builder.capacity());//11 38
 
        builder.append("一只懒猫在睡觉觉");
        System.out.println(builder.length()+"\t"+ builder.capacity());//19 38
 
 
        //操作：字符串中间位置增加
        int i = builder.indexOf("下");//找到字符串的数组下标
        builder.insert(i,"一棵银杏树");//在下标前插入新的子串
        System.out.println(builder.length()+"\t"+ builder.capacity());//24 38
 
 
        //操作：字符串修改
        int i2 = builder.indexOf("银杏树");//找到字符串的数组下标
        builder.replace(i2,i2+3,"芒果树");//要替换的字符串的起始位置，结束位置，要替换的字符串 ：北京故宫博物院墙角一棵芒果树树下的一只懒猫在睡觉觉
 
        //操作：字符串删除
        builder.deleteCharAt(23);//参数为要删除的那个字符的索引下标  ：北京故宫博物院墙角一棵芒果树下的一只懒猫在睡觉
        builder.delete(0,7);//start并延伸到字符索引end - 1：墙角一棵芒果树下的一只懒猫在睡觉子串开始于指定
 
        //操作：字符串输出
        String str = builder.toString();//将StringBuilder转变为一个字符串
        System.out.println(str);//墙角一棵芒果树下的一只懒猫在睡觉
        System.out.println(builder.toString());//墙角一棵芒果树下的一只懒猫在睡觉
        System.out.println(builder);//墙角一棵芒果树下的一只懒猫在睡觉
        System.out.println(builder.reverse());//觉睡在猫懒只一的下树果芒棵一角墙
        System.out.println(builder);//觉睡在猫懒只一的下树果芒棵一角墙--->没有创建新的字符串对象
    }
}

ログイン後にコピー

注意实际开发过程中StringBuilder的使用场合：字符串的拼接（SQL语句）

StringBuilder用得比较多的基本上就是这三个常见操作：

//1.创建对象（String-->StringBuilder） 
        StringBuilder builder = new StringBuilder("xxx");
 
//2.末尾追加字符串
        builder.append("yyy");
 
//3.转换为字符串（StringBuilder--->String）
        String str = builder.toString()
        System.out.println(str);

ログイン後にコピー

4.StringBuilder类源码

StringBuilder的底层就是一个长度可以自动增长的字符数组（JDK9变成了字节数组）

StringBuilder类底层和String类一样，也是一个字符数组value，但不是final的。变量count表示的是底层字符数组的元素的真实个数，不是底层字符数组的长度。

默认数组的长度是16。也可以通过构造方法直接指定初始长度。length（）方法返回的是字符数组元素的真实个数，capacity（）返回的是底层数组的长度。

添加字符串时如果内存大小不够要扩容，扩容的默认策略是增加到原来长度的两倍再加2

快捷键Ctrl+Alt+向左箭头<·····可以实现跳转到刚刚浏览的那个文件的那行代码

例子1：StringBuilder构造函数

StringBuilder builder = new StringBuilder();
//StringBuilder 的无参构造初始容量为：16

ログイン後にコピー

Javaでよく使われる文字列関連クラスの使い方

例子2：new StringBuilder

//创建Builder对象时，底层的数组大小实际为输入的字符串长度个数+16
StringBuilder builder = new StringBuilder("故宫博物院");
System.out.println(builder.length()+"\t"+ builder.capacity());

ログイン後にコピー

Javaでよく使われる文字列関連クラスの使い方

例子3：toString

String str = builder.toString();
System.out.println(str);

ログイン後にコピー

将builder的字符转换为String字符串

Javaでよく使われる文字列関連クラスの使い方

例子4：append()

略。

总结

String：不可变字符序列

StringBuffer：可变字符序列，并且线程安全，但是效率低

StringBuilder：可变字符序列，线程不安全，但是效率高（一般用它）

以上がJavaでよく使われる文字列関連クラスの使い方の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。