第十章总结

该方法提取文字符数组a中的一部分创建一个字符串对象，参数offset表示开始截取字符串的位置，length表示截取字符串的长度

char a[ ] ={'s','t','u','d','e','n','t'};

===>等价于strings=new string("uden");

string s=new string (a,2,4)

字符串常量的引用赋值来创建字符串

除了以上几种使用String类的构造方法来创建字符串变量外，还可以通过将字符串常量的引用赋值给一个字符串来创建字符串。代码如下：
String str,str2;
str="we are str";
str2="we are str2";

package Packages1;

public class Test1 {

	public static void main(String[] args) {
		//字符串变量的声明 
		String s;
		//字符串变量初始化
		s="你好";
		s=new String("你好");
		System.out.println(s);
		//字符串变量初始化，传入字符类型数组
		char[]ch = {'g','o','o','d'};
		String st=new String(ch);
		System.out.println(st);
		//字符串变量初始化，传入字符类型数组，两个数字
		char[]cha = {'s','t','u','d','e','n','t'
		};
		String str=new String(cha,2,4);
		System.out.print(str);
		//字符串链接
		System.out.print(s+str);
		//字符串与其他类型相连接
		System.out.print(1.6+str+3);
}
}

二、连接字符串

1、连接多个字符串

使用“+”运算符可实现连续多个字符串的功能。“+”运算符可以连接多个string对象并产生一个新的对象string对象

public class Test1 {//创建类

	public static void main(String[] args) {//主方法
		String s1=new String("春风绿十里");//声明string对象s1
		String s2=new String("马蹄香万家");//声明string对象s2
		String s=s1+"\n"+s2;//将对象s1、“、n”和对象s2连接并将结果赋值给s
		System.out.print(s);//将s输出
		}
}

2、连接其他数据类型

字符串也可同其他基本数据类型进行比较，如果将字符串同其他数据类型进行连接，会将其他数据类型的数据直接转换成字符串。

public class Test1 {//创建类

	public static void main(String[] args) {//主方法
		int booktime=4;//声明的int型变量booktime
		float practice=2.5f;//声明的float型变量practice
		//将字符串与整型、浮点型变量相连，并将结果输出
		System.out.print("我每天花费"+booktime+"小时看书；"+practice+"小时上机练习");
	}
}

三、获取字符串信息

1、获取字符串长度

使用string类的length（）方法可获取声明的字符串对象的长度

语法：

str.length();

str:字符串对象

获取字符串长度

语法：

string str="we are students";

int size =str.lenth();


public class Test1{
	public static void main(String args[]) {
		String str="hello world";//定义字符串str
		char mychar=str.charAt(6);//将字符串str中索引位置是6的字符返回
		System.out.println("字符串str中索引位置是6的字符为："+mychar);//输出信息
	}
}

2、字符串查找

string类提供了两种查找字符串的方法，即indexOf（）与lastIndexOf()方法。这两种方法都允许在字符串中搜索指定条件的字符或字符串，indexOf（）方法返回的是搜索的字符或字符串首次出现的位置，lastIndexOf（）方法返回的是搜索的字符或字符串最后一次出现的位置。

indexOf（string s）

该方法用于返回参数字符串S在指定字符串中首次出现的索引位置，当调用string类的indexOf（）方法时，会从当前字符串的开始位置搜索S的位置，如果没有检索到字符串S该方法的返回值是-1

语法：

str.indexOf（substr）

str:任意字符串对象

substr：要搜索的字符串

//查早字符串第一次出现该元素的位置
		int indexOf=str.indexOf("l");
		System.out.println(indexOf);

lastindexOf（string str）

该方法用于返回指定字符串最后一次出现的索引位置。当调用string类的lastIndexOf（）方法时，会从当前字符串的开始位置检索数字字符串str，并将最后一次出现在str的索引位置返回，如果没有检索到字符串str该方法返回-1

语法：

str.lastindexOf(substr)

str:任意字符串对象

substr:要搜索的字符串

public class Test1{
	public static void main(String args[]) {
		String str="We are students";//定义字符串str
		int size=str.lastIndexOf("");//将空字符串在str中的索引位置赋值给变量size
		System.out.println("空字符串在字符串str中的索引位置是："+size);//将变量size输出
		System.out.println("字符串str的长度是："+str.length());//将字符串str的长度输出
}
}

四、字符串操作

1、获取子字符串

