【java学习笔记】5字符串

我们在电脑上写作文或者撰写某软件系统的需求分析和设计方案时，Word文档里的一些句子和段落经常是一样的。为了避免重复输入，我i们通常会使用word的复制和粘贴功能。此外，在修改某些词语或者句子的时候，经常会使用Word的复制粘贴功能，此外们再修改某些词语或者句子的时候，经常会使用Word的查找和替换功能这些功能实质上都是在操纵字符串。
字符串是字符的序列。为了方便操控字符串，java语言在java.lang包中封装了两个类：String和StringBuffer。

1.字符串简介

java语言把字符串作为对象处理，主要原因是java是一种面向对象的程序设计语言。 通常可以使用类String和StringBuffer的对象来表示和处理字符串。

1.字符串常量

• 在java中，字符串常量是用双引号括起来的一串字符，如：“你今天身体好吗”
• 在Java中，可以通过一个字符串常量直接初始化一个String类型的对象。
• 字符串常量可以通过调用length()方法返回字符串中字符的个数。

2.String创建字符串对象

通过Java中的String类提供的构造方法可以生成一个空字符串，
字符数组、字符串对象、字符串缓冲区对象都可以生成一个字符串对象。

构造方法：比如你建一座房子，需要先打地基，再建框架，最后使用钢筋混凝土浇灌，这就是房子的构造方法。
正如同建造房子有很多种不同的方法，String类也有很多其他的构造方法

1. 用不同的方法创建字符串对象

//StringConstruction.java  String创造字符串对象的构造函数使用
package example;

public class StringConstruction {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		char s1[] = {'T','h','a','n','k'}; 				//声明并初始化字符串数组 s1
		char s2[] = {'T','h','a','n','k','s'};          //声明并初始化字符串数组 s2
		String str1 = new String(s1);					//用字符数组创建字符串对象，并且赋值给str1
		String str2 = new String(s2,0,5);				//用字符数组创建字符串对象，并且赋值给str2
		
		byte ascii1[] = {84,104,97,110,107};			//声明并初始化byte数组ascii1；
		byte ascii2[] = {84,104,97,110,107,115};		//声明并初始化byte数组ascii2；
		
		String str3 = new String(ascii1);               //用字符串数组创建字符串对象，并赋值给str3；
		String str4 = new String(ascii1,0,5);           //用字符串创建数组对象，并赋值给str4；
		String str5 = new String();						//创建一个空字符串对象，并赋值给str5；

		StringBuffer strbuf = new StringBuffer("Thank");//创建一个StringBuffer对象
		String str6 = new String(strbuf);				//使用StringBuffer对象创建字符串对象
		String str7 = new String("Thanks");				//创建并初始化字符串对象str7;	
		//下面是输出7个字符串的语句
		System.out.println("str1 = "+str1);
		System.out.println("str2 = "+str2);
		System.out.println("str3 = "+str3);
		System.out.println("str4 = "+str4);
		System.out.println("str5 = "+str5);
		System.out.println("str6 = "+str6);
		System.out.println("str7= " + str7);
	}
}

3.StringBuffer创建字符串对象

在生活中，总会遇到一些出乎意料的事情，而且往往让人手足无措。这个时候就必须提醒自己冷静，给自己一些时间和空间建立缓冲区，这样做出的效果一定会更好。
StringBuffer类是字符串的缓冲区，他可以支持对原字符串的修改，对字符串中任何子字符串的增加、删除、修改，以及将两个字符串合并成一个字符串而不需要建立新的字符串。
StringBuffer支持多线程，且具有线程安全性，每个字符串缓冲区对象都有一定的容量（存储空间），只要自付出啊缓冲区所包含的字符序列长度没有超出此容量，就无需分配寻得内部缓冲数组区。如果内存缓冲区空间不足导致溢出，则此容量自动增大。

1. StringBuffer创建字符串缓冲区的构造方法的使用示例。

package example;

