黑马毕向东Java课程笔记（day13-1_13-12）:String类——特点，常用功能+StringBuilder+StringBuffer

1、String类特点
  String类是final类，因此其没有子类，不能继承。之前提到的方法区，里面包含了方法的代码、静态数据，常量池也在方法区里面（JDK1.7后常量池移到堆中）。常量池的数据是固定不变的，字符串就在常量池中。

class StringDemo 
{
	public static void main(String[] args) 
	{
		/*
		//String有一个空参数的构造方法String()，下面2种创建String类对象的方法是一样的，都是创建一个空的String对象
		String s = new String();
		String s1 = "";

		//s2是一个(String)类类型变量， "abc"是一个对象。字符串是一个特殊的对象！
		//字符串最大特点：一旦被初始化就不可以被改变。字符串既是一个常量，也是一个对象。
		String s2 = "abc";
		s2 = "lll";
		System.out.println(s2);//结果是“lll”
		//这种情况下，字符串“abc”并没有变化，还是在内存中，而s2指向了内存中的另一块区域“lll”。s2指向的地址变了，而“abc”对象的内容没有变化。
		*/
		
		//这一段参考文章：https://blog.csdn.net/zp357252539/article/details/82758877
		//视频是10分50秒处的解释
		//这种形式的赋值存放在常量池中而不是存放在堆中，下一次创建内容相同的String对象s3，仍然会指向该常量池中的内存。s1与s3指向同一个对象。
		String s1 = "abc";
		String s2 = new String("abc");
		String s3 = "abc";	
		
		System.out.println(s1==s2);//"=="比较的是内存地址值是否相同（false）
		System.out.println(s1.equals(s2));//String类复写了Object类中equals方法，该方法用于判断字符串内容是否相同。（true）
		//s1和s2有什么区别？（见视频13-1,7分钟开始处解释）：s1在内存中有一个对象，s2在内存中有2个对象
		System.out.println(s1==s3);//true
	}
}

2、String常见功能——获取和
  String类适用于描述字符串事物，那么它就提供了多个方法对字符串进行操作。常见的操作如下：

1、获取。
	1.1 字符串中的包含的字符数，也就是字符串的长度。
		int length():获取长度。
	1.2 根据位置获取位置上某个字符。
		char charAt(int index):
	1.3 根据字符获取该字符在字符串中位置。
		int indexOf(int ch):返回的是ch在字符串中第一次出现的位置。
		（注意，这个方法接受的是我们想获取字符的ASCII码，所以使用int类型）
		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) ：反向索引字符出现的位置。

2、判断。
	2.1 字符串中是否包含某一个子串。
		boolean contains(str)：indexOf(str):可以索引str第一次出现位置，如果返回-1.表示该str不在字符串中存在，所以，也可以用于对指定判断是否包含：if(str.indexOf("aa")!=-1)。	而且该方法即可以判断，又可以获取出现的位置。
	2.2 字符中是否有内容。
		boolean isEmpty(): 原理就是判断长度是否为0. 
	2.3 字符串是否是以指定内容开头。
		boolean startsWith(str);
	2.4 字符串是否是以指定内容结尾。
		boolean endsWith(str);
	2.5 判断字符串内容是否相同。复写了Object类中的equals方法。
		boolean equals(str);
	2.6 判断内容是否相同，并忽略大小写。
		boolean equalsIgnoreCase();

3、转换
	3.1 将字符数组转成字符串。
		构造函数：String(char[])
				  String(char[],offset,count):将字符数组中的一部分转成字符串。

		静态方法：
				static String copyValueOf(char[]);
				static String copyValueOf(char[] data, int offset, int count) 

				static String valueOf(char[]):

		
	3.2 将字符串转成字符数组。
		char[] toCharArray():

	3.3 将字节数组转成字符串。
			String(byte[])
			String(byte[],offset,count):将字节数组中的一部分转成字符串。

	3.4 将字符串转成字节数组。
			byte[]  getBytes():
	3.5 将基本数据类型转成字符串。
		static String valueOf(int)
		static String valueOf(double)
		//3+"";//String.valueOf(3);
		这两种方法是一样的，都是将int数据类型转换为String数据类型
		特殊：字符串和字节数组在转换过程中，是可以指定编码表的。

