Java에서 일반적으로 사용되는 문자열 관련 클래스를 사용하는 방법

문자열 관련 클래스

String, StringBuilder 및 StringBuffer 클래스는 세 가지 문자열 관련 클래스입니다.

String 클래스는 변경할 수 없는 문자 시퀀스를 나타내고, StringBuilder 클래스와 StringBuffer 클래스는 변경 가능한 문자 시퀀스를 나타냅니다.

이 세 가지 항목의 자세한 사용법은 필기시험이나 면접은 물론이고 실제 개발에서도 자주 사용됩니다.

1.String 클래스 사용

String의 일반적인 메서드:

1.isEmpty()는 문자열이 비어 있으면 true를 반환하고, 그렇지 않으면 false를 반환합니다.

2.length()는 문자열의 길이를 계산합니다

3. isBlank( ) 이 메소드는 주어진 문자열이 비어 있거나 공백 코드 포인트만 포함하는 경우 true를 반환하고, 그렇지 않으면 false를 반환합니다.

4.startsWith() 문자열이 대괄호로 시작하는지 여부

5.endsWith() 대괄호로 시작하는지 여부 ends 내부의 문자열

6.toLowerCase()는 새로운 문자열을 생성하며, 문자열의 영문자는 모두 소문자입니다

7.toUpperCase()는 새로운 문자열을 생성하고, 문자열의 영문자는 모두 대문자입니다

8 .charAt()는 지정된 인덱스 위치의 char 값을 반환합니다. 인덱스 범위는 0~length()-1

9입니다.substring(int startIndex) 하위 문자열은 인덱스

10에서 시작합니다.substring(int startIndex, int endIndex) 이 문자열 하위 문자열의 인덱스인 문자열을 반환합니다.

하위 문자열은 지정된 BeginIndex에서 시작하여 문자 인덱스까지 확장됩니다. endIndex- 1

11.public int indexOf(int ch) 지정된 문자가 처음 나타나는 문자열 내 첫 번째 인덱스를 반환합니다.

12.indexOf(String str , int fromIndex) 지정된 인덱스부터 시작하여 지정된 하위 문자열이 처음 나타나는 문자열의 인덱스를 반환합니다.

13.lastIndexOf 처음 만난 지정된 문자열의 인덱스 위치를 뒤에서 앞으로 쿼리합니다. 참고 인덱스는 여전히 유지됩니다. 앞에서 뒤로 계산

14.split() 메서드: 문자열을 분할합니다. 매개변수 regex를 분할자라고 하며 정규 표현식으로 표현할 수 있습니다.

15.replace()는 문자열의 일부 문자를 사용하는 데 사용됩니다. 다른 문자를 사용하거나 정규식과 일치하는 하위 문자열을 바꾸세요. 대소문자 구분

16.replaceAll(String regex,String replacement) 주어진 정규 표현식과 일치하는 이 문자열의 모든 하위 문자열을 지정된 대체 문자열로 바꿉니다. regex - 이 문자열과 일치하는 정규식, 교체 - 일치하는 각 단어를 대체합니다.

17.trim()은 문자열 양쪽의 공백을 제거합니다.

18.toCharArray()는 문자열을 문자 배열로 변환합니다.

19. concat() 메서드는 문자열 끝에 하위 문자열을 추가합니다.

20.contains()는 이 문자열에 지정된 문자 값이 포함된 경우에만 true를 반환합니다. 시퀀스

21.compareTo()는 전후 비교를 반환합니다. 차이점 두 문자열의 ASCII 코드에서 두 문자열의 첫 번째 문자가 다른 경우 이 메서드는 첫 번째 문자의 ASCII 코드 차이를 반환합니다. 두 문자가 다를 때까지 다음 문자를 비교합니다. . 다른 문자의 ASCII 코드 차이를 반환합니다. 두 문자열의 길이가 동일하지 않고 비교할 수 있는 문자가 정확히 동일한 경우 두 문자열의 길이 차이가 반환됩니다.

예제 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은 힙에 생성된 "jsdy" 문자열 개체를 가리킵니다. str2는 힙에 생성된 또 다른 "jsdy" 문자열 개체를 가리킵니다. str1과 str2는 서로 다른 객체를 가리키는 두 개의 참조이며 결과는 물론 false입니다.

다른 것도 마찬가지예요.

예 3:

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

위에 표시된 대로:

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

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

2.理解String类源码

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

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

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

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

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

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

例子2：new StringBuilder

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

例子3：toString

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

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

例子4：append()

略。

总结

String：不可变字符序列

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

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

위 내용은 Java에서 일반적으로 사용되는 문자열 관련 클래스를 사용하는 방법의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!