通过string类的sudstring（）方法可对字符串进行截取

substring（int beginlndex）

该方法返回值的是从指定的索引位置开始截取直到该字符串结尾的子串

语法：

str.substring（int beginlndex）

beginlndex:指定从某一处索引开始截取字符串

//获取子串
	String str=new String("helloworld");
		String substring1=str.substring(3);
		System.out.println(substring1);

substring（int beginlndex，int endlndex）

该方法返回的是从字符串某一索引位置开始截取至某一索引位置结束的子串

语法：

substring（int beginlndex，int endlndex）

beginlndex:开始截取子字符串的索引位置

endlndex：子字符串在整个字符串的结束位置

public class Test1{
	public static void main(String args[]) {
		String str="《将进酒》：李白（唐）";//定义的字符串
		String substr=str.substring(6,8);//对字符串进行截取
		System.out.println("《将进酒》的作者是"+substr);//输出截取后的字符串
	}	
}

2、去除空格

trim（）方法返回字符串的副本，忽略前导空格和尾部空格

语法：str.trim

str:为任意字符串对象

public class Test1{
	public static void main(String args[]) {
		String str="  Java  class   ";//定义字符串str
		System.out.println("字符串原来的长度："+str.length());//将str原来的长度输出
		//将str去掉前导和尾部的空格后的长度输出
		System.out.println("去掉空格后的长度："+str.trim().length());
	}

}

3、字符串替换

replace（）方法可实现将指定的字符或字符串替换成新的字串或字符串

语法：str. replace(CharSequence target,CharSequence,replacement)

target:要替换的字符或字符串

replacement:用于替换原来字符串的内容

replace（）方法返回的结果是一个新的字符串。如果字符或字符串oldChar没有出现在该对象表达式中的字符串序列中，则将原字符串返回


public class Test1{
	public static void main(String args[]) {
		String str="address";//定义字符串str
		String newstr=str.replace("a","A");//将str中“a”替换成"A"并返回新字符串newstr
		System.out.println(newstr);//将字符串newstr输出
	}
}

4、判断字符串的开始与结尾

startsWith（）方法与endsWith（）方法分别用于分别于判断字符串是否指定的内容开始或结束。这两个方法的返回值都为boolean类型

startsWith（）方法

该方法用于判断当前字符串对象的前缀是否为参数指定的字符串

语法：

str.startsWith(string prefix)

prefix:指作为前缀的字符串

//判断字符串开头
		String num1="22045612";
		boolean b1=num1.startsWith("22");
		System.out.println(b1);

endsWith()方法

该方法用于判断当前字符串是否为以给定的子字符串结束

语法：

str. endsWith(string suffix)

suffix:指作为后缀的字符串

public class Test1{
	public static void main(String args[]) {
		String num1="22045612";//定义字符串num1
		String num2="21304578";//定义字符串num2
		boolean b=num1.startsWith("22");//判断字符串num1是否以‘22’开头
		boolean b1=num2.endsWith("78");//判断字符串num1是否以‘78’结束
		System.out.println("字符串num1是以‘22’开始的吗？"+b);
		System.out.println("字符串num2以‘78’结束的吗？"+b1);//输出信息
	}
}

5、判断字符串是否相等

对字符串对象进行比较不能简单地使用比较运算符“==”,因为比较运算符比较的是两个字符串的地址是否相同。即使两个字符串的内容相同，两个对象的内存地址也是不同的，使用比较运算符仍然会返回 false。使用比运算符比较两个字符串，

要比较两个字符串内容是否相等，应使用 equals0方法和equalsIgnoreCase0方法。

equals()方法

如果两个字符串具有相同的字符和长度，则使用equals0方法进行比较时，返回 true。否则false。

语法：

str.equals(String otherstr)

str、otherstr是要比较的两个字符串对象

equalslgnoreCase()方法

使用equals0方法对字符串进行比较时是区分大小写的，而使用equalsIgnoreCase0方法是在!大小写的情况下比较两个字符串是否相等，返回结果仍为 boolean 类型。

语法：

strequalslgnoreCase(String otherstr)

str、othersr 是要比较的两个字符串对象。

public class Test1{
	public static void main(String args[]) {
		String s1=new String("abc");//创建字符串对象s1
		String s2=new String("ABC");//创建字符串对象s2
		boolean b=s1.equals(s2);//使用equals()方法比较s1与s2
		boolean b1=s1.equalsIgnoreCase(s2);//使用equalsIgnoreCase()方法比较s1与s2
		System.out.println(s1+"equals"+s2+":"+b);
		System.out.println(s1+"equalsIgnoreCase"+s2+":"+b1);
	}
}

