String类的方法整理

最新推荐文章于 2024-08-29 18:44:48 发布

ZL_do_it

最新推荐文章于 2024-08-29 18:44:48 发布

阅读量233

点赞数 1

分类专栏：笔记文章标签： java 字符串其他

本文链接：https://blog.csdn.net/ZL_do_it/article/details/105688856

版权

笔记专栏收录该内容

2 篇文章 0 订阅

订阅专栏

String类的方法整理

String类表示字符串。

Java程序中的所有字符串文字（例如“abc”）都实现为此类的实例。
字符串的值是不变的（常量），它们的值在创建后无法更改。但是引用变量是可以改变的。
字符串可以看做是一个长度固定的有序字符序列，每个组成的字符编有索引，从0开始。

构造方法

在String类中定义了许多的构造方法

String（）

初始化新创建的String对象，使其表示空字符序列。

初始化但不赋值

例：
```
String s；
//或
String s = new String（）；
```
String(byte[] bytes)

通过使用平台的默认字符集解码指定的字节子数组来构造新的 String 。

参数： bytes：要解码为字符的 byte
```
//将字节数组转化为字符串
byte[] bytes = {97,98,99,100};
String s = new String(bytes);
System.out.println(s);
//输出abcd
```
String(byte[] bytes, int offset, int length)

通过使用平台的默认字符集解码指定的字节子阵列来构造新的 String 。

参数： bytes：要解码为字符的 byte
offset：要解码的第一个 byte 的索引
length：要解码的 byte 数的长度
```
//把字节数组的一部分转化为字符串
byte[] bytes = {97,98,99,100};
String s = new String(bytes,1,3);
System.out.println(s);
//输出bcd
```
String(byte[] bytes, int offset, int length, String charsetName)

通过使用指定的字符集解码指定的字节子 String构造新的 String。

参数：charsetName：要用来解码的字符集名称
String(byte[] bytes, int offset, int length, Charset charset)

通过使用指定的charset解码指定的字节子String构造新的String 。
String(byte[] bytes, String charsetName)

将指定的字节数组bytes以charset的编码格式进行解码来构造新的String 。
String(byte[] bytes, Charset charset)

将指定的字节数组bytes以charset的编码格式进行解码来构造新的String 。

String(char[] value)

分配新的 String，使其表示当前包含在字符数组参数中的字符序列。

//将字符数组转化为字符串
char[] value = {'a','b','c'};
String s = new String(value);
System.out.println(s);
//输出abc

String(char[] value, int offset, int count)

分配一个新的 String，其中包含字符数组参数的子数组中的字符。

//将字符数组子数组中的字符转化为字符串
char[] value = {'a','b','c'};
String s = new String(value,1,2);
System.out.println(s);
//输出bc

String(int[] codePoints, int offset, int count)

分配新的 String，其中包含 Unicode code point数组参数的子数组中的字符。
String(String original)

初始化新创建的String对象，使其表示与参数相同的字符序列; 换句话说，新创建的字符串是参数字符串的副本。

方法

Sting类中定义了很多的方法，类似于工具，可以方便我们去调用，下面就对一些主要的方法进行整理。

charAt（int index）

返回指定索引处的char值。

指数范围为0至length() - 1 。序列的第一个char值位于索引0 ，下一个位于索引1 ，依此类推，就像数组索引一样。

此方法返回char类型

参数：

index：char的索引下标

代码：
```
 String str = "abc";
 System.out.println(str.charAt(1));
//输出b
```
codePointAt(int index)

返回指定索引处的字符（Unicode代码点）.

索引引用char值（Unicode代码单位），范围从0到length() - 1.

index：char的索引下标

此方法返回int类型

代码：
```
 String str = "abc";
 System.out.println(str.codePointAt(1));
 //输出98
```
str字符串索引1处的字符为b，b在Unicode中的编码格式为98，所以输出98.
codePointBefore(int index)

返回指定索引之前的字符（Unicode代码点）。

索引引用char值（Unicode代码单位），范围从1到length()。

index：应返回的代码点后面的索引

此方法返回int类型

