java–String类常用方法大全

1.字符串的替换
   1. replace()

		public static void main(String[] args) {
			String str1 = "hello word";
			String str2 = str1.replace("hello", "hi");
			String str3 = str1.replace("abc", "hi");
			System.out.println("str2:"+str2);	//输出 hi word
			System.out.println("str3"+str3);	//输出 hello word（要替换的目标不存在）
		}

   2. replaceall()

		public static void main(String[] args) {
			String str1 = "hello word";
			String str2 = str1.replaceAll("o", "O");	//把字符串中的 o全部替换为 O
			String str3 = str1.replaceAll("123", "A");
			System.out.println("str2:"+str2);	//输出 hellO wOrd
			System.out.println("str3"+str3);	//输出 hello word（要替换的目标不存在）
		}

   3. replaceFirst()

		public static void main(String[] args) {	
			String str1 = "hello word";
			String str2 = str1.replaceFirst("h", "H");
			String str3 = str1.replaceFirst("o", "O");	//把字符串中第一个 o替换为 O
			String str4 = str1.replaceFirst("111", "H");
			System.out.println("str2:"+str2);	//输出 Hello word
			System.out.println("str3"+str3);	//输出 hellO word
			System.out.println("str4"+str4); 	//输出 hello word（要替换的目标不存在）
		}

2.字符串的拆分
   1. split(String regex)

		public static void main(String[] args) {
			String str1 = "你见过洛杉矶1凌晨四点的1样子吗？";
			String[] strs = str1.split("1");
			for(String s : strs){
				System.out.println("s------"+s);
			}	
		}

   2. split(String regex, int limit)

		public static void main(String[] args) {
			String str1 = "abc1def1ghi1";
			String[] str2 = str1.split("1", 555);
			for(String s2 : str2){
				System.out.println("s2---"+s2);
			}
			String[] str3 = str1.split("1", 3);
			for(String s3 : str3){
				System.out.println("s3---"+s3);
			}
		}

3.字符串的截取
   1. substring(int beginIndex)

		String str1 = "abcdefghi";
		String str2 = str1.substring(2);	//截取下标为2(含2)
		System.out.println(str2);

   2. substring(int beginIndex, int endIndex)

		String str1 = "abcdefghi";
		String str2 = str1.substring(2,4);	//从下标为2的字符开始截取，截取到下标为4的字符(含2不含4)
		System.out.println(str2);

4.字符串的查找
   1. contains()

		String str = "Hello Word";
		boolean result1 = str.contains("l");
		boolean result2 = str.contains("s");
		System.out.println(result1);		//输出 true
		System.out.println(result2);		//输出 false

   2. endsWith()

		//此方法测试字符串是否以指定的后缀结束
		String str = "Hello Word";
		boolean result1 = str.endsWith("d");
		boolean result2 = str.endsWith("s");
		System.out.println(result1);		//输出 true
		System.out.println(result2);		//输出 false

   3. startsWith(String prefix)

		//此方法测试字符串是否以指定的字符开始
		String str = "Hello Word";
		boolean result1 = str.startsWith("H");
		boolean result2 = str.startsWith("h");
		System.out.println(result1);		//输出 true
		System.out.println(result2);		//输出 false

   4. startsWith(String prefix, int offIndex)

		String str = "Hello Word";
		boolean result1 = str.startsWith("H",0);
		boolean result2 = str.startsWith("h",0);
		boolean result3 = str.startsWith("e",1);
		boolean result4 = str.startsWith("l",2);
		boolean result5 = str.startsWith("l",3);
		System.out.println(result1);		//输出 true
		System.out.println(result2);		//输出 false
		System.out.println(result3);		//输出 true
		System.out.println(result4);		//输出 true
		System.out.println(result5);		//输出 true

   5. indexOf(String str)

		//返回指定字符在字符串中第一次出现处的索引(下标)，如果此字符串中没有这样的字符，则返回 -1
		String str = "Hello Word";
		int res1 = str.indexOf("e");
		int res2 = str.indexOf("s");
		System.out.println(res1);		//输出 1
		System.out.println(res2);		//输出-1

   6. indexOf(String str, int fromIndex)

		//返回从 fromIndex 位置开始查找指定字符在字符串中第一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1
		String str = "Hello Word";
		int res1 = str.indexOf("o",5);
		int res2 = str.indexOf("s");
		System.out.println(res1);		//输出 7
		System.out.println(res2);		//输出-1

   7. lastindexOf(String str)

		//返回指定字符在此字符串中最后一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1
		String str = "Hello Word";
		int res1 = str.lastIndexOf("o");
		int res2 = str.indexOf("s");
		System.out.println(res1);		//输出 7
		System.out.println(res2);		//输出 -1

   8. lastindexOf(String str, int fromIndex)

		//从fromIndex个字符中找，返回指定字符在此字符串中最后一次出现处的索引，如果此字符串中没有这样的字符，则返回 -1
		String str = "Hello Wordollo";
		int res1 = str.lastIndexOf("o",9);
		int res2 = str.indexOf("s");
		System.out.println(res1);		//输出 7
		System.out.println(res2);		//输出 -1
		

   9. charAt(int index)

		//返回指定索引处的字符。索引范围为从 0 到 length() - 1
		String str = "Hello Wordollo";
		char str1 = str.charAt(0);
		char str2 = str.charAt(6);
		System.out.println(str1);		//输出 H
		System.out.println(str2);		//输出 W

