25个常用Java String API速查以及案例实践

最新推荐文章于 2024-08-16 10:49:14 发布

ybqdren

最新推荐文章于 2024-08-16 10:49:14 发布

阅读量766

点赞数

分类专栏： Java 大学积累文章标签： java 字符串

本文链接：https://blog.csdn.net/qq_43795348/article/details/109058224

版权

大学积累同时被 2 个专栏收录

81 篇文章 0 订阅

订阅专栏

Java

39 篇文章 1 订阅

订阅专栏

一、常用api

1.length()

求字符串的长度

public int length() 返回此字符串的长度。长度等于字符串中的 Unicode code units数。

2.trim()

去掉前后空格

public String trim() 返回一个字符串，它的值是字符串，任何前导和尾随空格删除。

3.equals()

比较两个字符串是否“相等”，比较字符串的内容

public boolean equals(Object anObject)将此字符串与指定的对象比较。其结果是 true如果只有参数不 null是 String表示相同的字符序列对象。

4.equalslgnoreCase()

比较两个字符串是否“相等”，比较字符串中的内容，忽略大小写

public boolean equalsIgnoreCase(String anotherString)比较这 String到另一个 String，忽略问题的考虑。两个字符串被认为是相等的忽略的情况下，如果他们是相同的长度和相应的字符在两个字符串是相等的忽略的情况下。

5.toUpperCase()

转为大写

public String toUpperCase()

6.toLowerCase()

转为小写

public String toLowerCase()

7.concat()

等价于+，拼接

public String concat(String str)如果参数字符串的长度是0，那么这String对象返回。否则，一个String对象返回代表一个字符序列，是由这个String对象表示的字符序列拼接和字符序列的参数字符串表示。

8.contains()

是否包含xx

public boolean contains(CharSequence s)如果并且只有当此字符串包含指定的字符序列的字符串值，则返回真值。

9.toCharArray()

转为字符数组

public char[] toCharArray()将此字符串转换为一个新的字符数组。 
Returns: 
一种新分配的字符数组，其长度是该字符串的长度，其内容被初始化为包含由该字符串表示的字符序列。

10.charAt()

返回某个索引位置的字符

public char charAt(int index)返回char类型数组的指定位置索引。指数范围从 0到 length() - 1。第一序列的 char值在指数 0，在指数 1下，等等，作为数组索引。

11.intern()

把结果放到常量池中

public String intern()返回字符串对象的规范表示形式。

12.startWith()

判断字符串是否以xx开头

public boolean startsWith(String prefix,
                          int toffset)如果此字符串中的指定索引处开始的子字符串从指定的前缀。 

---------------------------

public boolean startsWith(String prefix)测试这个字符串是否以指定的前缀开始。

13.endWith()

判断字符串是否以xx结尾

public boolean endsWith(String suffix)测试如果这个字符串以指定的结束后缀。

14.indexOf()

查找某个字符，子串在当前字符串的索引，从左往右查找

public int indexOf(int ch)返回在指定字符的第一个发生的字符串中的索引。

------
public int indexOf(int ch,
                   int fromIndex)返回在指定字符的第一个发生的字符串中的索引，在指定的索引处开始搜索。 

-----

public int indexOf(String str)返回指数在这个字符串指定的子字符串中第一个出现的。 

--

public int indexOf(String str,
                   int fromIndex)返回此字符串的指定子字符串中第一个出现在索引中，从指定索引处开始。

15.lastIndexOf()

查找某个字符，子串在当前字符串的索引，从右往左查找

public int lastIndexOf(int ch)返回在指定字符的最后一个发生的字符串内的索引 

----

public int lastIndexOf(int ch,
                       int fromIndex)返回在指定字符的最后一个发生的字符串内的索引，在指定的索引处搜索向后开始。

16.substring()

从当前字符串截取一个子串

public String substring(int beginIndex)返回一个字符串，这个字符串的子串。子字符串从指定索引处的字符和延伸到这个字符串的末尾。 


----

public String substring(int beginIndex,
                        int endIndex)返回一个字符串，这个字符串的子串。子字符串从指定的 beginIndex延伸在指数 endIndex - 1特征。这样子串的长度是 endIndex-beginIndex。

17.matches()

判断当前字符串是否匹配xx规则

public boolean matches(String regex)告诉是否这个字符串匹配给定 regular expression。 
这str.matches(正则表达式)产生完全相同的结果的表达形式的方法调用

Pattern. matches(regex, str) 
Parameters: 
regex -正则表达式的字符串相匹配

18.replace()

把当前字符串中某些字符替换为另外一些字符，不支持正则

public String replace(char oldChar,
                      char newChar)返回从字符串中替换所有出现在 newChar oldChar结果字符串。 
如果字符oldChar不在这个String对象表示的字符序列发生，然后参考这个String对象返回。否则，一个String对象返回代表一个字符序列相同的String对象表示的字符序列，惟oldChar每天发生的newChar发生取代。


---

public String replace(CharSequence target,
                      CharSequence replacement)每个子串替换该字符串指定的文本替换序列靶序列匹配的文字。更换从字符串的开始到结束