6、按字典顺序比较两个字符串

compareTo0方法为按字典顺序比较两个字符串,该比较基于字符串中各个字符的Unicode 值，按字典顺序将 String对象表示的字符序列与参数字符串所表示的字符序列进行比较。如果按字典顺序此 String 对象位于参数字符串之前，则比较结果为一个负整数;如果按字典顺序此 String 对象位于参数字符串之后，则比较结果为一个正整数;如果这两个字符串相等，则结果为 0。

语法：

str.compareTo(String otherstr)

str、otherstr 是要比较的两个字符串对象

public class Test1{
	public static void main(String args[]) {
//用于比较的3个字符串
		String str=new String("b");
		String str2=new String("a");
		String str3=new String("c");
		System.out.println(str+"compareTo"+str2+":"+str.compareTo(str2));//将str与str2比较的结果输出
		System.out.println(str+"compareTo"+str3+":"+str.compareTo(str3));//将str与str2比较的结果输出
	}
}

7、字母大小写转换

String 类的 toLowerCase0方法可将字符串中的所有大写字母改写为小写字母，而 toUpperCase0方法可将字符串中的所有小写字母改写为大写字母。

toLowerCase()方法

该方法将字符串中的所有大写字母转换为小写。如果字符串中没有应该被转换的字符，则将原符串返回:否则将返回一个新的字符串，将原字符串中每个大写字母都转换成小写，字符串长度不变

语法：

str.toLowerCase()

str 是要进行转换的字符串

toUpperCase()方法

该方法将字符串中所有的小写字母转换为大写。如果字符串中没有应该被转换的字符，则将原符串返回;否则返回一个新字符串，将原字符串中每个小写字母都转换成大写，字符串长度不变。

语法：
str.toUpperCase()

str 是要进行转换的字符串

public class Test1{
	public static void main(String args[]) {
		String str=new String("oh My God");//创建字符串str
		String newstr=str.toLowerCase();//使用toLowerCase()方法实行小写转换
		String newstr2=str.toUpperCase();//使用toUpperCase()方法实行小写转换
		System.out.println(newstr);
		System.out.println(newstr2);
	}
}

8、字符串分割

使用split0方法可以使字符串按指定的分割字符或字符串进行分割，并将分割后的结果存放在字符串数组中。split0方法提供了以下两种字符串分割形式

split(String sign)

该方法可根据给定的分割符对字符串进行拆分。

语法：
str.split(String sign)

sign 为分割字符串的分割符，也可以使用正则表达式

split(String sign,int limit)

该方法可根据给定的分割符对字符串进行拆分，并限定拆分的次数

语法:
str.split(String sign,int limit)

sign:分割字符串的分割符，也可以使用正则表达式口

limit:限制的分割次数

public class Test1{
	public static void main(String args[]) {
		String str="192.168.0.1";
		String[]firstArray=str.split("\\.");//按照”.“进行分割，使用转义字符串”\\.“
		String[]secondArray=str.split("\\.",2);//按照”.“进行两次分割，使用转义字符串”\\.“
		System.out.println("str的原值为：["+str+"]");//输出str原值
		System.out.print("全部分割的结果：");//输出全部分割的结果
		for(String a:firstArray) {
			System.out.print("["+a+"]");
		}
		System.out.println();//换行
		System.out.print("分割两次的结果：");
		for(String a:secondArray) {
			System.out.print("["+a+"]");	
			}
		System.out.println();
	}

}

代码总结：

package Packages1;

public class Test2 {