5.字符串的比较
   1. equals()

		String str1 = "你见过洛杉矶凌晨四点的样子吗？";
		String str2 = "ABC";
		String str3 = "你见过洛杉矶凌晨四点的样子吗？";
		System.out.println(str1.equals(str2));		//输出 false
		System.out.println(str1.equals(str3));		//输出 true

   2. equalsIgnoreCase()

		//不区分大小写
		String str1 = "abc";
		String str2 = "ABC";
		System.out.println(str1.equalsIgnoreCase(str2));	//输出 true

   3. compareTo(String str)

		/*
		*用于两种方式的比较：
		*	字符串与对象进行比较
		*	按字典顺序比较两个字符串
		*		返回值是整型,它是先比较对应字符的大小(ASCII码顺序),如果第一个字符和参数的第一个字符不等,结束比较,返回他们之间的差值,如果第一个字符和参数的第一个字符相等,则以第二个字符和参数的第二个字符做比较,以此类推,直至比较的字符或被比较的字符有一方
		*			如果参数字符串等于此字符串，则返回值 0
		*			如果此字符串小于字符串参数，则返回一个小于 0 的值
		*			如果此字符串大于字符串参数，则返回一个大于 0 的值
		*/
		String str1 = "a";
		String str2 = "A";
		String str3 = "bb";
		String str4 = "a";
		System.out.println(str1.compareTo(str2));	//输出 32
		System.out.println(str1.compareTo(str3));	//输出 -1
		System.out.println(str1.compareTo(str4));	//输出 0

   4. compareToIgnoreCase(String str)

		//按字典顺序比较两个字符串，不考虑大小写
		/*
		*  如果参数字符串等于此字符串，则返回值 0
		*  如果此字符串小于字符串参数，则返回一个小于 0 的值
		*  如果此字符串大于字符串参数，则返回一个大于 0 的值
		**/
		String str1 = "a";
		String str2 = "A";
		String str3 = "bb";
		String str4 = "a";
		System.out.println(str1.compareToIgnoreCase(str2));		//输出 0
		System.out.println(str1.compareToIgnoreCase(str3));		//输出 -1
		System.out.println(str1.compareToIgnoreCase(str4));		//输出 0

		/*
		* 在compareTo上返回的数据类型是int型，有如下三种返回：
		* 大于：> 0
		* 小于：< 0
		* 等于： = 0
		* compareTo对于大小的比较实际上就是对字母编码的比较
		**/
		

6.字符串转为数组
   1. 将字符串转为字节数组

• getBytes(String charsetName): 使用指定的字符集将字符串编码为 byte 序列，并将结果存储到一个新的 byte 数组中
• getBytes()使用平台的默认字符集将字符串编码为 byte 序列，并将结果存储到一个新的 byte 数组中

		public static void main(String args[]) {
        	String Str1 = new String("runoob");
        	try{
            	byte[] Str2 = Str1.getBytes();
            	System.out.println( Str2 );		//输出 [B@7852e922
            	Str2 = Str1.getBytes( "UTF-8" );
            	System.out.println( Str2 );		//输出 [B@4e25154f   
            	Str2 = Str1.getBytes( "ISO-8859-1" );
            	System.out.println( Str2 );		//输出 [B@70dea4e
        	} catch ( UnsupportedEncodingException e){
            	System.out.println("不支持的字符集");
        	}
    	}

2. 将字符串变为字节数组

• toCharArray() 方法将字符串转换为字符数组
  

		public static void main(String args[]) {
        	String Str = new String("www.runoob.com");
        	System.out.println( Str.toCharArray() );	//输出 www.runoob.com
    }