19.replaceFirst()

把当前字符串中首次出现的某些字符替换为另一个一些字符，支持正则

public String replaceFirst(String regex,
                           String replacement)代替这个字符串的替换，给 regular expression匹配第一个字符串。

20.replaceAll()

把当前字符串中所有出现的某些字符串替换为另一个一些字符串，支持正则

public String replaceAll(String regex,
                         String replacement)每个子串替换该字符串的给予更换，给 regular expression比赛。 
这str.replaceAll(正则表达式,取代)产生完全相同的结果的表达形式的方法调用

Pattern.compile(regex).matcher(str).replaceAll(repl) 
注意，反斜杠（\）和美元符号（$）在替换字符串中可能导致的结果是不同的比如果它被视为文字的替换字符串；看到Matcher.replaceAll。使用Matcher.quoteReplacement(java.lang.String)抑制这些字符的特殊意义，如果需要的话。

Parameters: 
regex -正则表达式的字符串相匹配 
replacement -被取代为每个匹配的字符串 
Returns: 
由此产生的 String 
Throws: 
PatternSyntaxException如果正则表达式的语法是无效的

21.split()

把当前字符串按照某个规则进行拆分

public String[] split(String regex)将此字符串在给定的 regular expression比赛。 
这种方法是通过调用两split如果论证方法与给定的表达和零的极限参数。因此不包括在结果数组中的尾随空字符串。

例如，字符串"boo:and:foo"，得到以下结果与这些表达式：

Regex Result 
: { "boo", "and", "foo" } 
o { "b", "", ":and:f" } 

Parameters: 
regex -定义的正则表达式 
Returns: 
通过分裂这个字符串来计算给定正则表达式的匹配的字符串数组 
Throws: 
PatternSyntaxException如果正则表达式的语法是无效的 

----

public String[] split(String regex)将此字符串在给定的 regular expression比赛。 
这种方法是通过调用两split如果论证方法与给定的表达和零的极限参数。因此不包括在结果数组中的尾随空字符串。

例如，字符串"boo:and:foo"，得到以下结果与这些表达式：

Regex Result 
: { "boo", "and", "foo" } 
o { "b", "", ":and:f" } 

Parameters: 
regex -定义的正则表达式 
Returns: 
通过分裂这个字符串来计算给定正则表达式的匹配的字符串数组 
Throws: 
PatternSyntaxException如果正则表达式的语法是无效的

22.isEmpty()

判断当前字符串是否为空字符串

public boolean isEmpty()返回 true如果，如果， length()是 0。 
Returns: 
true如果 length()是 0，否则 false

23.getBytes()

把当前字符串按照某种字符编码进行编码为字节序列

public byte[] getBytes()这 String编码成一个序列使用平台的默认字符集字节，结果存放到一个新的字节数组。 
行为的这种方法在该字符串不能在默认字符集编码不详。的CharsetEncoder班时应采用在编码过程中需要更多的控制。

Returns: 
生成的字节数组 

----

public byte[] getBytes(Charset charset)这 String编码为一个字节序列使用给定的 charset，结果存放到一个新的字节数组。 
这种方法总是会替换格式不正确的输入，无法映射的字符序列，该字符集的默认置换的字节数组。的CharsetEncoder班时应采用在编码过程中需要更多的控制。

Parameters: 
charset - Charset用来编码 String 
Returns: 
生成的字节数组 

----

@Deprecated
public void getBytes(int srcBegin,
                                 int srcEnd,
                                 byte[] dst,
                                 int dstBegin)过时的。  这种方法不正确地将字符转换为字节。作为 JDK 1.1，这样的首选方式是通过getBytes()方法，它使用平台的默认字符集。 
将此字符串的字符复制到目标字节数组中。每个字节接收相应字符的8个低阶位。每个字符的八个高阶位不被复制，不以任何方式参与传输。 
要复制的第一个字符是在指数srcBegin；要复制的最后一个字符是在指数srcEnd-1。要复制的字符数srcEnd-srcBegin。字符，转换成字节，复制到dst子数组的索引dstBegin开始和结束索引：

     dstbegin + (srcEnd-srcBegin) - 1
 Parameters: 
srcBegin指标字符串中第一个字符复制 
srcEnd -在字符串中的最后一个字符复制后指数 
dst -目标数组 
dstBegin的起始偏移在目标阵列 
Throws: 
IndexOutOfBoundsException -如果任何以下是真实的： 
srcBegin是负的 
srcBegin大于srcEnd 
srcEnd大于此字符串的长度 
dstBegin是负的 
dstBegin+(srcEnd-srcBegin)大于dst.length 

---

public byte[] getBytes(String charsetName)
                throws UnsupportedEncodingException这 String编码成一个序列使用指定的字符的字节，并将结果存储到一个新的字节数组。 
行为的这种方法在该字符串不能在给定的字符集编码不详。的CharsetEncoder班时应采用在编码过程中需要更多的控制。

Parameters: 
charsetName -支持的 charset名称 
Returns: 
生成的字节数组 
Throws: 
UnsupportedEncodingException -如果指定的字符集不支持