public class StringBufferConstruct {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		StringBuffer strbuf1 = new StringBuffer();	    //创建空的字符串缓冲区
		StringBuffer strbuf2 = new StringBuffer(512);   //创建字符串缓冲区，并指定长度。
		//通过字符串创建字符串缓冲区
		StringBuffer strbuf3 = new StringBuffer("Are you ok?"); 
		//输出字符串缓冲区的长度
		System.out.println("StringBuffer1.length="+strbuf1.length());
		//输出字符串缓冲区容量
		System.out.println("StringBuffer1.capacity="+strbuf1.capacity());
		//输出字符串缓冲区的长度
		System.out.println("StringBuffer2.length="+strbuf2.length());
		//输出字符串缓冲区容量
		System.out.println("StringBuffer1.capacity="+strbuf2.capacity());
		//输出字符串缓冲区的长度
		System.out.println("StringBuffer3.length="+strbuf3.length());		
		//输出字符串缓冲区的容量
		System.out.println("StringBuffer3.length="+strbuf3.capacity());	
	}
}

2.连接字符串

生活中的很多东西是需要连在一起才能使用的，例如，两只筷子只有放在一起才能使用，钥匙和锁套配套才能使用。

针对字符串的所有操作中，字符串连接较为常见. 在java中可以通过"＋"运算符连接两个字符串，也可以通过"+" 运算符连接一个字符串和一个其他基本类型数据

与字符串的连接

与字符串的连接通过“+”完成。可以使用多个“+”组成一个长的新的字符串，也可以将一个长的字符串通过“+”拆成多个短的字符串。

与其他数据类型的连接

如果字符串与基本数据类型（int float double boolean long char）连接，则这些数据在连接前将直接被转换成字符串
java中，所有类都是Object类的子类，所有的类都间接或直接的继承了Object类的方法。其中，toString()方法用于将对象转换成字符串。

1. 字符串连接程序

package example;

public class StringLinkExample {
   public static void main(String[] args) {
   	// TODO Auto-generated method stub
   	Object obj = "Good";					//声明一个Obj对象obj,并且初始化
   	String str0 = "Morning";				//声明一个字符串变量str0
   	char ch1 = 'w';							//声明一个字符变量ch1,并赋值为'w'
   	boolean b = false;						//声明一个boolean类型变量类型b,并赋值
   	int i = 186;							//声明一个整型变量，并复制
   	double d1 = 7.20007;					//声明一个双精度变量d1,并赋值
   	
   	String str = obj + "|" + str0 +"|"+ch1 + "|" + b +"|" + i +"|"+ d1;		
   	System.out.println("输出的字符串为: "+str);
   }
}

3.String类操作

对String类的基本操作方法包括比较、转换、查找、截取、拆分等。
java中String类型的对象是不可以改变的，即String中的字符不能修改

1.基本操作方法

• 获取字符串长度的方法 ： length()
  -获取字符串第i个字符的算法 ：charAt(i)
  -获取指定位置的字符方法 : getChars()

返回字符串索引index处的char值，索引范围为0 ~ length() - 1 。序列第一个char值位于索引0处，第二个char值位于索引1处。以此类推。

复制的字符是从索引srcBegin处开始，到索引srcEnd-1处结束的，复制的字符总数是srcEnd-srcBegin。目标数组字符是从索引dstBegin开始，到索引dstBegin+（srcEnd-srcBegin）-1处结束的 。

返回字符串长度，实际上是Unicode编码单元的数量

正如同一个小学班级有40人，需要配备40套桌椅和位置给学生一样。在使用方法前，必须为字符数组或字节数组分配足够的空间以存放数据。

1. 演示使用字符串的基本操作方法

//StringBaswOpeMethod.java 	String类的基本操作方法
package example;

public class StringBaseOpenMethod {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String str = "该程序演示String类的基本操作方法";				//声明并初始化变量str
		System.out.println(str);								//str输出
		System.out.println("str.length()="+str.length());		//输出字符串的长度
		char ch3 = str.charAt(3);								//获取索引为3的字符，并且赋值给h3
		System.out.println("str.CharAt(3)="+ch3);      			//输出ch3
		char ch60 = str.charAt(3);								//	
		System.out.println("str.CharAt(3) = "+ch60);
		byte bytedst[] = new byte[80];							//创建包含80个元素的byte数组
		bytedst = str.getBytes();								//将字符串转换成byte数组
		System.out.println("getBytes()取得的byte数组的第14个Ascii码："+bytedst[14]);//输出byte数组的值
		char chardst[] = new char[8];							//创建char类型的数组
		str.getChars(14, 19, chardst, 0);						//通过getchars方法获得指定的字符数组
		System.out.print("GetChars取得的字符串中14~19的字符数组 ");  //输出字符串
		System.out.println(chardst);							//输出字符串数组、
	}
}