代码：
```
 String str = "abc";
 System.out.println(str.codePointBefore(1));
//输出97
```
与codePointAt()方法不同的地方在于，codePointBefore()是返回指定索引之前的字符，因此str字符串索引1之前的字符为a，而a在Unicode中的编码格式为97，所以输出97.
codePointCount(int beginIndex, int endIndex)

返回此String的指定文本范围内的Unicode代码点数。

此方法返回int类型

文本范围从指定的beginIndex开始，并延伸至char，索引号为endIndex - 1 。因此，文本范围的长度是endIndex-beginIndex 。

参数：

beginIndex：文本范围的第一个 char的索引。

endIndex ：文本范围的最后 char之后的索引。

代码：
```
String str = "abcdefg";
       System.out.println(str.codePointCount(1,4));
//输出3
```
compareTo(String anotherString)

按字典顺序比较两个字符串，比较基于字符串中每个字符的Unicode值。

此方法返回int类型
- 两个字符串有一个或多个索引位置具有不同的字符，则令k为最小的索引，此时返回this.charAt(k)-anotherString.chaAr(k)
```
String str1 = "abcdefg";
String str2 = "acdfesc";
       System.out.println(str1.compareTo(str2));
//输出-1
```
  因为不同字符处的最小索引为1，因此返回b的Unicode代码点减去c的Unicode代码点，结果为-1.
- 两个字符串没有不同的索引位置，但长度不同时，返回 this.length() - anotherString.length()
```
String str1 = "abcdefg";
String str2 = "abcd";
System.out.println(str1.compareTo(str2));
//输出3
```
- 如果两个字符串相等，则返回0
```
String str1 = "abcdefg";
String str2 = "abcdefg";
System.out.println(str1.compareTo(str2));
//输出0
```
compareToIgnoreCase(String str)

按字典顺序比较两个字符串，忽略大小写差异。

此方法返回int类型

此方法与compareTo一样，区别就在于此方法忽略了字符的大小写差异。
```
String str1 = "abcd";
String str2 = "ABCD";
System.out.println(str1.compareTo(str2));
//此时输出的是0
```
concat(String str)

将指定的字符串连接到此字符串的末尾。

此方法返回String类型
- 如果参数字符串的长度为0 ，则返回此String对象。
```
String str1 = "to";
String str2 = "";
System.out.println(str1.concat(str2));
//输出to
```
- 否则，返回一个String对象，该对象表示一个字符序列，该字符序列是由此String对象表示的字符序列和由参数字符串表示的字符序列的串联。
```
String str1 = "to";
String str2 = "day";
System.out.println(str1.concat(str2));
//输出today
```

contains(CharSequence s)

当且仅当此字符串包含指定的char值序列时，才返回true。

此方法返回boolean类型

String str = "today";
System.out.println(str.contains("day"));
//输出true
String str = "today";
System.out.println(str.contains("noon"));
//输出false

contentEquals()方法

contentEquals(CharSequence cs)：

当且仅当此String表示与指定序列相同的char值序列时，结果为true 。

此方法返回boolean类型
```
String str = "today";
System.out.println(str.contentEquals("day"));
//输出false
String str = "today";
System.out.println(str.contentEquals("today"));
//输出true
```
contentEquals(StringBuffer sb)：

将此字符串与指定的StringBuffer比较。如字符串与指定StringBuffer表示相同的字符序列，则返回 true；否则返回 false。

copyValueOf()方法

copyValueOf(char[] data)

返回 char数组参数的字符串表示形式。

char[] value = {'好','好','学','习'};
String s = "";
System.out.println(s.copyValueOf(value));
//输出 好好学习

copyValueOf(char[] data, int offset, int count)

返回 char数组参数的特定子数组的字符串表示形式。

char[] value = {'好','好','学','习'};
String s = "";
System.out.println(s.copyValueOf(value,2,2));
//输出 学习

endsWith(String suffix)

测试此字符串是否以指定的后缀结尾。

此方法返回boolean类型

参数：

suffix：后缀
```
String str = "today";
System.out.println(str.endsWith("y"));
//输出true
```

equals(Object anObject)

将此字符串与指定的对象进行比较。如果相同则返回true。