7.其他方法
   1. 字符串长度

   2. 大写转小写

   3. 小写转大写

   4. 去掉前后空格(中间保留)

   5. 字符串连接(一般用+)

   6. 将内容保存到对象池中

   7. 判断是否是空字符串

C++string类常用方法

1、string(const char *s) ：将 string 对象初始化为 s 指向的字符串

string str("hello");

2、string(size_type n,char c) ：创建一个包含 n 个元素的 string 对象，其中每个元素都被初始化为字符 c

string str(10, 'a');

3、string(const string &str) ：将一个 string 对象初始化为 string 对象 str（复制构造函数）

string str("abcde");
string str2(str);

4、string() ：创建一个默认的 string 对象，长度为 0（默认构造函数）

string str;

5、使用C语言风格字符串处理string对象

string str = "hello!";

6、获取string对象的长度，C语言中使用strlen()来获取字符串长度，C++中使用str.size()或str.length().

string str("hello!");
int len1 = str.size();
int len2 = str.length();

7、将一个 string 对象赋值给另一个 string 对象

string str("hello!");
string str2;
str2 = str;

8、string 对象的拼接
C 语言中使用 strcat、strncat 函数来进行字符串拼接操作，C++中可以采用以下方式：

string str1("hello");
string str2("world");
string str3 = str1 + str2;

9、使用 += 来在一个 string 对象后面附加一个 string 对象、字符以及 C 风格的字符串

string str("hello");
string str2("world");
str += str2;
str += 'a';
str += "abcd";

10、string.append() 函数，在string对象后添加一个string对象或c风格字符串。

string str("hello");
string str2("world");
str.append(str2);
str.append("abcd");

11、string.push_back() 函数来在一个 string 对象后面附加一个字符

string str("hello");
char ch = 'a';
str.push_back(ch);

12、对于string对象的比较，可以直接使用关系运算符。

string str1("abcd");
string str2("abcd");
if(str1 == str2)
	break;

13、string对象的比较也可以使用string.compare() 方法

int compare(const string&str) const;
int compare(size_t pos，size_t len，const string&str)const;
int compare(size_t pos，size_t len，const string&str, size_t subpos，size_t sublen)const;
int compare(const char * s)const;
int compare(size_t pos，size_t len，const char * s)const;
int compare(size_t pos，size_t len，const char * s，size_t n)const;

// example
string str1("hello world");
string str2("hello boy");
str1.compare(6, 3, str2, 6, 3);

14、使用 string.substr() 函数来获取子串

string str("hello");
string str2 = str.substr(3,2)

15、访问 string 字符串的元素

string str("hello");
cout << str[2] << endl;
cout << str.at(2) << endl;

16、使用 string.find() 方法查找字符

//  从字符串的 pos 位置开始（若不指定 pos 的值，则默认从索引 0 处开始），查找子字符串 str。
//  如果找到，则返回该子字符串首次出现时其首字符的索引；否则，返回 string::npos：
//  string 类将 npos 定义为保证大于任何有效下标的值。
size_type find (const string& str, size_type pos = 0) const;
size_type find (const char *s, size_type pos = 0) const;
size_type find (const char *s, size_type pos, size_type n);
size_type find (char ch, size_type pos = 0) const;

17、string.rfind() 与 string.find() 方法类似，只是查找顺序不一样， string.rfind() 是从指定位置 pos （默认为字符串末尾）开始向前查找，直到字符串的首部，并返回第一次查找到匹配项时匹配项首字符的索引。换句话说，就是查找子字符串或字符最后一次出现的位置。

18、string.find_first_of() 方法在字符串中从指定位置开始向后（默认为索引 0 处）查找参数中任何一个字符首次出现的位置

string str("hello world");
int pos = str.find_first_of("abcde");
int pos = str.find_first_of("abcde", 1);  // 第二个参数为位置

19、string.find_last_of() 方法在字符串中查找参数中任何一个字符最后一次出现的位置

20、string.find_first_not_of() 方法在字符串中查找第一个不包含在参数中的字符

21、string.find_last_not_of() 方法在字符串中查找最后一个不包含在参数中的字符

22、使用 string.insert() 进行插入操作

string& insert（size_t pos，const string＆str）;　　　
// 在位置 pos 处插入字符串 str

string& insert（size_t pos，const string＆str，size_t subpos，size_t sublen）;　
// 在位置 pos 处插入字符串 str 的从位置 subpos 处开始的 sublen 个字符

string& insert（size_t pos，const char * s）;　　　　
// 在位置 pos 处插入字符串 s