参考：https://blog.csdn.net/csdn_ds/article/details/79106006

2.比较

字符串比较大小指的是两个字符串从前到后逐个比较。比较的依据是字符串的Unicode值。
在比较字符串大小时，若单个字符不一样，则字符Unicode值较大的字符串较大。

Unicode码拓展自ASCII字源集。Unicode码能够表示世界上所有可书写语言中可能用于计算机通信的字源、象形文字和其他符号。

• compareTo()
• compareToIgnoreCase()
• equalsIgnoreCase()

1. 字符串比较的实例

package example;

public class StringCompareMethod {
	public static void main(String[] args) {
		// TODO Auto-generated method stubn
		String str1 = args[0];
		String str2 = args[1];
		System.out.println("Compare to:");
		if(str1.compareTo(str2)>0) {
			System.out.println(str1+" > "+str2);
		}else if(str1.compareTo(str2)==0) {
			System.out.println(str1+" = "+str2);
		}else {
			System.out.println(str1+" < "+str2);
		}
		System.out.println("CompareToIgnoreCase:");
	
		if(str1.compareToIgnoreCase(str2)==0) {
			System.out.println(str1+" = "+str2);
		}else {
			System.out.println(str1+" != "+str2);
		}
		System.out.println("equals");
		
		if(str1.equals(str2)) {
			System.out.println(str1+" = "+str2);
		}else {
			System.out.println(str1+" != "+str2);			
		}
		System.out.println("equalsIgnoreCase:");
		
		if(str1.equals(str2)) {
			System.out.println(str1+" = "+str2);			
		}else {
			System.out.println(str1+" != "+str2);
		}
	}
}

3.转换

生活中可以将面粉制作成面包和蛋糕，这就是从面粉转换到面包的过程。工业上可以将金属原来料经过加工转换成我们需要的产品（例：手机外壳）
java可以实现字符串与整数、浮点数或布尔数之间的转换。

//StringConvertExample.java 			String类转换方法的演示
package example;

public class StringConvertExample {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		boolean b = Boolean.parseBoolean("true");
		int i = Integer.parseInt("20");
		long l = Long.parseLong("2000");
		float f= Float.parseFloat("3.1875");
		double d = Double.parseDouble("3.175765");
		byte bt = Byte.parseByte("100");
		//字符串输出
		String strb = String.valueOf(b);
		String stri = String.valueOf(i);
		String strl = String.valueOf(l);
		String strf = String.valueOf(f);
		String strd = String.valueOf(d);
		
		System.out.println("boolean b ="+strb+"\n int i = "+stri +"\n long l "
				+ "= "+strl+"\n float f = "+f+"\n double d = "+strd+"\n byte bt = "+ bt);	
	}
}

4.查找

• int indexOf()
• int lastindexOf()

1. 通过调用indexOf()和lastindexOf()来判断字符串中是包含0、1还是2个以上指定字符。

package example;

public class StringSerachChar {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		String str = args[0];
		char ch = args[1].charAt(0);
		int p1 = str.indexOf(ch);
		int p2 = str.lastIndexOf(ch);
		if(p1>=0) {
			if(p1==p2) {
				System.out.println(str+"中找到一个字符"+ch);
			}else {
				System.out.println(str+"中至少有两字符"+ch);
			}
		}else {
			System.out.println(str+"中没有一个字符"+ch);
		}
	}

}

5.截取和拆分

正则表达式，又叫做正规表示法，它使用单个字符串来描述、匹配一系列的符合某个句法规则的字符串。

• public String substring()
• string[ ] split()

1. 调用subString() 方法返回某指定位置的子字符串，调用split()方法对字符串进行拆分。

package example;

public class StringCutandSpilt {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//声明并初始化字符串变量str
		String str = "How to cut and spilt string into a substring";
		int length = str.length();										//返回字符串长度
		System.out.println("请输入字符串的长度为："+length);					//打印输出字符串的长度
		int b = str.indexOf(' ');										//返回字符串中第一次出现空格的索引
		System.out.println("请输入字符串第一个空格索引为："+b);					//打印输出字符串的长度		
		int e = str.lastIndexOf(' ');									//返回字符串中最后一次出现空格的索引
		System.out.println("输入字符串最后一个空格索引为"+e);
		String strb = str.substring(0,b);
		String stre = str.substring(e+1,length);
		System.out.println("输入字符以开始的单词为"+strb);
		System.out.println("输入字符以结束的单词为"+stre);
		String strarray[] = str.split(" ");								//匹配正则表达式，并返回字符串数组
		System.out.println("输出字符用空格拆分后的词汇为");						//输出字符串
		//for循环语句，包含初始化变量、循环条件、步进表达式
		for(int i = 0;i<strarray.length;i++) {
			System.out.println(strarray[i]);							//输出字符串
		}	
	}
}