此方法返回boolean类型

String str = "today";
String str1 = "today";
System.out.println(str.equals(str1));
//输出true
String str = "today";
String str1 = "tonight";
System.out.println(str.equals(str1));
//输出false

equalsIgnoreCase(String anotherString)

将此String与另一个String比较，忽略了大小写。

此方法返回boolean类型

如果两个字符串相应字符相同且长度一样，则返回true
```
String str = "today";
String str1 = "Today";
System.out.println(str.equalsIgnoreCase(str1));
//输出true
```
getBytes方法
- getBytes()：
  
  使用平台的默认字符集将此String编码为字节序列，将结果存储到新的字节数组中。
- getBytes(Charset charset)：
  
  使用给定的charset将此String编码为字节序列，将结果存储到新的字节数组中。
  
  注：如果不支持指定的charset，抛出UnsupportedEncodingException 异常
```
String str = "today";
System.out.println(str.getBytes());
System.out.println(str.getBytes("UTF-8"));
//输出[B@7c30a502
//    [B@49e4cb85
```
- getBytes(String charsetName)：
  
  使用命名的字符集将此 String编码为字节序列，将结果存储到新的字节数组中。
getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)

将此字符串中的字符复制到目标字符数组中。

参数：

srcBegin：字符串中要复制的起始字符索引

srcEnd：字符串中要复制的最后字符的下一个索引

dst：目标字符数组

dstBegin：目标字符数组的起始偏移量
```
String str = "好好学习，天天向上";
char[] dst = new char[10];
str.getChars(5,9,dst,0);
System.out.println(dst);
//输出 天天向上
```
注：不能超出索引范围，否者会产生IndexOutOfBoundsException 异常
hashCode()

返回此字符串的哈希码。返回值为int类型。
```
String s = "好好学习，天天向上";
System.out.println(s.hashCode());
//输出 236901163
```
String对象的哈希码计算为：
```
s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
```
注：使用int算术，其中s[i]是字符串的第i个字符， n是字符串的长度， ^表示取幂。（空字符串的哈希值为零。）
indexOf方法
- indexOf(int ch)
  
  返回指定字符第一次出现的字符串中的索引。
  
  参数：
  
  ch：字符（Unicode代码点）。
```
String str = "好好学习，天天向上";
System.out.println(str.indexOf("天"));
//输出5
//字符串中没有出现此类字符，则返回-1
String str = "好好学习，天天向上";
System.out.println(str.indexOf("你"));
//输出-1
```
- indexOf(int ch, int fromIndex)
  
  返回指定字符第一次出现的此字符串中的索引，从指定索引处开始搜索。
  
  参数：
  
  ch - 字符（Unicode代码点）。
  
  fromIndex - 从中开始搜索的索引。
```
String str = "好好学习，天天向上";
System.out.println(str.indexOf("天",6));
//输出6
//字符串中没有出现此类字符，则返回-1
```
  注：fromIndex的价值没有限制。如果它是负数，它具有与零相同的效果：可以搜索整个字符串。如果它大于此字符串的长度，则它具有与等于此字符串长度相同的效果：返回-1 。所有索引都以char值（Unicode代码单位）指定。
- indexOf(String str)
  
  返回指定子字符串第一次出现的字符串中的索引。
  
  参数：
  
  str - 要搜索的子字符串。
```
String str = "好好学习，天天向上";
System.out.println(str.indexOf("天天向上"));
//输出5
//如果字符串中没有出现此子字符串，则返回-1
```
- indexOf(String str, int fromIndex)
  
  从指定的索引处开始，返回指定子字符串第一次出现的字符串中的索引。
```
String str = "好好学习，天天向上";
System.out.println(str.indexOf("天天向上",6));
//输出-1
```
lastIndexOf方法

与indexOf方法不同的是，此方法是从后往前搜索的。
- lastIndexOf(int ch)
  
  返回指定字符最后一次出现的字符串中的索引。
```
String str = "好好学习，天天向上";
System.out.println(str.lastIndexOf("天"));
//输出6
```
- lastIndexOf(int ch, int fromIndex)
  
  返回指定字符最后一次出现的字符串中的索引，从指定的索引开始向前搜索。