4、替换
	String replace(oldchar,newchar);

5、切割
	String[] split(regex);		

6、子串。获取字符串中的一部分。
	String substring(begin);
	String substring(begin,end);//注意end不包含在获取的字段

7、转换，去除空格，比较。
	7.1 将字符串转成大写或则小写。
		 String toUpperCase();
		 String toLowerCase();

	7.2 将字符串两端的多个空格去除。
		String trim();

	7.3 对两个字符串进行自然顺序的比较。
		int compareTo(string);

  相应的测试代码如下：

package pack;
class StringDemo 
{
	public static void main(String[] args) 
	{	
//		StringDemo.method_get();
//		StringDemo.method_is();
//		StringDemo.string_trans();
//		StringDemo.method_replace();
//		StringDemo.method_split();
//		StringDemo.method_sub();
		StringDemo.method_7();
	}
	//获取
	public static void method_get()
	{
		String str = "abcdefabcdef";
		
		//获取字符串长度
//"字符串str的长度为"+str.length():这一部分相当于一个String类的对象，我们在sop方法里面直接打印obj对象即可打印出相应的内容
		sop("字符串str的长度为："+str.length());
		//获取某个位置上的字符
		sop("字符串str第3位置上的字符为："+str.charAt(3));
		//获取字符与字符串在字符中第一次的位置
		sop("字符“c”在字符串中第一次出现的位置是："+str.indexOf('c'));
		sop("字符串“cd”在字符串中第一次出现的位置是："+str.indexOf("cde"));
		//从某个位置开始，获取字符与字符串在字符中的位置
		sop("从位置3开始，字符“c”在字符串中第一次出现的位置是："+str.indexOf('c',3));
		//反向索引字符出现的位置。
		sop("字符“c”,反向索引字符出现的位置是："+str.lastIndexOf('c'));
	}
	//判断
	public static void method_is()
	{
		String str = "abcdefabcdef";
		String str1 = "ABCDEFABCDEF";
		
		//字符串中是否包含某一个子串
		sop("str中包含“dd”？"+str.contains("dd"));
		
		if(str.indexOf("dd")!=-1)//如果没有查找到“dd”，就返回-1
			System.out.println("str中包含“dd”");
		else
			System.out.println("str中不包含“dd”");
		
		//字符中是否有内容
		sop("str是空的？"+str.isEmpty());
		//字符串以指定内容开始或者结尾
		sop("str以ab开头？"+str.startsWith("ab"));
		sop("str以ab结尾？"+str.endsWith("ab"));
		//内容是否相等
		sop(str.equals(str1));
		sop(str.equalsIgnoreCase(str1));//忽略大小写
	}
	//转换
	public static void string_trans()
	{
		char[] arr = {'a','b','c','d','f','g'};
		//通过构造方法创建字符数组的String对象
		String s1 = new String(arr);
		String s2 = new String(arr,2,3);
		//通过普通方法创建字符数组的String对象
		String s3 = String.copyValueOf(arr);
		String s4 = String.copyValueOf(arr, 2, 3);
		sop(s1);
		sop(s2);
		sop(s3);
		sop(s4);
		
//		将基本数据类型转成字符串
		String s5 = String.valueOf(2);
		String s6 = String.valueOf(2.456d);
		sop(s5);
		sop(s6);
		sop(2.5+"");//同样是将int数据类型转换为字符串
		
		//将字符串转成字符数组
		char[] arr2 = s1.toCharArray();
		//将字符串转成字节数组
		byte[] arr3 = s1.getBytes();
		for(int x=0;x<arr3.length;x++)
		{
			System.out.print(arr3[x]+" ");//97 98 99 100 102 103 :打印abcdef的ASCII码
		}	
	}
	//替换
	public static void method_replace()
	{
		String s1 = "hello java";
		String s2 = s1.replace('l', 'w');//如果要替换的字符不存在，返回的还是原串。
		sop(s2);
		//替换字符串
		String s3 = s1.replace("java", "world");
		sop(s3);
	}
	//切割
	public static void  method_split()
	{
		String s = "zhagnsa,lisi,wangwu";

		String[] arr  = s.split(",");//按照“,”将字符串切割为字符串数组，切割后“,”不会存在

		for(int x = 0; x<arr.length; x++)
		{
			sop(arr[x]);
		}
	}
	//子串
	public static void method_sub()
	{
		String s1 = "abcdefg";
		
		sop(s1.subSequence(2, 5));//从指定位置开始到结尾。如果角标不存在，会出现字符串角标越界异常。（注意这里5位置不包含在子串中）
		sop(s1.substring(3));
		sop(s1.substring(0,s1.length()));//获取整个字符串
		//获取子串也可以实现上面切割的功能，但是要先获取“,”的位置，再一部分一部分获取子串，比较麻烦
	}
	//转换，去除空格，比较
	public static void method_7()
	{
		String s1 = "  HELLO java  ";
		//大小写转换
		sop(s1.toLowerCase());
		sop(s1.toUpperCase());
		//去除两边空格
		sop(s1.trim());
		//对两个字符串进行自然顺序的比较
		String s2 = "a1c";
		String s3 = "aaa";
		//该比较基于字符串中各个字符的 Unicode 值，既ASCII码值
		sop(s2.compareTo(s3));//-48:第二个字符1的ASCII值是49，a的ASCII值是97,49-97=-48
	}
	
	
	//我们发现每一次打印都需要写那么多打印的代码，我们干脆将打印的功能封装成方法
	//由于基本数据类型都有其包装类（除了String），他们都是继承Object类，
	//因此我们可以使用Object类的对象来表示基本数据类型的对象，这是基本数据类型的向上类型转换
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

3、字符串练习
  练习1：实现trim()方法

/*
1、模拟一个trim方法，去除字符串两端的空格。
思路：
	1）判断字符串第一个位置是否是空格，如果是继续向下判断，直到不是空格为止。结尾处判断空格也是如此；
	2）当开始和结尾都判断到不是空格时，就是要获取的字符串。

*/
package pack;
class StringDemo 
{
	public static void main(String[] args) 
	{	
		String s1 = "   hello world  ";
		sop("("+s1+")");
		sop("("+myTrim(s1)+")");
	}