6.替换和修改

当我们编写一个Word文档时，如果需要替换或者修改其中的某些文本，如：将所有的“第一章“”替换成“第二章”，则需要用到Word中提供的替换或修改的功能，这个功能就是利用了字符串的替换或修改方法。
类String表示不变字符串，因此不能直接对他的内容进行修改，而是通过生成一个新的String类对象，同时完成对字符串的修改。

• String toLowerCase()
• public String replace(char oldChar,char newChar)
• public String replaceAll(String regex,String replacement)
• public String replaceFirst(String regex,String replacement)
• public String concat(String str)

1. 通过contcact方法，把两个字符串合在一起，并通过replaceFirst()方法，替换原来字符串的子字符串。

package example;

public class StringFindandReplace {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String str1 = "vbasic";
		System.out.println("str1 = :"+str1);
		
		String str2 = "Vbasic";
		System.out.println("str2 = :"+str2);
		
		String str = str1.concat(str2);
		System.out.println("contact合并字符串:"+str);
		
		String str3 = str1.toUpperCase();
		System.out.println("str1.toUpperCase() = :"+str3);
		String str4 = str2.toLowerCase();
		System.out.println("str2.toUpperCase() = :"+str4);
		
		String str5 = str1.replaceFirst("(?i)VBASIC", "C++");
		System.out.println("str1.replaceFirst() = :"+str5);
		
		String str6 = str1.replaceFirst("(?-i)VBASIC", "C++");		
		System.out.println("str1.replaceFirst() = :"+str6);
	}
}

4.StringBuffer类的操作

通过字符串缓冲区对象StringBuffer创建对象，可以在本对象中增加、删除和修改字符串的长度，并且不需要创建新的对象，而是在原有的字符串对象中进行修改。这是String类和StringBuffer类之间的最大区别。也是StringBuffer类的最大好处。

1.基本操作

• public int length()
• public int capacity()
• public Synchronized void ensureCapacity(int minimumCapacity)
• public Synchronized void setLength(int newLength)

String类对象之间可以通过运算符 + 相连，StringBuffer不可以通过 + 相连。
StringBuffer不可以通过equals()方法比较

1. 通过添加字符串、设置字符串的长度来分别查看字符串缓冲区的长度和容量

//StringBufferLength 通过添加字符串，设置字符串长度分别来查看字符串缓冲区长度的长度和容量

package example;

public class StringBufferLength {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		StringBuffer strbuf = new StringBuffer(8);			//创建指定长度的字符串缓冲区变量
		strbuf.append("abcdefg");							//给strbuff添加字符串
		System.out.println(strbuf.length());				//输出strbuf的长度
		System.out.println(strbuf.capacity());				//输出strbuf的容量
		System.out.println(strbuf.toString()+"**");			//strbuf转换为字符串并输出
		strbuf.setLength(10);								//strbuf的长度为10
		System.out.println(strbuf.length());				//输出strbuf的长度
		System.out.println(strbuf.capacity());				//输出strbuf的容量
		System.out.println(strbuf.toString()+"**");			//strbuf转换为字符串并输出
		strbuf.setLength(3);								//设置strbuf的长度为3
		System.out.println(strbuf.length());				//输出strbuf的长度
		System.out.println(strbuf.capacity());				//输出strbuf的容量		
		System.out.println(strbuf.toString()+"**");			//strbuf转换为字符串并输出		
	}
}

2. 通过添加字符串、设置字符串的长度来分别查看字符串缓冲区的长度和容量

package example;

public class StringBufCapacity {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		StringBuffer strbuf = new StringBuffer(6);
		strbuf.append("hello");
		System.out.println(strbuf.length());
		System.out.println(strbuf.capacity());
		System.out.println(strbuf.toString()+"***");
		strbuf.ensureCapacity(14);
		System.out.println(strbuf.length());
		System.out.println(strbuf.capacity());
		System.out.println(strbuf.toString()+"***");
		strbuf.ensureCapacity(5);
		System.out.println(strbuf.length());
		System.out.println(strbuf.capacity());
		System.out.println(strbuf.toString()+"***");
	}
}