```
String str = "好好学习，天天向上";
System.out.println(str.lastIndexOf("天",4));
//输出-1
```
- lastIndexOf(String str)
  
  返回指定子字符串最后一次出现的字符串中的索引。
```
String str = "好好学习，天天向上";
System.out.println(str.lastIndexOf("天天向上"));
//输出8
```
- lastIndexOf(String str, int fromIndex)
  
  返回指定子字符串最后一次出现的字符串中的索引，从指定索引开始向前搜索。
```
String str = "好好学习，天天向上";
System.out.println(str.lastIndexOf("天天向上",4));
//输出-1
```
intern()

返回字符串对象的规范表示。

返回与此字符串具有相同内容的字符串，但保证来自唯一字符串池。

对于任何两个字符串s和t ， s.intern() == t.intern()是true当且仅当s.equals(t)为true 。
```
String str = "好好学习，天天向上";
System.out.println(str.intern());
//输出 好好学习，天天向上
```

isBlank()

如果字符串为空或仅包含 white space个代码点，则返回 true ，否则 false 。

String str = "";
String str1 = "好好学习"
System.out.println(str.isBlank());
//输出true
System.out.println(str1.isBlank());
//输出false

isEmpty()

当且仅当length()是0，返回true，否者返回false。
join(CharSequence delimiter, CharSequence… elements)

返回由CharSequence elements的副本组成的新String，该副本与指定的delimiter的副本连接在一起。

参数：

delimiter - 用于分隔每个元素的分隔符
elements - 要连接在一起的元素。
```
String str = String.join(" ","Are","you","ok","?");
System.out.println(str);
//输出 Are you ok?
```
注：如果元素为null，则添加"null" 。
length()

返回此字符串的长度。
matches(String regex)

判断此字符串是否与给定的regular expression匹配。

参数：

regex - 要与此字符串匹配的正则表达式
```
String str = "Are you ok ?";
System.out.println(str.matches("(.*)(you)(.*)(?)"));
//输出true
```
regionMatches方法
- regionMatches(int toffset, String other, int ooffset, int len)
  
  测试两个字符串区域是否相等。返回boolean类型
  
  将此String对象的子字符串与参数other的子字符串进行比较。如果这些子串表示相同的字符序列，则结果为true。要比较的此String对象的子字符串从索引toffset开始，长度为len 。要比较的其他子串从索引ooffset开始，长度为len 。
  
  参数：
  
  toffset - 此字符串 toffset区域的起始偏移量。
  other - 字符串参数。
  ooffset - 字符串参数 ooffset区域的起始偏移量。
  len - 要比较的字符数。
```
String str = "abcd";
String other = "Abcd";
System.out.println(str.regionMatches(1,other,1,3));
//输出true
```
  当且仅当至少满足下列条件之一时，结果为false ：
  - toffset是否定的。
    ooffset是否定的。
    toffset+len大于此String对象的长度。
    ooffset+len大于另一个参数的长度。
    有一些非负整数k小于len ，使得： this.charAt(toffset + k ) != other.charAt(ooffset + k )
- regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)
  
  将此String对象的子字符串与参数other的子字符串进行比较。如果这些子串表示相同的字符序列，则结果为true ，当且仅当ignoreCase为true时，忽略大小写。
repeat(int count)

返回一个字符串，其值为此字符串的串联重复count次。

返回String类型

如果此字符串为空或count为零，则返回空字符串。

如果 count为负数，产生IllegalArgumentException异常
```
String str = "abcd";
System.out.println(str.repeat(3));
//输出abcdabcdabcd
```
replace方法
- replace(char oldChar, char newChar)
  
  将此字符串中的oldChar字符替换为newChar字符，返回新的字符串。
  
  参数：
  
  oldChar - 老字符。
  newChar - 新角色。