24.String(byte[]…)

把字节序列按照某种字符编码进行解码为字符

String(byte[] bytes)  通过使用平台的默认字符集解码指定的字节数组构造了一个新的 String。  
String(byte[] bytes, Charset charset)  通过使用指定的 charset解码指定的字节数组构造了一个新的 String。

25.String(char[]…)

把字符数组重新构建为一个字符串

String(char[] value)  分配一个新的 String，它代表了目前包含在字符数组参数字符序列。  
String(char[] value, int offset, int count)  分配一个包含字符与字符数组数组参数的新 String。

二、应用与实践

1.去掉字符串前后的空格

"  hello world !  "

温知识：

在Java中，字符小于32的字符（32即为空格），都叫做空白符，包括tab制表符

方法一

把str转成字符数组
遍历数组，找出第一个非空的字符的startIndex和最后一个非空字符的endIndex
用这个数组[startIndex,endIndex]重新构建一个字符串

    public static String trim1(String str){
        char[] array = str.toCharArray();

        int startIndex = 0;
        for(int i=0;i<array.length;i++){
            if(array[i] <= ' '){
                startIndex++; 
            }else{
                break;
            }
        }

        //找出endIndex
        int endIndex = str.length()-1;
        for(int i= array.length-1;i>=0;i--){
            if(array[i] <= ' '){
                endIndex--; 
            }else{
                break;
            }
        }

        String result = new String(array,startIndex,endIndex-startIndex-1);
        return result;
    }

方法二

    public static String trim2(String str){
        char[] array = str.toCharArray();
  
        int startIndex = 0;
        for(int i=0;i<array.length;i++){
            if(array[i] <= ' '){
                startIndex++; 
            }else{
                break;
            }
        }

        //找出endIndex
        int endIndex = str.length()-1;
        for(int i= array.length-1;i>=0;i--){
            if(array[i] <= ' '){
                endIndex--; 
            }else{
                break;
            }
        }

        return str.substring(startIndex,endIndex-1);
    }

方法三（不是很完美）

把开头和结尾的空格截取调用
这个方法有问题，要判断很多的空白符

    public static String trim3(String str){
        while(str.startsWith(" ")){
            str = str.substring(1);
        }

        while(str.endsWith(" ")){
            str = str.substring(0,str.length()-1);
        }

        return str;
    }

方法四

把str前面的空白符替换掉 -> 使用正则

    public static String trim4(String str){
        String result = str.replaceAll("(^\\s+)|(\\s+$)","");
        return result;
    }

2.将字符串指定部分进行反转

        String str = "abcjddhdhd"; // 反转为abdhddjchd
        str = reverse1(str,2,7);

方法一

既需要管位置，又要管理次数

1.把str字符串分为三个部分：左 + 中 + 右，中间存放要进行反转的部分
2.反转middle 在进行反转之前，先对中间部分进行数组转换
拼接

    public static String reverse1(String str,int startIndex,int endIndex){
        String leftString = str.substring(0,startIndex);
        String middleString = str.substring(startIndex,endIndex+1);
        System.out.println("middleString -> "+middleString);
        String rightString = str.substring(endIndex-1,str.length());

        // 对中间部分进行交换
        char[] middleCharArray = middleString.toCharArray();
        for(int i=0;i<middleCharArray.length/2;i++){
            char temp = middleCharArray[i];
            middleCharArray[i] = middleCharArray[middleCharArray.length-i-1];
            middleCharArray[middleCharArray.length-i-1] = temp;
        }

        String result = new String(middleCharArray);
        System.out.println("result -> "+result);
        return leftString+result+rightString;
    }

注意：

此处在遍历数组时需要注意，只需要遍历数组的一半，如果将数组从头遍历到尾，那就意味着交换的字符又重新交换回去，在结果上看起来和原字符没有任何差别

方法二

只管次数

    public static String reverse2(String str,int startIndex,int endIndex){
        char[] charArray = str.toCharArray();
        for(int i=startIndex,j=endIndex;i<j;i++,j--){
            char temp = charArray[i];
            charArray[i] = charArray[j];
            charArray[j] = temp;
        }
        String result = new String(charArray);
        return result;
    }

3.获取一个字符串在拎另一个字符串中出现的次数

方法一

查找+截取

    public static int count(String strString,String subString){
        int count = 0;
        while(strString.indexOf(subString) != -1){
            int index = strString.indexOf(subString);
            strString = strString.substring(index+subString.length(),strString.length());
            count++;
        }
        return count;
    }

方法二

替换

    public static int count2(String strString,String subString){
        int count = 0;
        while(strString.contains(subString)){
            strString = strString.replaceFirst(subString,"");
            count++;
        }
        return count;
    }

注意：

在进行替换时应该使用replacefirst()，而非replace()。后者会一次性将指定字符进行全部替换，二前者一次只替换一次，故统计出现次数应该使用前者。

有关replace()、replaceAll()、replacefirst()三者之间的更多详情可以查看：[replace()、replaceFirst()和replaceAll()的区别](https://www.cnblogs.com/klqmg/p/6230047.html)