2.字符串操作方法

• public synchronized char charAt(int index)
• public synchronized char getChars(int srcBegin,int srcEnd,char dst[],int dstBegin)
• public synchronized void setCharAt(int index, char ch)
• public synchronized StringBuffer deleteCharAt(int index)
• public synchronized StringBuffer delete(int start, int end)
• public synchronized StringBuffer replace(int start, int end, String str)
• public synchronized String substring(int start, int end)
• public synchronized int indexOf(String str)
• public synchronized int indexOf(String str, int fromIndex)
• StringBuffer.reverse()
• public synchronized void setCharAt(int index, char ch)

1. 该程序主要展示字符串缓冲区变量可以自由添加和删除子字符串的功能

package example;

public class StringBufBasicOpera {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		StringBuffer strbuf = new StringBuffer();		//创建字符串缓冲区变量
		//初始化变量strbuf
		strbuf = new StringBuffer("This program shows the method of StringBuffer");
		System.out.println("strbuf="+strbuf);			//输出strbuf
		//输出字符串缓冲区容量的变量
		System.out.println("strbuf.capaity()="+strbuf.capacity());
		//输出字符串缓冲区变量的长度
		System.out.println("strbuf.length()="+strbuf.length());
		strbuf.setCharAt(32, '!');
		System.out.println("strbuf="+strbuf);
		
		//输出指定索引位置的字符
		System.out.println("strbuf.charAt(5)="+strbuf.charAt(5));
		strbuf.setCharAt(5, 'P');
		char ch1[] = new char[10];
		strbuf.getChars(5, 8, ch1, 0);
		System.out.println("strbuf="+strbuf);
		System.out.println("ch1[0]="+ch1[0]);
		strbuf.delete(5, 11);
		strbuf.deleteCharAt(5);
		System.out.println("strbuf.deleteCharAt(5)="+strbuf);
		strbuf.replace(0, 4, "That");
		//输出替换后的字符串
		System.out.println("strbuf.replace(0,4,\"That\")"+strbuf);
		//输出指定位置的字符串
		System.out.println("strbuf.substring(6,12)="+strbuf.substring(6,12));
		//输出子字符串的位置索引
		System.out.println("strbuf.indexOf(\"of\")="+strbuf.indexOf("of"));
		strbuf.reverse();
		System.out.println("strbuf.reverse()="+strbuf);
	}
}

3.添加 append()

我们在写软件需求文档时，在写完功能等需求后，发现缺少对性能需求的描述，可以在该文档后面进行添加。
字符串添加可以使用append()进行实现。

StringBuffer类的append()方法和String类的Contact方法类似。本质区别在于String类添加字符串后创立新的字符串对象，而StringBuffer类是在原有的字符串的基础上进行修改。

添加的参数可以是布尔量、字符、字符数组、双精度数、浮点数等等。若添加的字符超出了字符串缓冲区的长度，则Java自动进行扩充

1. StringBuffer类的append方法使用示例

package example;

public class StringBuffferAppendMethod {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Object ob = "Good";//创建并初始化一个Object对象
		String str = "Morning";//创建并初始化字符串变量
		char ch[] = {'j','h','o','n'};//创建并初始化字符数组类型变量
		boolean b1 = false;//创建并初始化布尔类型变量
		char c = 'o';//创建并初始化字符变量
		int i =49;//创建并初始化整形变量
		double d = 1.234567;//创建并初始化双精度变量
		StringBuffer strbuf = new StringBuffer();//创建
		并初始化字符串缓冲区变量
		
		strbuf.append(ob+"|");						//将ob添加到strbuf
		strbuf.append(str+"|");						//将str添加到strbuf
		strbuf.append(ch);							//将ch添加到strbuf 
		strbuf.append("#");							//分隔符#添加到strbuf
		strbuf.append(b1);                          //将b1添加到strbuf
		strbuf.append("#");							
		strbuf.append(c);
		strbuf.append("#");
		strbuf.append(i);
		strbuf.append("#");
		strbuf.append(d);
		System.out.println(strbuf.toString());      //strbuf转换为字符串并输出	
	}
}

4.插入 insert()