	public static void main(String[] args) {
		//获取字符串的长度
		String str=new String("helloworld");
		int length= str.length();
		System.out.println(length);
		//查早字符串第一次出现该元素的位置
		int indexOf=str.indexOf("l");
		System.out.println(indexOf);
		//查早字符串最后一次出现该元素的位置
		int lastIndexOf=str.lastIndexOf("l");
		System.out.println(lastIndexOf);
		//获取指定索引号的字符
		char charAT=str.charAt(5);
		System.out.println(charAT);
		//10.4字符串操作
		//获取子串
		String substring1=str.substring(3);
		System.out.println(substring1);
		//获取字串substring（前索引，后索引）前含后不含
		String substring2=str.substring(3,5);
		System.out.println(substring2);
		//去除首尾空格
		String st="   java   class    ";
		System.out.println(st+"长度为"+st.length());
		String s=st.trim();
		System.out.println(s+"长度为"+s.length());
		//字符串的替换
		String stri="address";
		String replace=stri.replace("a","A");
		System.out.println(replace);
		//判断字符串开头
		String num1="22045612";
		boolean b1=num1.startsWith("22");
		System.out.println(b1);
		//判断字符串结尾
		String num2="21304578";
		boolean b2=num1.startsWith("78");
		System.out.println(b2);
		//判断字符串是否相等
		String str1 =new String("abc");
		String str2 =new String("abc");
		boolean b=(str1==str2);
		System.out.println(b);
		boolean equals=str1.equals(str2);
		System.out.println(equals);
		String str3=new String("ABC");
		boolean equalsIgnore=str1.equalsIgnoreCase(str3);
		System.out.println(equalsIgnore);
		//按照Unicode值去比较两个字符串的顺序
		String st1="a";
		String st2="b";
		String st3="c";
		System.out.println(st1.compareTo(st2));//前和后比较返回-1
		System.out.println(st2.compareTo(st2));//自己和自己比较返回0
		System.out.println(st3.compareTo(st2));//后和前比较返回1
		//字符的大小写转换
		String s1="Oh My God!";
		System.out.println(s1.toCharArray());
		System.out.println(s1.toUpperCase());
		//字符串的分割
		String strin="192.168.0.1";
		String []split1=strin.split("\\.");
		for(String temp:split1) {
		System.out.println(temp);
	}
		String stri1="192.168.0.1";
		String []spli1=stri1.split("\\.2");
		for(String temp:split1) {
		System.out.println(temp);
	}

}
}

代码运行结果总结：

五、格式化字符串

String类的静态format0方法用于创建格式化的字符串。format0方法有两种重载形式

format(String format,Object...args)

该方法使用指定的格式字符串和参数返回一个格式化字符串，格式化后的新字符串使用本地默的语言环境。

语法:
str.format(String format,Object...args)

format:格式字符串

args: 格式字符串中由格式说明符引用的参数。如果还有格式说明符以外的参数，则忽略这些额外的参数。此参数的数目是可变的，可以为 0。

format(Local lString format,Object...args)

该方法使用指定的语言环境、格式字符串和参数返回一个格式化字符串，格式化后的新字符串使用其指定的语言环境。

语法:
str.format(Local 1,String format,Object...args)
1:格式化过程中要应用的语言环境。如果1为nul1，则不进行本地化

format:格式字符串

args: 格式字符串中由格式说明符引用的参数。如果还有格式说明符以外的参数，则忽略这额外的参数。此参数的数目是可变的，可以为 0

1、日期和时间字符串格式化

在应用程序设计中，经常需要显示日期和时间。如果想输出满意的日期和时间格式，一般需要写大量的代码、经过各种算法才能实现。frmat方法通过给定的特殊转换符作为参数来实现对日期时间的格式化。

//日期与时间格式化
		Date date=new Date();
		System.out.println(date);

日期格式化

//日期格式化
		String year=String.format("%tY",date);
		String month=String.format("%tm",date);
		String day=String.format("%td",date);
		System.out.println(year+"年"+month+"月"+day+"日");

常用的日期格式化转换符

import java.util.Date;//导入java.util.Date类
public class Test1{
	public static void main(String args[]) {
		Date date=new Date();//创建Date对象date
		String year=String.format("%tY",date);//将date进行格式化
		String month=String.format("%tB",date);
		String day=String.format("%td",date);
		System.out.println("今年是："+year+"年");//输出信息
		System.out.println("现在是："+month);
		System.out.println("今天是："+day+"号");
	}
}

时间格式化

使用format0方法不仅可以完成日期的格式化，也可以实现时间的格式化。时间的格式化转换符要比日期的格式化转换符影多、更精确，它可以将时间格式化为时、分、秒、毫秒等。

//时间格式化
		String hour=String.format("%tH",date);
		String minute=String.format("%tM",date);
		String second=String.format("%tS",date);
		System.out.println(hour+"时"+minute+"分"+second+"秒");

时间格式化转换符

格式化常见的日期时间组合

格式化日期与时间组合的转换符定义了各种日期时间组合的格式