```
String str = "abcd";
System.out.println(str.replace('b','B'));
//输出aBcd
```
- replace(CharSequence target, CharSequence replacement)
  
  将此字符串中与文字目标序列匹配的每个子字符串替换为指定的文字替换序列。替换从字符串的开头到结尾，例如，在字符串“aaa”中将“aa”替换为“b”将导致“ba”而不是“ab”。
  
  参数：
  
  target - 要替换的char值序列
  replacement - char值的替换序列
```
String str = "好好学习，天天向上";
System.out.println(str.replace("天天向上","出人头地"));
//输出 好好学习，出人头地
```
replaceAll(String regex, String replacement)

使用给定的参数 replacement 替换字符串所有匹配给定的正则表达式的子字符串。返回String类型

参数：

regex - 要与此字符串匹配的正则表达式
replacement - 要替换每个匹配项的字符串
```
String str = "好好学习,天天向上";
System.out.println(str.replaceAll("(,)(.*)",",出人头地"));
//输出 好好学习,出人头地
```

replaceFirst(String regex, String replacement)

使用给定的参数 replacement 替换字符串第一个匹配给定的正则表达式的子字符串。

String str = "好好学习,天天向上,锄禾日当午,汗滴禾下土";
System.out.println(str.replaceAll("(,)(.*)",",出人头地"));
//输出 好好学习,出人头地

split方法

split(String regex)

将此字符串拆分为给定regex正则表达式的匹配项。

返回String类型的数组

String str = "boo:and:foo";
String[] s = str.split(":");
for (int i = 0;i<s.length;i++){
    System.out.print(s[i]+" ");
}
//输出boo and foo

split(String regex, int limit)

将此字符串拆分为给定regex正则表达式的匹配项。

返回String类型的数组

参数：

limit：被分割的块数，但是当limit小于等于0或者大于最大分割块数，都会尽可能多的分割。

String str = "a:b:c:d:e:f:g";
String[] s1 = str.split(":",-1);
String[] s2 = str.split(":",5);
String[] s3 = str.split(":",9);
for (int i = 0;i<s1.length;i++){
     System.out.print(s1[i]+" ");
}
//输出a b c d e f g
for (int i = 0;i<s2.length;i++){
     System.out.print(s2[i]+" ");
 }
//输出a b c d e:f:g
for (int i = 0;i<s3.length;i++){
     System.out.print(s3[i]+" ");
}
//输出a b c d e f g

注：如果表达式与输入的任何部分都不匹配，那么结果数组只有一个元素，即该字符串。

startsWith方法
- startsWith(String prefix)
  
  测试此字符串是否以指定的前缀开头。返回boolean类型。
  
  参数：
  
  prefix - 前缀。
```
String str = "今天天气很好";
System.out.println(str.startsWith("今天"));
//输出true
```
- startsWith(String prefix, int toffset)
  
  测试从指定索引开始的此字符串的子字符串是否以指定的前缀开头。
```
String str = "今天天气很好";
System.out.println(str.startsWith("天气",2));
//输出true
```
endsWith(String suffix)

测试此字符串是否以指定的后缀结尾。

参数：

suffix - 后缀。
```
String str = "今天天气很好。";
System.out.println(str.endsWith("。"));
//输出true
```
strip()

返回一个字符串，其值为此字符串，并删除了所有前导和尾随white space 。

如果此String对象表示空字符串，或者此字符串中的所有代码点均为white space ，则返回空字符串。

否则，返回此字符串的子字符串，该字符串以第一个不是white space的代码点开头，包括最后一个不是white space的代码点。
```
String str = "      今天天气很好。";
System.out.println(str.strip());
//结果去掉了字符串前面的空值
```
stripLeading()

返回一个字符串，其值为此字符串，并删除了所有前导white space 。

如果此String对象表示空字符串，或者此字符串中的所有代码点均为white space ，则返回空字符串。

否则，返回此字符串的子字符串，该字符串以第一个不是white space的代码点开头，并且包括该字符串的最后一个代码点。
stripTrailing()

返回一个字符串，其值为此字符串，并删除所有尾随white space 。

如果此String对象表示空字符串，或者此字符串中的所有字符均为white space ，则返回空字符串。

否则，返回此字符串的子字符串，以该字符串的第一个代码点开头，包括最后一个不是white space的代码点。
subSequence(int beginIndex, int endIndex)