正如前面提到的，我们在写软件需求文档时，在写完功能需求等内容后，发现缺少对性能需求的描述。则可以在文档后面进行添加。但是如果功能需求部分还不完整，怎么办呢？我们可以在功能需求部分插入新的功能需求分析内容。

StringBuffer类的insert()方法可以用来实现字符串缓冲区中插入新的数值
添加的参数可以是布尔量、字符、字符数组、双精度数、浮点数等等。若添加的字符超出了字符串缓冲区的长度，则Java自动进行扩充

1. StringBuffer类的insert()方法使用示例

package example;
public class StringBufferInsertMethod {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Object ob = "Good";//创建并初始化一个Object对象
		String str = "Morning";//创建并初始化字符串变量
		char ch[] = {'j','h','o','n'};//创建并初始化字符数组类型变量
		boolean b1 = false;//创建并初始化布尔类型变量
		char c = 'o';//创建并初始化字符变量
		int i =49;//创建并初始化整形变量
		double d = 1.234567;//创建并初始化双精度变量
		StringBuffer strbuf = new StringBuffer();//创建并初始化字符串缓冲区变量
		strbuf.insert(0, d);						//将ob添加到strbuf
		strbuf.insert(0,"#");						//将str添加到strbuf
		strbuf.insert(0,i);							//将ch添加到strbuf 
		strbuf.insert(0,"#");							//分隔符#添加到strbuf
		strbuf.insert(0,c);                          //将b1添加到strbuf
		strbuf.insert(0,"#");							
		strbuf.insert(0,b1);
		strbuf.insert(0,"#");
		strbuf.insert(0,ch);
		strbuf.insert(0,"|");
		strbuf.insert(0,str);
		strbuf.insert(0,"|");
		System.out.println(strbuf.toString());      //strbuf转换为字符串并输出		
	}
}

5.拓展训练

(***)1.字符串大小写转换

在程序设计中，经常遇到大小写转换的情况。例如，在验证用户登录时，如果用户名不区分大小写，那么在代码中应当排除字母大小写情况，然后再对比系统存储中的用户名和输入的用户名是否一致。

package example;

import java.awt.EventQueue;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.ButtonGroup;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JRadioButton;
import javax.swing.JTextField;
import javax.swing.UIManager;

public class SwingLoginExample extends JFrame {

    private JTextField inputTextField;
    private JTextField outputTextField;
    private final ButtonGroup buttonGroup = new ButtonGroup();

    public static void main(String[] args) {
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                try {
                    SwingLoginExample frame = new SwingLoginExample();
                    frame.setVisible(true);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }

    //Create the frame.
    public SwingLoginExample() {
        setTitle("字符串大小写转换");
        setBounds(100, 100, 450, 250);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        getContentPane().setLayout(null);

        inputTextField = new JTextField();
        inputTextField.setBounds(23, 21, 383, 31);
        getContentPane().add(inputTextField);
        inputTextField.setColumns(10);

        JButton button = new JButton("\u8F6C\u6362");//转换
        button.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent arg0) {
                do_button_actionPerformed(arg0);
            }
        });
        button.setBounds(23, 77, 93, 23);
        getContentPane().add(button);

        JRadioButton radioButton = new JRadioButton("大写");
        radioButton.setActionCommand("大写");
        radioButton.setSelected(true);
        radioButton.setBounds(169, 77, 76, 23);
        buttonGroup.add(radioButton);
        getContentPane().add(radioButton);

        JRadioButton radioButton_1 = new JRadioButton("小写");
        radioButton_1.setBounds(280, 77, 121, 23);
        radioButton_1.setActionCommand("小写");
        buttonGroup.add(radioButton_1);
        getContentPane().add(radioButton_1);
        
        outputTextField = new JTextField();
        outputTextField.setEditable(false);
        outputTextField.setColumns(10);
        outputTextField.setBounds(23, 122, 383, 31);
        getContentPane().add(outputTextField);
        @SuppressWarnings("unused")
        String strBook = "MingRiBook".toLowerCase();
    }

    protected void do_button_actionPerformed(ActionEvent arg0) {
        // 获取大小写单选项的选择
        String command = buttonGroup.getSelection().getActionCommand();
        boolean upper = command.equals("大写");// 判断是否选择的大写单选项
        String text = inputTextField.getText();// 获取输入字符串
        if (upper) {// 大写转换
            outputTextField.setText(text.toUpperCase());
        } else {// 小写转换
            outputTextField.setText(text.toLowerCase());
        }
    }
}