	public static String myTrim(String str)
	{
		//答案与我的思路是一样的，不过这里使用while循环会比for循环好
		int start = 0 , end = str.length()-1;//开头结尾用start与end表示更加好
		
		//首先start不得小于end否则说明整个str都是空格，那么trim方法也就没有意义。其次判断每一个字符是否为空格，用charAt获取字符
		while(start<=end && str.charAt(start) == ' ')//我们其实也可以写start++，但是这样while循环没有语句，因此将++设为while循环语句
			start++;
		//去除结尾空格也是一样的方法，从结尾判断过来。同样判断start<=end
		while(start<=end && str.charAt(end) == ' ')
			end--;
		//我们已经获取到了字符不为空段开头与结尾的下标，用获取子串方法substring(begin,end)
		return str.substring(start,end+1);//这里end记得+1，因为substring的最后一位不包含在获取的字段
	}

	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

  练习2：实现字符串反转与字符串指定部分的反转.
  先贴上自己的实现

/*
/*
2、将一个字符串进行反转；将字符串中指定部分进行反转，"abcdefg";abfedcg
思路：
	1）曾经学习过对数组的元素进行反转。
	2）将字符串变成数组，对数组反转。
	3）将反转后的数组变成字符串。
	4）只要将或反转的部分的开始和结束位置作为参数传递即可。
*/
package pack;
class StringDemo 
{
	public static void main(String[] args) 
	{	
		String s = "abcdefg";
		sop(s+"部分反转后的结果是："+reverseString(s,1,4));
		sop(s+"全部反转后的结果是："+reverseString(s));
	}
	//字符串指定内容反转方法
	public static String reverseString(String str , int start , int end)
	{
		char[] arr = str.toCharArray();//将字符串转换为字符串数组
		arr = arrayReverse(arr,start,end);
//		return String.copyValueOf(arr);
		//当然这里也可以利用构造方法将字符串数组转换为字符串
		return new String(arr);
	}
	//整个字符串反转的方法。这个方法我们可以重载指定内容反转的方法，这样比较方便！注意这种技巧！
	public static String reverseString(String str)
	{
		return  reverseString(str,0,str.length()-1);//调用字符串指定内容反转方法来实现全部反转的方法。
	}
	
