Java基础学习笔记--常用API之String类

package com.common.api;

/*
 * 基本介绍：
 * 	1、字符串是一个特殊的对象
 * 	2、字符串一旦初始化就不可以被改变
 * 	3、初始化有两种方式
 * 		1）String str="abc";
 * 		2）String str=new String("abc");
 * 
 * String类是用于描述字符串事物的
 *  那么他就提供了许多个方法对字符串进行操作
 * 常用的方法：
 * 1、获取
 * 		1）字符串中的包含的字符数，也就是字符串的长度
 * 			int length(); 返回此字符串的长度。 
 * 		2）根据位置获取位置上的某个字符
 * 			char charAt(int index)；
 * 		3）根据字符获取该字符在字符串中的位置
 * 			int indexOf(int ch)；返回的是ch在字符串中第一次出现的位置
 * 			int indexOf(int ch,int fromIndex);从fromIndex指定的位置开始，ch在字符串中出现的位置
 * 			int indexOf(String str)；返回的是str在字符串中第一次出现的位置
 * 			int indexOf(String str,int fromIndex);从fromIndex指定的位置开始，str在字符串中出现的位置
 * 			int lastIndexOf(int ch) 返回指定字符的最后一次出现的字符串中的索引
 * 			int lastIndexOf(int ch, int fromIndex) 返回指定字符的最后一次出现的字符串中的索引，从指定的索引开始向后搜索
 * 			int lastIndexOf(String str) 返回指定子字符串最后一次出现的字符串中的索引
 * 			int lastIndexOf(String str, int fromIndex) 返回指定子字符串的最后一次出现的字符串中的索引，从指定索引开始向后搜索。
 * 2、判断
 * 		1）字符串中是否包含某个子串
 * 			boolean contains(CharSequence s) 当且仅当此字符串包含指定的char值序列时才返回true。 
 * 		2）字符串中是否有内容
 * 			boolean isEmpty() 返回 true如果，且仅当 length()为 0 。 
 * 		3）字符串是否以指定内容开头
 * 			boolean startsWith(String prefix) 测试此字符串是否以指定的前缀开头
 * 		4）字符串是否以指定内容判断
 * 			boolean endsWith(String suffix) 测试此字符串是否以指定的后缀结尾。 
 * 		5）判断字符串内容是否相同，复写了Object类中的equals方法
 * 			boolean equals(Object anObject) 将此字符串与指定对象进行比较。 
 * 		6）判断内容是否相同，并忽略了大小写
 * 			boolean equalsIgnoreCase(String anotherString) 将此 String与其他 String比较，忽略案例注意事项。
 * 3、转换
 * 		1）将字符数组转换为字符串		
 * 			 构造函数：	String(char[] value)分配一个新的 String ，以便它表示当前包含在字符数组参数中的字符序列。 
 * 					String(char[] value, int offset, int count) 一个新的 String ，其中包含字符数组参数的子阵列中的字符。
 * 			静态方法：	static String valueOf(char[] data) 返回 char数组参数的字符串 char形式。 
 * 					static String valueOf(char[] data, int offset, int count) 返回 char数组参数的特定子阵列的字符串 char形式。  
 * 					static copyValueOf(char[] data) 相当于 valueOf(char[]) 。 
 * 					static copyValueOf(char[] data, int offset, int count) 相当于 valueOf(char[], int, int) 。
 * 		2）将字符串转换为字符数组
 * 			char[] toCharArray() 将此字符串转换为新的字符数组。  
 * 		3）将字节数组转换为字符串
 * 			String(byte[] bytes) 通过使用平台的默认字符集解码指定的字节数组来构造新的 String 。 
 * 			String(byte[] bytes, Charset charset) 构造一个新的String由指定用指定的字节的数组解码charset 。 
 * 		4）将字符串转换为字节数组
 * 			byte[] getBytes(String charsetName) 使用命名的字符集将此 String编码为字节序列，将结果存储到新的字节数组中。  
 * 		5）将基本数据类型转换为字符串
 * 			static String valueOf(boolean b) 返回 boolean参数的字符串 boolean形式。  
 * 			static String valueOf(char c) 返回 char参数的字符串 char形式。  
 * 			static String valueOf(double d) 返回 double参数的字符串 double形式。
 * 			static String valueOf(float f) 返回 float参数的字符串 float形式  
 * 			static String valueOf(int i) 返回 int参数的字符串 int形式。  
 * 			static String valueOf(long l) 返回 long参数的字符串 long形式 
 * 			static String valueOf(Object obj) 返回 Object参数的字符串 Object形式。  
 * 4、替换
 * 		String replace(char oldChar, char newChar) 返回从替换所有出现的导致一个字符串 oldChar在此字符串 newChar 。  
 * 		String replace(CharSequence target, CharSequence replacement) 将与字面目标序列匹配的字符串的每个子字符串替换为指定的字面替换序列。
 * 5、切割
 * 		String[] split(String regex) 将此字符串分割为给定的 regular expression的匹配。    
 * 6、子串，获取字符串中的一部分
 * 		String substring(int beginIndex) 返回一个字符串，该字符串是此字符串的子字符串。 
 * 		String substring(int beginIndex, int endIndex) 返回一个字符串，该字符串是此字符串的子字符串。 
 * 7、转换、去除空格、比较
 * 		1）将字符串转换成大写或者小写
 * 			String toLowerCase() 将所有在此字符 String使用默认语言环境的规则，以小写。  
 * 			String toUpperCase() 将所有在此字符 String使用默认语言环境的规则大写。  
 * 		2）将字符串两端的都空格去除
 * 			String trim() 返回一个字符串，其值为此字符串，并删除任何前导和尾随空格。  
 * 		3）对连个字符串进行自然顺序的比较
 * 			int compareTo(String anotherString) 按字典顺序比较两个字符串。  
 */
