总体方法一览

image-20220831122824717

equals

比较两个字符串内容是否相等，这里区分大小写

public boolean equals(Object anObject)

1
2
3
4
5
6
7
// 判断"ikun"是否等于"ikun"
System.out.println("ikun".equals("ikun"));
// 判断"ikun"是否等于"你干嘛"
System.out.println("ikun".equals("你干嘛"));
// 结果：
// true
// false

equalsignoreCase

比较两个字符串内容是否相等，这里不区分大小写

public boolean equalsIgnoreCase(String anotherString)

1
2
3
// 判断"ikun"是否等于"IKUN"，这里不区分大小写
System.out.println("ikun".equalsIgnoreCase("IKUN"));
// 结果：true

length

获取字符串的长度

public int length()

1
2
3
// 获取"ikun"的长度
System.out.println("ikun".length());
// 结果：4

indexOf

获取字符/字符串第一次在另一个字符串中出现的位置

有四个重载方法

  1. public int indexOf(int ch)

​ 查找字符在字符串中第一次出现的位置，找到返回位置索引，没有找到返回-1

  1. public int indexOf(int ch, int fromIndex)

​ 从fromIndex索引位置开始查找字符在字符串中第一次出现的位置，找到返回位置索引，没有找到返回-1

  1. public int indexOf(String str)

​ 查找字符串str在字符串中第一次出现的位置，找到返回位置索引，没有找到返回-1

  1. public int indexOf(String str, int fromIndex)

​ 从fromIndex索引位置开始查找字符串str在字符串中第一次出现的位置，找到返回位置索引，没有找到返回-1

1
2
3
4
5
6
7
8
9
10
11
12
13
// 查找'z'在"wzzzzz"中第一次出现的位置
System.out.println("wzzzzz".indexOf('z'));
// 从索引为3的位置开始查找'z'在"wzzzzz"中第一次第一次出现的位置
System.out.println("wzzzzz".indexOf('z', 3));
// 查找'zzzz'在"wzzzzz"中第一次出现的位置
System.out.println("wzzzzz".indexOf("zzzz"));
// 从索引为2的位置开始查找'zzzz'在"wzzzzz"中第一次出现的位置
System.out.println("wzzzzz".indexOf("zzzz", 2));
// 结果
// 1
// 3
// 1
// 2

lastIndexOf

获取字符/字符串最后一次在另一个字符串中出现的位置

有四个重载方法

  1. public int lastIndexOf(int ch)

​ 查找字符在字符串中最后一次出现的位置，找到返回位置索引，没有找到返回-1

  1. public int lastIndexOf(int ch, int fromIndex)

​ 从fromIndex索引位置开始查找字符在字符串中最后一次出现的位置，找到返回位置索引，没有找到返回-1

  1. public int lastIndexOf(String str)

​ 查找字符串str在字符串中最后一次出现的位置，找到返回位置索引，没有找到返回-1

  1. public int lastIndexOf(String str, int fromIndex)

​ 从fromIndex索引位置开始查找字符串str在字符串中最后一次出现的位置，找到返回位置索引，没有找到返回-1

1
2
3
4
5
6
7
8
9
10
11
12
13
// 查找'z'在"wzzzzz"中最后一次出现的位置, 这个是从后往前找
System.out.println("wzzzzz".lastIndexOf('z'));
// 从索引为3的位置开始查找'z'在"wzzzzz"中最后一次出现的位置, 这个是从后往前找
System.out.println("wzzzzz".lastIndexOf('z', 3));
// 查找'zzzz'在"wzzzzz"中最后一次出现的位置, 这个是从后往前找
System.out.println("wzzzzz".lastIndexOf("zzzz"));
// 从索引为2的位置开始查找'zzzz'在"wzzzzz"中最后一次出现的位置, 这个是从后往前找
System.out.println("wzzzzz".lastIndexOf("zzzz", 2));
// 输出结果
// 5
// 3
// 2
// 2

subString

截取子串

有两种重载形式

  1. public String substring(int beginIndex)

    截取从beginIndex开始到最后的子串

  2. public String substring(int beginIndex, int endIndex)

​ 截取从[beginIndex,endIndex)的子串

1
2
3
4
5
6
7
// 从1位置开始截取"鸡你太美"
System.out.println("鸡你太美".substring(1));
// 截取[1,3)位置的子串
System.out.println("鸡你太美".substring(1, 3));
// 结果：
// 你太美
// 你太

trim

去除字符串左右两边的空格

public String trim()

注意：字符串中间的空格不能去除

1
2
3
4
5
6
7
// 去除"   ikun    "左右两边的空格
System.out.println("   ikun    ".trim());
// 去除"   ik  un    "左右两边的空格，但是"ik  un"中间的空格不能去掉
System.out.println("   ik  un    ".trim());
// 结果
// ikun
// ik  un

charAt

获取字符串指定索引位置的字符

public char charAt(int index)

1
2
3
4
5
6
7
8
9
System.out.println("ikun".charAt(0));
System.out.println("ikun".charAt(1));
System.out.println("ikun".charAt(2));
System.out.println("ikun".charAt(3));
// 输出
// i
// k
// u
// n

toUpperCase

将字符串全部转成大写

该方法有两种重载形式

  1. public String toUpperCase()

​ 使用默认本地化将字符串转成大写

  1. public String toUpperCase(Locale locale)

    指定本地化语言将字符串转成大写，不同地区的语言差异，可能导致转换大小写有差异