2. 当前日期格式化

package example;
import java.util.Date;
import java.util.Locale;

public class DateStringFormat {

   public static void main(String[] args) {
   	// TODO Auto-generated method stub
   	Date today = new Date();
   	String a = String.format(Locale.US, "%tb",today);
   	System.out.println("格式化后的字符串为月份的英文缩写："+ a);
   	String b = String.format(Locale.US, "%tB",today);
   	System.out.println("格式化后的字符串为月份的英文全写："+ b);
   	String c = String.format(Locale.US, "%ta",today);
   	System.out.println("格式化后的字符串为星期："+ c);
   	String d = String.format(Locale.US, "%tA",today);
   	System.out.println("格式化后的字符串为星期："+ d);
   	String e = String.format(Locale.US, "%tY",today);
   	System.out.println("格式化后的字符串为4位的年份值："+ e);
   	String f = String.format(Locale.US, "%ty",today);
   	System.out.println("格式化后的字符串为2位的年份值："+ f);
   	String g = String.format(Locale.US, "%tm",today);
   	System.out.println("格式化后的字符串为2位的月份值："+ g);
   	String h = String.format(Locale.US, "%td",today);
   	System.out.println("格式化后的字符串为2位的日期值："+ f);
   }	
}

字符串是不可变对象。字符串的不可变性意味着每当对字符串进行操作时，都会产生一个新的字符串对象。如果频繁地操作字符串对象，会在托管堆中产生大量的无用字符串，增加垃圾回收器压力，从而造成资源浪费

3. 验证IP地址有效性
   IP地址是网络上每台计算机的标识，在浏览器中输入的网址也是要根据DNS服务转换为IP地址才能找到服务器的。

package example;
import java.util.Scanner;

public class IsVaild {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入一个IP地址：");
		String result = IsVaildIP(scan.next());
		System.out.println(result);
	}
	public static String IsVaildIP(String text) {
		if(text!=null&&!text.isEmpty()) { 
			String regex ="(^((2[0-4]\\d.)|(25[0-5].)|(1\\d{2}.)|(\\d{1,2}.))"
					+ "((2[0-5]{2}.)|(1\\d{2}.)|(\\d{1,2}.){2})"
					+ "((1\\d{2})|(2[0-5]{2})|(\\d{1,2})))";
		if(text.matches(regex)) {
			return text + "\n是一个合法的IP地址";
		}else {
			return text + "\n不是一个合法的IP地址";
		}	
	}
		return "请输入要验证的IP地址";
	}
}

在正则表达式中，“”.”表示任意一个字符。需要使用 . 时，前面要加“”/”

4.获取字符串中单词的个数。

package example;

public class GetChineseNum {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String str1 = args[0];
		String str2 = args[1];
		String str[] = str1.split(str2);
		int count = 0;
		if(str1.lastIndexOf(str2)==(str1.length()-str2.length())) {
			count = str.length;
		}else {
			count = str.length-1;
		}
		System.out.println(str1+"出现了"+count+"次"+str2);
	}
}
``
*频繁修改字符串的时候，可以使用StringBuffer类。因为StringBuffer不会产生新的对象。更适合修改字符串*

![在这里插入图片描述](https://img-blog.csdnimg.cn/3ea5c1ce2c3f44a09db5758a0a25d250.png)
# 6.技术解惑
## 1.String类和StringBuffer类有什么区别
**String类对象一旦产生后就不能被修改，而StringBuffer对象可以被修改。**
StringBuffer在进行字符串处理时不产生新的对象，如果需要经常对一个字符串进行修改操作，则使用StringBuffer类
StringBuffer效率要比String多。另外，StringBuffer类是线程安全的，在多线程程序中也可以使用。
## 2.String类为什么不可变
**String是final类，这意味着不允许任何人定义String类的子类**，Java在运行时保存了一个字符串池。 
1）只有当字符串是不可变时，字符串池才有可能实现，因为不同生物字符串变量都指向池中同一个字符串。如果值发生了变化，其他指向这个值的变量的值也会发生改变。
2）字符串是可变的，会造成安全问题。比如数据库的用户名、密码都以字符串的的形式传入。字符串不可变，所以值也不变。
3）字符串不可变，多线程安全，同一个字符串实例可以被多个线程共享。不可变性提供了安全性。