public class StringDemo {
	public static void method_7()
	{
		String s="   Hello Java   ";
		sop(s.toLowerCase());
		sop(s.toUpperCase());
		sop(s.trim());
		
		String s1="adc";
		String s2="aaa";
		sop(s1.compareTo(s2));
	}
	public static void method_sub()
	{
		String s="abcdefg";
		
		String s1=s.substring(2);
		sop(s1);
		String s2=s.substring(2,5);
		sop(s2);
	}
	public static void method_split()
	{
		String s="zhangsan,lisi,wangwu";
		String[] strArr=s.split(",");
		for(int i=0;i<strArr.length;i++)
		{
			sop(strArr[i]);
		}
	}
	public static void method_replace()
	{
		String s="hello java";
		String s1=s.replace('a','n');//不能再原字符串替换，因为字符串一旦被初始化，不能被修改，只能生成新的字符串
		sop(s);
		sop(s1);
		String s2=s.replace("java", "c++");
		sop(s2);
	}
	public static void method_trans()
	{
		char[] arr= {'a','b','c','d','e','f'};
		String s=new String(arr);
		sop("s="+s);
		s=new String(arr,1,3);
		sop("s="+s);
		sop("s="+String.valueOf(100));
		
		String s1="avbdifirtjoi";
		char[] chs=s1.toCharArray();
		for(int i=0;i<chs.length;i++)
		{
			sop("ch="+chs[i]);
		}
	}
	public static void method_is()
	{
		String str="ArrayDemo.java";
		//判断是否以Array开头
		sop(str.startsWith("Array"));
		//判断是否以.java结尾
		sop(str.endsWith(".java"));
		//判断是否包含Demo
		sop(str.contains("Demo"));
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	
	public static void method_get()
	{
		String str="abcdeakpf";
		//长度
		sop(str.length());
		
		//根据所以获取字符
		sop(str.charAt(4));
		//sop(str.charAt(40));//当访问到字符串中不存在的角标时会发生StringIndexOutOfBoundsException
		//根据字符获取索引
		sop(str.indexOf('a'));
		sop(str.indexOf('a',3));
		sop(str.indexOf('m'));//如果没有找到，返回-1
		
		sop(str.lastIndexOf('a'));

	}

	public static void main(String[] args) {
		
		String s1="kk";//s1是一个类类型变量，"kk"是一个对象
						//字符串一旦被初始化就不可以被改变
		s1="abc"; 		//这是s1变化了，s1刚刚指向了“kk”，现在指向“abc”，“kk”没有变化
		System.out.println(s1);
		
		//s1和s2有什么区别？
		//s1在内存中只有一个对象，
		//s2在内存中有两个对象
		
		String s2=new String("abc");
		System.out.println(s1==s2);
		System.out.println(s1.equals(s2));	//String 类复写了Object类总的equals方法，
											//定义了自己独特的内容，该方法用于判断字符串是否相同
		
		String s3="abc";
		System.out.println(s1==s3);//true,s1 和s3 指向同一个对象
		
		method_get();
		
		method_is();
		
		method_trans();
		
		method_replace();
		
		method_split();
		
		method_sub();
		
		method_7();
	}
}

运行结果

abc
false
true
true
9
e
0
5
-1
5
true
true
true
s=abcdef
s=bcd
s=100
ch=a
ch=v
ch=b
ch=d
ch=i
ch=f
ch=i
ch=r
ch=t
ch=j
ch=o
ch=i
hello java
hello jnvn
hello c++
zhangsan
lisi
wangwu
cdefg
cde
   hello java   
   HELLO JAVA   
Hello Java
3