1
2
3
4
5
6
7
// 使用默认的转换方式转换
System.out.println("nihao".toUpperCase());
// 指定locale
System.out.println("nihao".toUpperCase(Locale.CHINA);
// 结果（貌似两种方法没有什么差异？）
// NIHAO
// NIHAO

toLowerCase

将字符串全部转成小写

该方法有两种重载形式

  1. public String toLowerCase()

    使用默认本地化将字符串转成大写

  2. public String toLowerCase(Locale locale)

    指定本地化语言将字符串转成大写，不同地区的语言差异，可能导致转换大小写有差异

1
2
3
4
5
6
7
// 使用默认的转换方式转换
System.out.println("NIHAO".toLowerCase());
// 指定locale
System.out.println("NIHAO".toUpperCase(Locale.CHINA));
// 结果（貌似两种方法没有什么差异？）
// nihao
// nihao

concat

拼接两个字符串，返回拼接后的字符串

public String concat(String str)

1
2
3
4
// 拼接"ikun"和"你干嘛？"
System.out.println("ikun".concat("你干嘛？"));
// 输出
// ikun你干嘛？

split

指定分隔符来分割字符串，返回分割后的字符串数组

该方法有两种重载形式

  1. public String[] split(String regex)

    regex指定分隔符，被尽可能多的分割，但是尾部的空字符串""会被抛弃

  2. public String[] split(String regex, int limit)

​ regex指定分隔符, limit指定分割模式

limit 效果
limit > 0 分割limit -1次
limit = 0 被尽可能多的分割，但是尾部的空字符串会被抛弃，这个等价于没有limit参数的重载
limit < 0 被尽可能多的分割，不会抛弃空字符串""

默认方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 默认效果,被尽可能多的分割,会省略后面的空串
String[] split = "春天,夏天,秋天,冬天,,,,".split(",");
for (String string : split) {
	// 为了效果，空串做特殊处理
	if (string.equals("")) {
	System.out.println("空串");
	} else {
	System.out.println(string);
	}
}
// 结果:
// 春天
// 夏天
// 秋天
// 冬天

带limit参数

limit > 0

分割limit -1次

1
2
3
4
5
6
7
8
9
10
11
12
13
// limit > 0 && limit = 2
String[] split = "春天,夏天,秋天,冬天,,,,".split(",", 2);
for (String string : split) {
	// 为了效果，空串做特殊处理
	if (string.equals("")) {
	System.out.println("空串");
	} else {
	System.out.println(string);
	}
}
// 结果:
// 春天
// 夏天,秋天,冬天,,,,

limit = 0

被尽可能多的分割，但是尾部的空字符串""会被抛弃，这个等价于没有limit参数的重载

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// limit = 0
String[] split = "春天,夏天,秋天,冬天,,,,".split(",", 0);
for (String string : split) {
	// 为了效果，空串做特殊处理
	if (string.equals("")) {
	System.out.println("空串");
	} else {
	System.out.println(string);
	}
}
// 结果:
// 春天
// 夏天
// 秋天
// 冬天

limit < 0

被尽可能多的分割，不会抛弃空字符串""

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// limit = -2
String[] split = "春天,夏天,秋天,冬天,,,,".split(",", -2);
for (String string : split) {
	// 为了效果，空串做特殊处理
	if (string.equals("")) {
	System.out.println("空串");
	} else {
	System.out.println(string);
	}
}
// 结果:
// 春天
// 夏天
// 秋天
// 冬天
// 空串
// 空串
// 空串
// 空串

compareTo

比较两个字符串的字典序大小

public int compareTo(String anotherString)

1
2
3
4
5
6
7
8
9
10
// abc字典序大于aba，返回正数
System.out.println("abc".compareTo("aba"));
// abc字典序等于aba，返回0
System.out.println("abc".compareTo("abc"));
// abc字典序小于aba，返回负数
System.out.println("abc".compareTo("abd"));
// 结果:
// 2
// 0
// -1

toCharArray

将字符串转换成字符数组

public char[] toCharArray()

1
2
3
4
5
6
// 将"happy"字符串转换成{'h', 'a', 'p', 'p', 'y'}字符数组
char[] chars = "happy".toCharArray();
	for (char c : chars) {
	System.out.print(c + "\t");
}
// 结果: h	a	p	p	y

format

按照C语言的输出风格控制输出

有两种重载形式

  1. public static String format(String format, Object... args)

    这个是默认输出格式

  2. public static String format(Locale l, String format, Object... args)

    这个可以指定本地化语言风格

1
2
3
4
5
6
7
// 默认输出
System.out.println(String.format("我爱%s", "中国"));
// 指定本地化语言为CHINA
System.out.println(String.format(Locale.CHINA,"我爱%s", "中国"));
// 输出结果
// 我爱中国
// 我爱中国

replace

可以替换字符串中的字符/字符串

该方法有两种重载形式

  1. public String replace(char oldChar, char newChar)

    这个方法用于替换字符

  2. public String replace(CharSequence target, CharSequence replacement)

    这个方法用于替换字符串

    值得一提的是：CharSequence是一个接口，String、StringBuilder、StringBuffer都实现了该接口，所以这里可以传入String、StringBuilder、StringBuffer对象

1
2
3
4
5
6
7
// 替换字符: 将"hhhhh"中的所有'h'替换成'T'
System.out.println("hhhhh".replace("h", "T"));
// 替换字符串:将"我是ikun"中的"ikun"替换成"小明"
System.out.println("我是ikun".replace("ikun", "小明"));
// 结果
// TTTTT
// 我是小明