返回作为此序列的子序列的字符序列。

参数：

beginIndex - 包含起始索引。
endIndex - 结束索引，不包括。
```
String str = "今天天气很好。";
System.out.println(str.subSequence(2,7));
//输出 天气很好
```
substring方法
- String substring(int beginIndex)
  
  返回一个字符串，该字符串是此字符串的子字符串。子字符串以指定索引处的字符开头，并延伸到此字符串的末尾。
```
String str = "今天天气很好。";
System.out.println(str.substring(2));
//输出 天气很好
```
- substring(int beginIndex, int endIndex)
  
  返回一个字符串，该字符串是此字符串的子字符串。子字符串从指定的beginIndex开始，并扩展到索引endIndex - 1处的字符。因此子串的长度是endIndex-beginIndex 。
```
String str = "今天天气很好。";
System.out.println(str.subString(2,7));
//输出 天气很好
```

toCharArray()

将此字符串转换为新的字符数组。

String str = "今天天气很好。";
char[] chars = str.toCharArray();
for (int i =0;i<chars.length;i++){
     System.out.print(chars[i]+", ");
}
//输出 今, 天, 天, 气, 很, 好, 。,

toLowerCase()方法
- toLowerCase()
  
  使用默认语言环境的规则将此String所有字符转换为小写。
```
String str = "ABCD";
System.out.println(str.toLowerCase());
//输出abcd
```
- toLowerCase(Locale locale)
  
  使用给定Locale的规则将此String所有字符转换为Locale 。
  
  参数：
  
  locale - 使用此语言环境的大小写转换规则
toUpperCase方法
- toUpperCase()
  
  使用默认语言环境的规则将此String所有字符转换为大写。
```
String str = "abcd";
System.out.println(str.toUpperCase());
//输出ABCD
```
- toUpperCase(Locale locale)
  
  使用给定Locale的规则将此String所有字符转换为大写。

trim()

返回一个字符串，其值为此字符串，删除了所有前导和尾随空格，其中space定义为其代码点小于或等于’U+0020’ （空格字符）的任何字符。

String str1 = "";
System.out.println(str1.trim());
//输出空字符串
String str2 = "      ";
System.out.println(str2.trim());
//输出空字符串
String str3 = "  今晚打老虎。  ";
System.out.println(str3.trim());
输出今晚打老虎

strip()

返回一个字符串，其值为此字符串，并删除了所有前导和尾随white space 。

如果此String对象表示空字符串，或者此字符串中的所有代码点均为white space ，则返回空字符串。

否则，返回此字符串的子字符串，该字符串以第一个不是white space的代码点开头，包括最后一个不是white space的代码点。

valueOf方法

根据传入参数的不同，一共有九种形式：

九种参数为：

boolean、char、char[]、(char[] data, int offset, int count) 、double、float、int、long、Object。

boolean s1 = true;
char s2 = '好';
char[] s3 = {'好','好','学','习'};
double s4 = 555555.6;
float s5 = 555.3f;
int s6 = 424;
long s7 = 5555555;
Object s8 = 55555.6;
System.out.println(String.valueOf(s1));
//输出 true
System.out.println(String.valueOf(s2));
//输出 好
System.out.println(String.valueOf(s3));
//输出 好好学习
System.out.println(String.valueOf(s3,2,2));
//输出 学习
System.out.println(String.valueOf(s4));
//输出 555555.6
System.out.println(String.valueOf(s5));
//输出 555.3
System.out.println(String.valueOf(s6));
//输出 424
System.out.println(String.valueOf(s7));
//输出 5555555
System.out.println(String.valueOf(s8));
//输出 55555.6

ZL_do_it

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
String类的方法整理

String类的方法整理String类表示字符串。Java程序中的所有字符串文字（例如“abc”）都实现为此类的实例。字符串的值是不变的（常量），它们的值在创建后无法更改。但是引用变量是可以改变的。字符串可以看做是一个长度固定的有序字符序列，每个组成的字符编有索引，从0开始。构造方法在String类中定义了许多的构造方法String（）初始化新创建的String...
复制链接

扫一扫