	//数组内容反转的方法（该方法不需要暴露给外面，直接私有）
	private static char[] arrayReverse(char[] arr , int start , int end)
	{
//(end-start)/2的结果必然是int类型（2个int类型的变量做运算），因此如果start与end的差是1，(end-start)/2结果就是0，因此要加“=”，否则不会转换
		for(int x=0; x<=(end-start)/2 ; x++)
		{
			char temp = arr[start+x];
			arr[start+x] = arr[end-x];
			arr[end-x] = temp;
		} 
		//for循环部分不再引入多余变量x，而是直接用start与end表示
		for(; start<end ; start++,end--)
		{
			swap(arr,start,end);
		} 

		return arr;
	}
	//交换的方法
	private static void swap(char[] arr,int x,int y)
	{
		char temp = arr[x];
		arr[x] = arr[y];
		arr[y] = temp;
	}

	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

  下面是答案的实现：参考StringTest.java文件，和我的答案差不多！只要注意一般end不算在反转范围内即可。
  练习3：取两个字符串中最大相同子串（这一题比较有意思），先上自己的答案：

/*
4、取两个字符串中最大相同子串。第一个动作：将短的那个串进行长度一次递减的子串打印。
	"abcwerthelloyuiodef"
	"cvhellobnm"
	思路：1，将短的那个子串按照长度递减的方式获取到。（我们操作长度较小的字符串，这样操作的次数少一点）
		2，将每获取到的子串去长串中判断是否包含，如果包含，已经找到！。
*/
package pack;
class StringDemo 
{
	public static void main(String[] args) 
	{	
		String s1 = "cdlobn";
		String s2 = "abcdlobnm";
		sop("s1与s2的最大相同子串为："+getMaxSubString(s1,s2));
	}
	
	public static String getMaxSubString(String str1 , String str2)
	{
		String strMax = null;//创建变量strMax用于保存获取的最长子串，初始值赋值为null
		boolean breakSign = false;//设置跳出循环的标志
		//先取得str1与str2中长度较小者
		String shorterStr = str1.length()<=str2.length()? str1 : str2 ;
		//同样的方式取得str1与str2中长度较大者
		String longerStr = str1.length()>str2.length()? str1 : str2 ;
		
//首先，用外循环的变量x控制每一轮判断的最长子串的长度：x的最大值为shorterStr.length()，最小值应该大于0，x若小于0，判断的最长子串长度为零，便没有意义
		for(int x = shorterStr.length() ; x>0 ; x--)
		{
			//接下来，用内存循环变量y控制子串最开始取的位置，y从0开始，而每一次比较的最长子串长度为y+x
			//y+x的最大值必须小于等于shorterStr.length()
			for(int y = 0; y+x <= shorterStr.length() ; y++)
			{
				strMax = shorterStr.substring(y,y+x);
				if(longerStr.contains(strMax))
				{
//					break;注意！！！因为break只跳出一层循环，因此错误，我们设置一个跳出循环的标志来跳出外层循环
					breakSign = true;
					break;//先将跳出循环标记置true，再跳出这层循环
				}
				else
					strMax = null;//如果不存在我们必须将strMax重新置null，否则最后比较到不能比较的时候，strMax会变成shorterStr的最后一个字符
			}
			if(breakSign == true)
				break;//当breakSign为true的时候，跳出外层循环
		}
		
		return strMax;
	}

	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

  答案的方法

/*
注意：2种方法的区别不大，除了一些小技巧，最大的区别就是在2个for循环的时候变量设置不一样，可以试用答案的方法
*/

class  StringTest3
{
	/*
	练习四。
	*/
	public static String getMaxSubString(String s1,String s2)
	{

		String max = "",min = "";

		max = (s1.length()>s2.length())?s1: s2;

		min = (max==s1)?s2: s1;//这里取得最短子串的方法可以参考
		
//		sop("max="+max+"...min="+min);
		for(int x=0; x<min.length(); x++)//这里同样用x来控制每一轮比较子串的长度
		{//注意这里的技巧：设置一个y用来控制子串开头，而设置一个z用来控制子串的结尾。y与z是同增的，那么每一轮获得的子串长度都是一样的
			//当z增加到max.length()+1的时候，说明这一轮比较完毕。这里max.length()可以取到，因为下面的substring方法不会取到max.length()的点。
			for(int y=0,z=min.length()-x; z!=max.length()+1; y++,z++)
			{
				String temp = min.substring(y,z);
				
				sop(temp);
				if(max.contains(temp))//if(s1.indexOf(temp)!=-1)
					return temp;//获得最长子串则自接返回。不用break，用break还比较麻烦！
			}
		}
		return "";//没获得子串则返回空字符串，上面的连续break的方法跳出循环太麻烦了，找到直接return，最后没找到就return null就可以。
	}