//常用日期时间组合格式化
		String dateFormat=String.format("%tF", date);
		String timeFormat=String.format("%tT", date);
		System.out.println(dateFormat+" "+timeFormat);

常见的日期和时间组合的格式

代码总结：

package Packages1;
import java.util.Date;
public class Trst4 {
	public static void main(String[] args) {
		// 10.5格式化字符串
		//String格式化后的字符串=String.format (格式，字符串);
		//日期与时间格式化
		Date date=new Date();
		System.out.println(date);
		//日期格式化
		String year=String.format("%tY",date);
		String month=String.format("%tm",date);
		String day=String.format("%td",date);
		System.out.println(year+"年"+month+"月"+day+"日");
		//时间格式化
		String hour=String.format("%tH",date);
		String minute=String.format("%tM",date);
		String second=String.format("%tS",date);
		System.out.println(hour+"时"+minute+"分"+second+"秒");
		//常用日期时间组合格式化
		String dateFormat=String.format("%tF", date);
		String timeFormat=String.format("%tT", date);
		System.out.println(dateFormat+" "+timeFormat);
		
	}

}

代码运行结果总结：

2、常规类型格式化

常规类型格式化可应用于任何参数类型

常见转换符

package Packages1;

public class General {//新建类

	public static void main(String[] args) {//主方法
		String str=String.format("%d", 400/2);//将结果以十进制格式转换
		String str2=String.format("%b", 3>5);//将结果以boolean型结果
		String str3=String.format("%x", 200);//将结果以十六进制格式转换
		//输出格式化字符串
		System.out.println("400的一半是："+str);
		System.out.println("3>5正确吗："+str2);
		System.out.println("200的十六进制数是："+str3);
	}

}

六、使用正则表达式

正则表达式通常被用于判断语句中，用来检查某一字符串是否满足某一个格式。正则表达式是含有一些具有特殊意义字符的字符串，这些特殊字符称为正则表达式的云字符。

限定修饰符

限定修饰符	意义	示例	限定修饰符	意义	示例
？	0次或1次	A？	{n}	正好出现n次	A{2}
*	0次或多次	A*	{n，}	至少出现一次	A{3，}
+	一次或多次	A+	{n，m}	出现N~m次	A{2，6}

public class General {//新建类

	public static void main(String[] args) {//主方法
		String regex="\\w+@\\w+(\\.\\w{2,3})*\\.\\w{2,3}";//定义要匹配E-mail地址的正则表达式
		String str1="aaa@";//定义要进行验证的字符串
		String str2="aaaaa";
		String str3="1111@111ffyu.dfg.com";
		if(str1.matches(regex)) {//判断字符串变量是否与正则表达式匹配
			System.out.print(str1+"是一个合法的E-mail地址格式");
		}
		if(str2.matches(regex)) {
			System.out.print(str2+"是一个合法的E-mail地址格式");
		}
		if(str3.matches(regex)) {
			System.out.print(str3+"是一个合法的E-mail地址格式");
		}
		//QQ邮箱
		String re="\\d{5,12}@qq.com";
	}
}

七、字符串生成器

创建成功的字符串对象，其长度是固定的，内容不能被改变和编译。虽然使用“+”可以达到附新字符或字符串的目的，但“+”会产生一个新的 String 实例，会在内存中创建新的字符串对象。如重复地对字符串进行修改，将极大地增加系统开销。而JDK 新增了可变的字符序列 StringBuilder天大大提高了频繁增加字符串的效率

public class General {//新建类

	public static void main(String[] args) {//主方法
		String str="";//创建空字符串
		long starTime=System.currentTimeMillis();//定义对字符串执行操作的起始时间
		for(int i=0;i<10000;i++) {//利用for循环执行10000次操作
			str=str+i;//循环追加字符串
		}
		long endTime=System.currentTimeMillis();//定义对字符串操作后的时间
		long time=endTime-starTime;//计算对字符串执行操作的时间
		System.out.println("String消耗时间："+time);//将执行的时间输出
		StringBuilder builder=new StringBuilder("");//创建字符串生成器
		starTime=System.currentTimeMillis();//更新操作执行前的时间
		for(int j=0;j<10000;j++) {//利用for循环进行操作
			builder.append(j);//循环追加字符
		}
		endTime=System.currentTimeMillis();//更新操作后的时间
		time=endTime-starTime;//更新追加操作执行的时间
		System.out.println("StringBuilder消耗时间："+time);//将操作时间输出
	}
}