字符串构造器及常用方法介绍

package com.oracle.Demo;

import java.io.UnsupportedEncodingException;

public class Demo {
public static void main(String[] args) throws Exception {

	String str1 = new String("你好");	//在堆中开辟一块空间，用于存放字符串
	String str2 = "你好";		//在常量池中创建字符串
	/**构造器*/
	 
	
	//1.new String();		目的是创建一个空字符串
	//2.new String(byte[] byte),将byte数组中的元素转换为字符串
	byte[] b = {65,66,67};//创建字符数组
	String str3 = new String(b);//将字符数组中的元素转换为字符串，然后拼接成字符串，封装到str3中
	System.out.println(str3);
	//3.new String(byte[] byte,字符集编码，"GBK");  将字符串先变为byte数组，然后按照指定的字符集编码方式转换
	//其中，getBytes()可以将字符串转为byte数组
	//使用getByte()的原因是因为计算机最底层的数据都是二进制，字节形式，因此使用getByte()方法是最优的
	String str4 = "中国";
	String s = new String(str4.getBytes(),"utf-8");
	System.out.println(s);	//打印输出的结果为?й?
	//4.new String(byte[] byte,int offset,int length);  
	//参数一：将字符串转为byte数组；参数二：要输出的开始位置的字符串（一个汉字占两个字节，标点符号也占两个字节，汉字或者标点符号，开始位置是指定参数二的位置下一位置的字符）；参数三：要输出的字符串的长度
	String str6 = "anbfhfd";
	String str7 = "你好，中国";
	String str5 = new String(str6.getBytes(),2,3);//当字符串内容为字符时，起始位置为参数二的下一位置的字符
	String str8 = new String(str7.getBytes(),0,4);
	System.out.println(str8);
	System.out.println(str5);
	
	//5.new String(char[] value); 将char类型数组元素整合为字符串形式输出
	char[] c = {'L','O','V','E'};
	String str9 = new String(c);
	System.out.println(str9);
	
	//6.new String(original);		在构造器中放入字符串

	
	/**普通方法*/
	// 1.char charAt(int index)	返回字符串指定索引位置的值
	//字符串也叫作字符序列，相当于一个数组，索引也是从0开始
	//当下标越界的时候，报	StringIndexOutofBoundsException（字符串下标越界异常）
	String str10 = new String("你好，世界万物");
	char c1 = str10.charAt(6);
	System.out.println(c1);
	// 2.concat(String str)  实现字符串的拼接，有返回值，返回值为String类型
	String str11 = "你好，史家湾    ";
	String c2 = str11.concat(str10);
	System.out.println(c2);
	// 3.public boolean startsWith(String prefix,int toffset)  测试在指定索引处开始的此字符串的子字符串是否以指定的前缀开头。 
	//参数prefix，前缀，toffset，在哪里开始查找这个字符串
	//如果字符序列是从索引toffset开始的前缀 ，则为true，否则false；若toffset为负数或者大于字符序列的长度，结果为false
	boolean startsWith = str11.startsWith("好，史家湾",1);
	System.out.println(startsWith);
	//没有索引toffset，默认是从字符序列的第一个字符开始
	boolean b1 = str10.startsWith("好");
	System.out.println(b1);
	
	//4.public boolean endsWith(String suffix)  测试此字符串是否以指定的后缀结尾。
	//参数：suffix，后缀
	/**true如果由参数表示的字符序列是由该对象表示的字符序列的后缀; false否则。
	 *  注意，结果将是true如果参数是空字符串或等于该String如由所确定的对象equals(Object)方法。
	*/
	String str12 = "";
	String str13 = "hello";
	
	boolean endsWith = str12.endsWith("");
	boolean endsWith2 = str13.endsWith("llo");
	System.out.println(endsWith);
	System.out.println(endsWith2);
	
	//5.public int indexOf(int ch或String str)	返回指定字符第一次出现的字符串内的索引。若没有，则返回-1；若满足，则返回第一个字符的索引
	//当指定字符为字符串时，如果满足，则返回的索引位置为该指定字符串的第一个字符在目标字符串中的索引
	int indexOf = str13.indexOf("hell");
	System.out.println(indexOf);
	//public int indexOf(int ch, int fromIndex)	返回指定字符第一次出现的字符串内的索引，以指定的索引开始搜索。若没有，则返回-1；若满足，则返回第一个字符的索引
	//参数1：指定字符；参数二：从指定索引位开始搜索
	int indexOf2 = str13.indexOf("ell", 1);
	System.out.println(indexOf2);
	
	//6.public int lastIndexOf(int ch)返回指定字符的最后一次出现的字符串中的索引。若没有，则返回-1；若满足，则返回第一个字符的索引
	//	public int lastIndexOf(int ch, int fromIndex)返回指定字符的最后一次出现的字符串中的索引，从指定的索引开始向后搜索。若没有，则返回-1；若满足，则返回第一个字符的索引 
	 		int lastIndexOf = str13.lastIndexOf("llm");
	int lastIndexOf2 = str13.lastIndexOf("l", 5);
	
	System.out.println(lastIndexOf2);
	System.out.println(lastIndexOf);
	
	//7. public String substring(int beginIndex) 返回一个字符串，该字符串是此字符串的子字符串。 子字符串以指定索引处的字符开头，并扩展到该字符串的末尾。	
	//	public String substring(int beginIndex,int endIndex)   返回一个字符串，该字符串是此字符串的子字符串。 子串开始于指定beginIndex并延伸到字符索引endIndex - 1 。 因此，子串的长度为endIndex-beginIndex
	String str14  = "你好啊，这个世界";
	
	String substring = str14.substring(3);
	//子串的长度为endIndex-beginIndex		3-1=2
	String substring1 = str14.substring(1, 3);
	System.out.println(substring);
	System.out.println(substring1);
	
	
	//8.public String replace(char oldChar, char newChar)	 返回从替换所有出现的导致一个字符串oldChar在此字符串newChar 。
	//参数oldChar，老字符；newChar，新字符
	//只要原字符串中有oldChar匹配的字符，就会被全部替换为新字符newChar
	String str15 = "hello";
	String replace = str15.replace("l", "哈哈");
	System.out.println(replace);
	
	//9.public boolean contains(CharSequence s/String str)	当且仅当此字符串包含指定的char值序列时才返回true。
	boolean contains = str15.contains("l");
	System.out.println(contains);
	
	//10.public String replaceFirst(String regex,String replacement)  将元字符串中第一次出现指定字符regex，替换为指定字符replacement（只替换第一个）
	//参数regex：指定被替换的字符；参数replacement:指定替换后的字符
	String replaceFirst = str15.replaceFirst("l", "a");
	System.out.println(replaceFirst);
	
	//11.public String[] split(String regex, int limit)按照指定字符分割元字符串
	String str16 ="你好*世界*足球";
	//正则表达式 \\ 转义字符
	String[] split2 = str16.split("\\*");
	
	for(int i = 0;i < split2.length;i++) {
		System.out.println(split2[i]);
	}
	
	//12.public String toLowerCase()将所有在此字符String使用默认语言环境的规则，以小写。
	//	public String toUpperCase()将所有在此字符String使用默认语言环境的规则，以大写。
	String str17 = "LOVE";
	String lowerCase = str17.toLowerCase();
	System.out.println(lowerCase);
	String upperCase = lowerCase.toUpperCase();
	System.out.println(upperCase);
	
	
	//12.public String trim()  删除字符串中字符创整体前后的所有空格
	
	String str18 = "           我是   你  爹     ";
	
	String trim = str18.trim();
	System.out.println(trim);
	
	//13 public char[] toCharArray()  将原字符串转为字符数组
	char[] charArray = str17.toCharArray();
	for(int i=0;i<charArray.length;i++) {
		System.out.println(charArray[i]);
	}
	
	//14. public static String valueOf(Object obj)返回 Object参数的字符串 Object形式。
	
	String str20 =String.valueOf(false);
	System.out.println(str20);
	
	String str21 = String.valueOf(new TestDemo());
	System.out.println(str21);
	//将int类型的变量转为字符串类型
	String str22 = String.valueOf(5);
	System.out.println(str22+5);

}

}
运行结果：