	public static void main(String[] args) 
	{
		String s1 = "ab";
		String s2 = "cvhellobnm";
		sop(getMaxSubString(s2,s1));
	}

	public static void sop(String str)
	{
		System.out.println(str);
	}
}

4、StringBuffer类
  StringBuffer的特点如下：

StringBuffer是字符串缓冲区，是一个容器，长度可变化。因此其可以C create U update R read D delete（增删改查）（CURD）
特点：
1、长度是可变化的，既StringBuffer类字符串可以修改（修改内存中对象的内容），通过append(),insert()等方法修改这块内存区域的内容，对比String，String的对象一当创建便不可以修改，因此String没有这些方法。
2、可以直接操作多个数据类型。（数组一次只能操作一个类型）
3、最终会通过toString方法变成字符串。

什么时候使用：当我们要操作的数据类型不确定，数据个数不确定，最后要变成字符串，那么StringBuffer缓冲区是最方便的！

1、存储。
	StringBuffer append():将指定数据作为参数添加到已有数据结尾处。
	StringBuffer insert(index,数据):可以将数据插入到指定index位置。

2、删除。
	StringBuffer delete(start,end):删除缓冲区中的数据，包含start，不包含end。
	StringBuffer deleteCharAt(index):删除指定位置的字符。
	
3、获取。
	char charAt(int index) 
	int indexOf(String str) 
	int lastIndexOf(String str) 
	int length() 
	String substring(int start, int end) 
 
4、修改。
	StringBuffer replace(start,end,string);
	void setCharAt(int index, char ch) ;

5、反转。
	StringBuffer reverse();
 
6、	将缓冲区中指定数据存储到指定字符数组中。
	void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 

	
JDK1.5 版本之后出现了StringBuilder.

StringBuffer是线程同步。
StringBuilder是线程不同步。

以后开发，建议使用StringBuilder

升级三个因素：
1，提高效率。
2，简化书写。
3，提高安全性。

  添加功能

package pack;
class StringDemo 
{
	public static void main(String[] args) 
	{	
		StringBuffer sb1 = new StringBuffer();
		StringBuffer sb2 = sb1.append("def");
		sop(sb1.toString());//我们可以通过toString()方法将StringBuffer对象变为字符串String，打印的时候其实也可以直接输出
		sop(sb2.toString());
		sop(sb1==sb2);//true
		//2个的结果都是：def。sb1与sb2指向的是同一个对象（同一块内存）
		//也就是说，我们不需要再创建一个变量sb2来表示（因为只有一块内存），如下，如果我们想给sb3添加内容，直接调用append添加即可
		StringBuffer sb3 = new StringBuffer();
		sop(sb3.append("abc").append("acvdas").append("cdasv"));//调用链：对象调用一个方法还是返回哪个对象，就可以使用这种调用链（也叫做链式编程）
		
		//insert()方法
		StringBuffer sb4 = new StringBuffer("lkjlkj");
		sop(sb4.insert(3,"hhh"));//insert将第三位置及其以后的内容向后推，将“hhh”从第三位开始插入
	}
	
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