string& insert（size_t pos，const char * s，size_t n）;　
// 在位置 pos 处插入字符串 s 的前 n 个字符

string& insert（size_t pos，size_t n，char c）;　　　　　 
// 在位置 pos 处插入 n 个字符 c

iterator insert (const_iterator p, size_t n, char c);　
// 在 p 处插入 n 个字符 c，并返回插入后迭代器的位置

iterator insert (const_iterator p, char c);　　　　　　 
// 在 p 处插入字符 c，并返回插入后迭代器的位置

23、使用 string.erase() 进行元素删除操作

string& erase (size_t pos = 0, size_t len = npos);　　　// 删除从 pos 处开始的 n 个字符
iterator erase (const_iterator p);　　　　　　　　　　　　// 删除 p 处的一个字符，并返回删除后迭代器的位置
iterator erase (const_iterator first, const_iterator last);　// 删除从 first 到last 之间的字符，并返回删除后迭代器的位置

24、使用 getline() 函数来获取 string 输入

string str;
getline(cin, str);

25、使用 string.empty() 函数判断字符串是否为空

26、使用 string.swap() 函数交换两个字符串

string str1 = "hello";
string str2 = "HELLO";
str1.swap(str2);

27、string.back()获取或修改字符串最后一个字符

string str("abcd");
char b = str.back();
str.back() = 'e';

28、string.front()获取或修改字符串第一个字符

29、string.pop_back()删除字符串最后一个元素

参考资料：
STRING类使用方法汇总

1.String的构造方法
1）String(String original):把字符串数据封装成字符串对象
2）String(char[] value):把字符数组的数据封装成字符串对象
3）String(char[] value, int index, int count):把字符数组中的一部分数据封装成字符串对象

2.String类的获取功能：
1）length():获取字符串的长度，其实也就是字符个数
————————————————
2）charAt(int index):获取指定索引处的字符

3）indexOf(String str):获取str在字符串对象中第一次出现的索引

4）substring(int start):从start开始截取字符串

5）String substring(int start,int end):从start开始，到end结束截取字符串。包括start，不包括end

3.String判断功能

1）equals(Object obj):比较字符串的内容是否相同

2）equalsIgnoreCase(String anotherString):比较字符串的内容是否相同,忽略大小写

3）startsWith(String prefix):判断字符串对象是否以指定的字符开头（区分大小写）

4）startsWith(String prefix,int toffset)：判断字符串对象是否以指定的字符开头，参数toffset为指定从哪个下标开始

5）endsWith(String str):判断字符串对象是否以指定的字符结尾

6）isEmpty()：判断指定字符串是否为空

6）compareTo(String anotherString)：比较字符串的大小，前者大返回整数，后者大返回负数，相等返回0

4.String类中的转化方法：

1）toCharArray():把字符串转换为字符数组

2）toLowerCase():把字符串转换为小写字符串

3）toUpperCase():把字符串转换为大写字符串

5.其他常用方法

1）trim()：去除字符串两端空格

2）split():去除字符串中指定的的字符，然后返回一个新的字符串

3）subSequence(int beginIndex,int endIndex )：截取字符串中指定位置的字符组成一个新的字符串

4）replace(char oldChar, char newChar)：将指定字符替换成另一个指定的字符

5）replaceAll(String regex,String replasement)：用新的内容替换全部旧内容

6）replaceFirst(String regex,String replacement)：替换首个满足条件的内容

7）lastIndexOf(String str)：返回指定字符出现的最后一次的下标

8）contains(CharSequence s)：查看字符串中是都含有指定字符

9）concat(String str)：在原有的字符串的基础上加上指定字符串

练习题：输入一个字符串，再输入要查找的字符，判断该字符在该字符串中出现的次数

Scanner input =new Scanner(System.in);
System.out.print("请输入一个字符串：");
String ci = input.next();
System.out.print("请输入要查找的字：");
String sou=input.next();
// 1.直接使用sou作为拆分符号对ci拆分，拆分后数组的长度-1即为字符个数
String[] ciArr = ci.split(sou);
System.out.println("个数："+(ciArr.length-1));
// 2.循环ci，取出每个字符和sou相比，累计相同个数

int count =0;
for (int i = 0; i <ci.length() ; i++) {
    if (ci.charAt(i)==sou.charAt(0)){
        count++;
    }
}
System.out.println("个数："+count);

// 3.使用字符串的替换方法，将sou在ci中出现的位置全部替换为“”，
// 然后原始字符串长度减去替换后的字符串长度即为c的个数
String newCi = ci.replace(sou, "");
System.out.println("个数："+(ci.length()-newCi.length()));