  删除、获取、修改、反转功能

package pack;
class StringDemo 
{
	public static void main(String[] args) 
	{	
		//删除
		StringBuffer sb1 = new StringBuffer("abcdefg");	
//		sb1.delete(1, 4);
//		sb1.deleteCharAt(2);
		//清空缓冲区
		sb1.delete(0, sb1.length());
		sop(sb1.toString());//一般都是用StringBuffer的方法先操作内存，再用toString()方法打印
		
		//获取较为简单，与String内容类型不多说
		
		//修改
		StringBuffer sb2 = new StringBuffer("abcdefg");
		sb2.replace(1, 4, "hhh").append('a');//返回StringBuffer类，可以使用调用链
		sb2.setCharAt(3, 'k');//返回void，不可以使用调用链
		sop(sb2.toString());
		//对于使用完还返回StringBuffer类的方法，他们并不会新增一块内存区域，还是操作原来的对象，那么他们就可以使用调用链
		
		//反转
		StringBuffer sb3 = new StringBuffer("abcdefg");
		sb3.reverse();
		sop(sb3.toString());
		
		//将缓冲区中指定数据存储到指定字符数组中
		StringBuffer sb4 = new StringBuffer("abcdefg");
		char[] arr = {'1','2','3','4','5','6','7','8','9'};
		sb4.getChars(1, 4, arr, 6);//获取sb4的1,2,3位的字符，并将其存储到字符串数组arr的6角标开始的位置
		for(int x=0; x<arr.length; x++)
		{
			sop(arr[x]);
		}
	}
	
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

5、StringBuilder类
  一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。
  一般单线程我们使用StringBuilder类，多线程使用StringBuffer，多线程也可以使用StringBuilder，我们自己加锁。
  Java的升级围绕3个部分：提高效率、简化书写、提高安全性

6、字符串相关重要知识补充
  关于String字符串2种创建方法所创建对象在内存中的分配方式，见如下文章：文章1
  需要注意的一点是jdk7之前是常量池是在方法区（永久代）中，之后的版本常量池（包括字符串池）则移到了堆中。
  另外，假如说的有String m = “abc”; ，这时的abc常量被保存在常量池中，如果我要在后面继续拼接一个d，也就是 m = m+“d”; 拼接成一个新的字符串常量，这时候就会在常量池中创建三个字符串常量，也就是说，这三个字符串常量就是adc、和我们拼接的d，和拼接之后adcd,所以说非常消耗内存的，我刚刚说的显示的字符常量存在于常量池里，而new 出来的String对象则存在于堆中。
  关于字符串的拼接，还可以参考如下文章：
文章2
String常量池与运行时常量池
字符串常量池，Class常量池、运行时常量池

  注意下面图片，“a”、“b”、“c”、“ab”、“abc”都是独立的数组，虽然他们存放在常量池中，但是最后会创建多个数组（字符串）。但是现在编译器会优化，直接将全部是字符串值的字符串自动视为一个字符串，既只有一个数组。

  再下面是StringBuilder的图解

  字符串常量池的分析——见就业班-day08-03视频。
  从JDK1.7开始，字符串常量池在堆里面，而Class常量池与运行时常量池仍然是在方法区。而且字符串常量池中保存字符串对象也是底层字节数组的地址值。具体图解如下：

  String类的相关方法说明

首先是String方法
public boolean equals(Object obj)：参数可以是任何对象，只有参数是一个字符串并且内容相同的才会给true；否则返回false。
注意事项：
1. 任何对象都能用Object进行接收。
2. equals方法具有对称性，也就是a.equals(b)和b.equals(a)效果一样。
3. 如果比较双方一个常量一个变量，推荐把常量字符串写在前面。
推荐："abc".equals(str)    不推荐：str.equals("abc")，原因如下代码：

String str5 = null;
System.out.println("abc".equals(str5)); // 推荐：false
//System.out.println(str5.equals("abc")); // 不推荐：报错，空指针异常NullPointerException

public boolean equalsIgnoreCase(String str)：忽略大小写，进行内容比较。

其次是split()方法

分割字符串的方法：
public String[] split(String regex)：按照参数的规则，将字符串切分成为若干部分。

注意事项：
split方法的参数其实是一个“正则表达式”，今后学习。
今天要注意：如果按照英文句点“.”进行切分，必须写"\\."（两个反斜杠）
这个"\\."在正则表达式中表示"."，如果只加一个"\"，就会被认为是转义字符，再加一个"\"，2个"\"加一个"."就表示是一个"."

String str3 = "XXX.YYY.ZZZ";
String[] array3 = str3.split(".");//应该写"\\."
System.out.println(array3.length); // 0
for (int i = 0; i < array3.length; i++) {
     System.out.println(array3[i]);
}