目录
5.1 String类
5.1.1 声明字符串
5.1.2 创建字符串
5.2 连接字符串
5.3 提取字符串信息
5.3.1 获取字符串长度
5.3.2 获取指定字符
5.3.3 获取子字符串索引位置
5.3.4 判断字符串首尾内容
5.3.5 获取字符数组
5.4 字符串的 *** 作
5.4.1 截取字符串
5.4.2 字符串替换
5.4.3 字符串分割
5.4.4 大小写转换
5.4.5 去除空白内容
5.1 String类 5.1.1 声明字符串
字符串常量，可以显示任何文字信息。
String a;//声明字符串
String a,b;//声明字符串1、引用字符串常量
String a = "时间就是金钱，我的朋友。";//定义string类型的字符串
String b = "锄禾日当午",c = "小鸡炖蘑菇";//定义a，b两个字符串
String str1,str2;//声明两个String类型的变量
str1="we are student.";//传入字符串
str2="I'm a student.";//传入字符串当两个字符串应用相同的常量时，就具有相同的实体。
2、 利用构造方法实例化
例如：使用new关键词创建String对象;
String a = new String ("我爱清汤小肥羊。");//用new关键字创建String对象
String b = new String (a);//用new关键字创建String对象3、利用字符数组实例化
例如：定义一个字符数组，并创建个字符串；
char[] a = {'t','i','m','e'};//定义字符类型数组创建一个字符串
String b = new String(a);//用new关键字创建String对象4、提取字符数组中的一部分创建子字符串对象
char[] a = ('时','间','就','是','金','钱');//用字符类型创建字符串
String b = new String(a,3,2);//定义字符串b，从索引3开始提取两个字符从该字符串索引3的位置开始，提取两个元素。
例1：
package boketask;//java包名
public class qwqw {//创建类的名字
public static void main(String[] args) {//主函数
String a = "时间就是金钱，我的朋友。";//直接应用字符串常量
System.out.println("a=" +a);//一个输出语句
String b = new String("我爱清汤小肥羊。");//利用构造方法实例化
System.out.println("b="+b);//一个输出语句
String c= new String(b);//使用已有字符串常量实例化
System.out.println("c="+c);//一个输出语句
char[] charArray = {'t','i','m','e'};//一个字符类型的数组创建字符串
String d = new String (charArray);//利用字符数组实例化
System.out.println("d="+d);//一个输出语句
char[] charArray2 = {'时','间','就','是','金','钱'};//一个字符类型的数组创建字符串
String e = new String(charArray2,4,2);//提取字符数组部分内容，从下标为4的元素开始，截取两个字符
System.out.println("e="+e);//一个输出语句
}
}
运行结果如下
，：
5.2 连接字符串
5.2.1
使用“+”运算符可以实现拼接多个字符串的功能，并产生一个String对象，出来“+”运算符，“+=”运算符同样可以实现字符串拼接。
java中相连的字符串不能直接分为两行。例如：、
System.out.println("I like Java ");//一句输出语句这种语法是错误的，可用"+"来连接
System.out.println("I like"+ "Java");//一句输出语句5.2.2
字符串也可以同其他的基本数据类型进行连接。
注意：字符串在计算公式中的前后顺序会影响运算结果；
例如：
String a = "1" +2+3+4 -->"1234"//碰到字符串后，直接输出后面内容 String b = 1+2+3+"4" -->"64" //碰到字符串前，先做运算，后输出内容 String c = "1"+(2+3+4) -->"19" //碰到字符串后，先运算括号中的值，后输出内容
5.3 提取字符串信息
5.3.1 获取字符串长度定义一个字符串num ，使用length()方法获取其长度。
5.3.2 获取指定字符package boketask;//包名 public class hqzdzf {//创建类 public static void main(String[] args) {//主方法 String str = "床前明月光，疑是地上霜。";//定义字符串 char chr = str.charAt(4);//将字符串str中索引位置为4的字符赋值给chr System.out.println("字符串中索引位置为4的字符是："+chr);//输出chr } }运行结果如下：
5.3.3 获取子字符串索引位置String类提供了两种查找字符串的方法，即indexOf()与lastIndexOf()方法。
1. indexOf(String str)
语法如下：
a.indexOf(substr);//indexOf的使用方法a:任意字符串对象
substr：要搜索的字符串
如下所示：
package boketask;//包名 public class hqzzfcweizhi {//创建类名 public static void main(String[] args) {//主方法 String str = "12345abcde";//创建字符串对象 int charIndex = str.indexOf("abc");//获取字符串str中"abc"首次出现的索引，赋值给charIndex if (charIndex !=1) {//判断：index的值不等于-1 //如果index不等于-1，则执行这串代码，说明str中存在"abc"字符串 System.out.println("str中存在abc字符串");//输出内容 } else {//如果index=-1，则执行这串代码，说明str中不存在"abc"字符串 System.out.println("str中没有abc字符串");//输出内容 } } }运行结果如下：
说明：
如果参数是一个字符串，返回的结果是字符串第一个字母所在位置。 String str = "abcdefg"; //定义一个字符串 str.lastInderOf("def"); //返回值是32. indexOf(String str,int fromIndex)
从指定的索引 fromIndex 开始至字符串最后，返回指定子字符串中第一次出现处的索引。
如果没有检索到字符串str，该方法返回的值为-1。
语法如下：
a.indexOf(str,fromIndex);//该方法的使用格式解释说明：
a：任意字符对象
str：要搜索的子字符串
fromIndex：开始搜索引的位置
例:
package boketask;//包名 public class PIPIPI {//创建类 public static void main(String[] args) {//主方法 String str = "we are the world";//定义一个字符串 int firstIndex = str.indexOf("r");//获取字符串中r第一次出现的索引位置 //获取字符串中r第二次出现的索引位置，从r第一次出现的索引位置开始查找 int secondIndex = str.indexOf("r",firstIndex+1);//获取字符串中r第二次出现的索引位置 //获取字符串中r第三次出现的索引位置，从r第二次出现的索引位置开始查找 int thirdIndex = str.indexOf("r",secondIndex+1);//获取字符串中r第三次出现的索引位置 //输出三次获取的索引位置 System.out.println("r第一次出现的索引位置是:"+firstIndex);//输出r第一次出现的索引位置 System.out.println("r第二次出现的索引位置是:"+secondIndex);//输出r第二次出现的索引位置 System.out.println("r第三次出现的索引位置是:"+thirdIndex);//输出r第三次出现的索引位置 } }运行结果：
该代码注解：
从运行结果可以看出，由于字符串只有两个“r”，所以程序输出了这两个“r”的索引位置， 第三次搜索是找不到“r”，所以返回结果为-1。3. public int lastIndexOf(String str)
返回指定子字符串在此字符串中最右边出现处的索引，语法如下：
a.lastIndexOf(atr);//该方法的使用格式解释说明：
a:任何字符串。
str：要搜索的字符串。
例子：
package boketask;//包名 public class StringLastIndexOf {//创建类 public static void main(String[] args) {//主方法 String str = "Let it go!Let it go!";//创建字符串对象 int gIndex = str.lastIndexOf("g");//返回“g”最后一次出现的位置 int goIndex = str.lastIndexOf("go");//返回“go”最后一次出现的位置 int oIndex = str.lastIndexOf("o");//返回“o”最后一次出现的 System.out.println("字符串\"Let in go!Let it go!中:\n");//输出提示内容 System.out.println("\"g\"最后一次出现的位置是：" + gIndex);//输出“g”最后一次出现的位置 System.out.println("\"o\"最后一次出现的位置是：" + oIndex);//输出“o”最后一次出现的位置 System.out.println("\"\"go最后一次出现的位置是：" + goIndex);//输出“go”最后一次出现的位置 } }运行结果：
4. lastIndexOf(String str,int fromIndex)
返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。
语法如下：
a. lastIndexOf(str,fronIndex);//该方法使用格式
解释说明：
a:任意字符串。
str：要搜索的子字符串。
fromIndex: 开始搜索的索引位置。
例如下面的代码：
运行结果如下：
package boketask;//包名 public class StringLastIndexOf2 {//创建类 public static void main(String[] args) {//主方法 String str = "01a3a56a89";//创建字符串对象 int lastIndex = str.lastIndexOf("a");//返回字母“a”最后一次出现的索引位置 //返回字母“a”的索引位置otheerIndex //满足0<=fiveBeforeIndex<=5条件，在满足条件的结果集中，返回最大的数字 int fiveBeforIndex = str.lastIndexOf("a",5); //返回字母“a”的索引位置otherIndex //满足0<=threeBeforIndex<=3条件，在满足条件的结果集中，返回最大的数字 int threeBeforIndex = str.lastIndexOf("a",3); System.out.println("字符串\"01a3a56a89\"中：\n");//输出括号内的内容 System.out.println("字母\"a\"最后一次出现的位置是："+ lastIndex); System.out.println("从索引5开始往回搜索，字母\"a\"最后一次出现的位置："+ fiveBeforIndex); System.out.println("从索引3开始往回搜索，字母\"a\"最后一次出现的位置" + threeBeforIndex); } }运行结果如下：
5.3.4 判断字符串首尾内容startWith()方法和 endsWith()方法分别用于判断字符串是否以指定内容开始或结束。
这两个方法返回的值都是boolean类型。
1. startWith(String prefix)
该方法用于判断字符串是否以指定内容开始
语法如下：
str.startWith(prefix);//该方法使用的语法解释说明：
str：任意字符串。
prefix：作为前缀的字符串。
例：查看一个字符串是否以“我有一个梦想”开始。
package javaProject001;//包名 public class StringStartWith {//创建类 public static void main(String[] args) {//主方法 String myDream1 = "我有一个梦想，幽谷上升，高山下降；";//前半句，创建字符串对象 String myDream2 = "坎坷曲折之路成坦途，圣光披露，满照人间。";//后半句 创建字符串对象 // 打印整句话 System.out.println(myDream1+myDream2 + "\n——马丁·路德金《我有一个梦想》\n"); boolean firstBool = myDream1.startsWith("我有一个梦想");//判断前半句是否以“我有一个梦想”为前缀 boolean secondBool = myDream2.startsWith("我有一个梦想");//判断后半句是否以“我有一个梦想”为后缀 if (firstBool) { System.out.println("前半句是以\"我有一个梦想\"开始的。");//判断前半句逻辑结果 }else if (secondBool) { System.out.println("后半句是以\"我有一个梦想\"开始的。");//判断前半句逻辑结果 } } }运行结果如下：
2. startWith(String prefix,int tooffset)
该方法用于判断从指定索引开始的子字符串是否以指定的前缀开始。
语法如下：
str.startWith(prefix,index);//该方法使用方式解释说明：
str：任意字符串。
prefix:作为前缀的字符串。
index：开始查找的位置。
例：
package javaProject001;//包名 public class StringStartWith2 {//创建类 public static void main(String[] args) {//主方法 String str = "床前明月光，疑是地上霜。\n举头望明月，低头思故乡。";//创建字符串对象 System.out.println(" 《静夜思》 \n" +str+"\n");//打印古诗 int enterIndex = str.indexOf("\n");//返回换行符所在的位置 boolean flag = str.startsWith("举",enterIndex);//返回换行符之后开始的子字符串前缀是否为“举” if (flag) { System.out.println("第二行是以\"举\"开始的");//如果结果为真，则输出此句 }else { System.out.println("第二行是以\""+str.charAt(enterIndex + 1)+"\"开始的"); //如果结果为假，则输出第二行开头的第一个字符 } } }运行结果如下：
3. endsWith(String suffix)
该方法判断字符串是否以指定的后缀结束。
语法如下：
str.endsWith(suffix);//该方法的使用格式解释说明：
str :任意字符串。
suffix:指定的后缀字符串。
例：
package javaProject001;//包名 public class StringEndsWith {//创建类 public static void main(String[] args) {//主方法 String str1 = "你说完了吗？";//创建字符串对象 String str2 = "我说完了。";//创建字符串对象 boolean flag1 = str1.endsWith("。");//判断str1是否以“。”结尾 boolean flag2 = str2.endsWith("。");//判断str2是否以“。”结尾 System.out.println("字符串str1是以句号结尾的吗？"+flag1);//输出结果 System.out.println("字符串str2是以句号结尾的吗？"+flag2);//输出结果 } }运行结果如下：
5.3.5 获取字符数组toCharArray()方法可以将一个字符串转化为一个字符数组。语法如下：
str.toCharArray();//此方法使用格式其中，str表示任意字符串。
例：
package javaProject001;//包名 public class StringToArray {//创建类 public static void main(String[] args) {//主方法 String str = "这是一个字符串";//创建字符串对象 char[] ch = str.toCharArray();//将字符串转化为字符数组 for (int i = 0;i运行结果如下：
5.3.6 判断子字符串是否存在
contains()方法可以判断字符串中是否包括指定的内容 。语法如下：
str.contains (String);//该方法的使用方式解释说明：
str：任意字符串。
String：查询的子字符串。
例：
package javaProject001;//包名 public class zszszsxd {//创建类 public static void main(String[] args) {//主方法 String a = "今日的菜单有：蒸羊羔，蒸熊掌，蒸鹿尾，烤花鸭，烧雏鸡，烧子鹅，卤煮咸鸭，酱鸡，腊肉，松花小肚";//创建字符串对象 System.out.println(a);//输出字符串 boolean request = a.contains("腊肉");//判断字符串中是否有“腊肉”的字样 System.out.println("今天有腊肉吗？" +request);//输出内容 boolean request1 = a.contains("汉堡");//判断字符串中是否有“汉堡”的字样 System.out.println("今天有汉堡吗？" + request1);//输出内容 } }运行结果如下：
5.4 字符串的 *** 作 5.4.1 截取字符串
1.subString(int bginIndex)
该方法返回一个新的字符串，它是此字符串的一个子字符串。该字符串从指定索引处的字符开始，直到此字符串末尾。
语法如下：
str.substring(beginIndex);//此方法的使用方式解释说明:
str:任意字符串。
beeginIndex:起始索引（包括）。
例：
package javaProject001;//包名
public class StringSub {//创建类
public static void main(String[] args) {//主方法
String str = "为革命保护视力，眼保健 *** 开始。";//创建字符串对象
String substr = str.substring(8);//从第八位截取字符串
System.out.println("字符串str的后半句是："+ substr);//输出内容
}
}
运行结果如下：
2. subString(int beginIndex,int endIndex)
该方法返回一个新字符串，它是此字符串的一个子字符串。该子字符串从指定的 beginIndex 开始，直到索引 endIndex-1处的字符。
语法如下：
str.substring(beginIndex,endIndex);//该方法的使用方式解释说明：
str：任意字符串。
beginIndex：开始索引（包括）。
endIndex：结束索引（不包括）。
例：
package javaProject001;//包名
public class StringSub2 {//创建类
public static void main(String[] args) {//主方法
String str = "闭门造车，出门踩屎。";//创建字符串对象
String substr = str.substring(0,4);//从0开始截取值4-1索引位置的子字符串
System.out.println("字符串str的前半句是：" + substr);//输出内容
}
}
运行结果如下：
5.4.2 字符串替换1. replace(CharSequence target,CharSequence repalcement)
该方法可以实现将指定的字符替换成新的字符序列。CharSequence 是一个接口，代表一个可读的字符序列，String、StringBuffer、StringBuilder 都实现了这个接口，所以可以直接将字符串当成参数。语法如下：
str.replace(oldstr,newstr);//该方法的使用方式解释说明：
str：任意字符串。
oldstr：要被替换的字符序列。
newstr：替换后的字符序列。
replcace()方法返回的是一个新的字符串，如果字符串str中没有找到需要被替换的子字符序列oldstr，则将原字符串返回。
例：
package javaProject001;//包名
public class Stringreplace {//创建类
public static void main(String[] args) {//主方法
String str = "明月几时有，把酒问青天。";//创建字符串对象
String restr = str.replace("月", "日");//将str中的“月”全部替换成“日”
System.out.println("字符串str替换后的效果："+restr);//输出内容
}
}
运行结果如下：
注意:
如果要替换的字符oldstr在字符串中重复出现多次，replace)方法会将所有oldstr全部替换成newstr。例如 String str = "java project";
String str2 = str.replace("j","J");此时，str2 的值为Java proJecto
需要注意的是，要替换的字符oldstr的大小写要与原字符串中字符的大小写保持一致，否则不能成
功地替换例如，上面的实例如果写成如下语句，则不能成功替换。
String str = "java project";
String str3 = str.replace("P","t");
2.replaceAll(String regex,String replacement)
该方法可以实现将指定的字符串替换成新的字符串，支持正则表达式。语法如下:
str.replaceAll(regex,replacement);//该方法的使用方式解释说明：
str:任意字符串。
regex:被替换的字符串或正则表达式。
replacement:替换后的字符串
则表达式是含有一些具有特殊意义字符的字符串，这些特殊字符称为正则表达式的元字符。例如，“ild”示数字0-9中的任何一个，“\ld”就是元字符
例：分别使用replace0方法和replaceA110方法，利用正则表达式将字符串中所有的数字的
换成“?”。
package javaProject001;//包名
public class StringReplaceAll {//创建类
public static void main(String[] args) {//主方法
String str = "0123456789abc\d";//创建字符串对象
String restr = str.replace("\d", "？");//使用replace()将符合"\d"的表达式字符串替换“？”
String restrAll = str.replaceAll("\d","?");//使用replace()将符合"\d"的表达式字符串替换“?”
//输出结果
System.out.println("字符串str："+str);//输出结果
System.out.println("使用replace()替换的结果："+restr);//输出结果
System.out.println("使用replaceAll()替换的结果："+restrAll);//输出结果
}
}
运行结果如下：
代码注解:
从这个运行结果可以直观地看出，replace()方法不知道"lld"表达式代表的含义，只是将"lld"当成一个子字符串在str中替换成了"?";而replaceA110知道正则表达式的含义，将所有的数字替换成了"?"，但对于字符串中出现的子字符串"lld"没有做任何 *** 作。
3. replaceFirst(String regex,String replacement)
该方法可以实现将第一个指定的字符串替换成新的字符串，支持正则表达式。
str.replaceFirst(regex,replacement);//该方法的使用方式解释说明：
str:任意字符串。
regex:第一个被替换的字符串或正则表达式。replacement:替换后的字符串。
例5.18 现有字符串"8I want to marry you,so I need you!"，去掉第一个数字，再把第一次出现的"you"替换成"her"。
package javaProject001;//包名
public class StringReplaceFirst {//创建类
public static void main(String[] args) {//主方法
String str = "8I want to marry you, so I need you!";//创建字符串对象
String noNumber = str.replaceFirst("\d", "");//将开头的数字替换成两个双引号“”
String youToHer = noNumber.replaceFirst("you", "her");//将第一次出现的“you”替换成“her”
System.out.println("替换之后的结果是：" +youToHer);//输出结果
}
}
运行结果如下:
5.4.3 字符串分割1. split (String regex)
该方法可根据给定的分隔符对字符串进行拆分，支持正则表达式，最后返回一个字符串数组。
语法如下：
str.split(regex);//该方法的使用方式解释说明：
str：任意字符串。
regex：分隔符表达式。
例：创建一个字符串，用“，”分割
package javaProject001;//包名
public class StringSplit {//创建类
public static void main(String[] args) {//主方法
String str = "从前有座山，山里有个庙，庙里有个小松鼠。";//创建字符串对象
String[] strArray = str.split("，");//让字符串按照“，”进行分割
for (int i = 0; i运行结果如下：
如果想定义多个分隔符，可以使用符号“|”。如果用“|”分割字符串，需要用到转义字符“\\|”。
例：同时使用不同的分隔符分割同一个字符串。
package javaProject001;//包名
public class StringSplit2 {//创建类
public static void main(String[] args) {//主方法
String str = "a1b2,c,d e f|gh";//创建字符串对象
String[] a1 = str.split(",");//使用“，”分隔
String[] a2 = str.split(" ");//使用“ ”分隔
String[] a3 = str.split("\|");//使用“|”分隔
String[] a4 = str.split("\d");//使用正则表达式分割，本行用数字分割
String[] a5 = str.split(",| |\||\d");//同时使用“，”、“空格”、“|”、数字分割，用“|”连接所有分隔符
System.out.println("str的原值："+str);//显示str原值
System.out.println("使用\",\"分割：");//输出内容
for(String b:a1) {//使用for-each循环展示结果
System.out.print("["+b+"]");//输出，分割后的结果
}
System.out.println();//换行
System.out.println("使用空格分割：");//输出内容
for(String b:a2) {//使用for-each循环展示结果
System.out.print("["+b+"]");//输出，分割后的结果
}
System.out.println();//换行
System.out.println("使用\"|\"分割：");
for(String b:a3) {//使用for-each循环展示结果
System.out.print("["+b+"]");//输出，分割后的结果
}
System.out.println();//换行
System.out.println("使用数字分割：");
for(String b:a4) {//使用for-each循环展示结果
System.out.print("["+b+"]");//输出，分割后的结果
}
System.out.println();//换行
System.out.println("同时使用所有分隔符：");//使用for-each循环展示数字分割结果
for(String b:a5) {//使用for-each循环展示结果
System.out.print("["+b+"]");//输出，分割后的结果
}
System.out.println();//换行
}
}
运行结果如下：
2.spilt(String regex,limit)
该方法可根据给定的分隔符对字符串进行拆分，并限定拆分的次数，支持正则表达式。
语法如下：
str.split(regex,limit);//该方法的使用方式解释说明：
str：任意字符串。
regex:分隔符表达式。
limit：限定的分割次数。
例：将字符串“192.168.0.1”按照“.”拆分两次，第一次全部拆分，第二次拆分两次。
package javaProject001;//包名
public class StringSpilit3 {//创建类
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.println("全部分割的结果：");//输出全部结果
for(String a:firstArray) {//for-each循环展示分割结果
System.out.print("["+a+"]");//输出结果
}
System.out.println();//换行
System.out.println("分割两次的结果：");//输出分割两次的结果
for(String a:secondArray) {//for-each循环展示分割结果
System.out.print("["+a+"]");//输出结果
}
System.out.println();//换行
}
}
运行结果：
5.4.4 大小写转换
1. toLowerCase()
该方法将String转换为小写，如果字符串中没有应被转换的字符，则将原字符串返回；否则将返回一个新的字符串，将原字符串中每个可进行小写转换的字符都转换成等价的小写字符，字符串长度与原字符串长度相同。
语法如下：
str.toLowerCase();//该方法的使用方式其中 str代表任意字符串。
2. toUpperCase()
该方法将String转换为大写，如果字符串中没有应被转换的字符，则将原字符串返回；否则将返回一个新的字符串，将原字符串中每个可进行大写转换的字符都转换成等价的大写字符，字符串长度与原字符串长度相同。
语法如下：
str.toUpperCase();//该方法的使用方式其中 str代表任意字符串。
例：将字符串“abc DEF”分别用大写、小写两种格式输出。
package javaProject001;//包名
public class StringTransform {//创建类
public static void main(String[] args) {//主方法
String str = "abc DEF";//创建字符串对象
System.out.println(str.toLowerCase());//按照小写格式输出
System.out.println(str.toUpperCase());//按照大写格式输出
}
}
运行结果如下：
5.4.5 去除空白内容trim()方法可以返回字符串的副本，忽略首尾处空白。语法如下：
str.trim();//该方法的使用方式其中str代表任意字符串。
例：使用trim()方法去掉字符串两边的空白内容。
package javaProject001;//包名
public class StringTrim {//创建类
public static void main(String[] args) {//主方法
String str = " abc ";//创建字符串对象
String shortStr = str.trim();//使用trim()方法 处
System.out.println("str的原值是：["+str+"]");//输出str的原值
System.out.println("去掉首尾空白的值：["+ shortStr +"]");//输出去除空白后的值
}
}
运行结果如下：
例2：去除字符串中所有的空白
package javaProject001;//包名
public class StringRemoveBlank {//创建类
public static void main(String[] args) {//主方法
String str= "a b cd e f g ";//创建字符串对象
String shortstr = str.replaceAll("\s", "");//利用正则表达式，将字符串中所有的空白内容替换成“ ”
System.out.println("str的原值是：["+str+"]");//输出内容
System.out.println("删除空内容之后的值是：["+shortstr+"]");//输出删除空内容之后的值
}
}
运行结果如下：
5.4.6 比较字符串是否相等
对字符串对象进行比较不能简单的使用比较运算符“==”，因为比较运算符比较的是两个字符串的内存地址是否相同，因为即使两个字符串的文本值相同，两个对象的内存地址也可能不同，所以使用比较运算符会返回false.
例：使用比较运算符计较两个字符串。
package javaProject001;//包名
public class StringCompare {//创建类
public static void main(String[] args) {//主方法
String a,b;//引入字符串常量
a = "I am a student";//给a赋值
b = "I am a student";//给b赋值
System.out.println("直接引入字符串常量的比较结果："+ (a==b));//直接引入字符串常量的比较
a = new String("I am a student");//使用new创建对象
b = new String("I am a student");//使用new创建对象
System.out.println("使用new创建对象的比较结果："+ (a==b));//使用new创建对象的比较
}
}
运行结果如下：
注解：
为什么第一个结果是true,第二个结果是false呢?因为两种赋值方法在计算机中处理的方不同。像字符串常量这样的字面值，会直接放在栈中。例子5.25中tom和jerry直接用字符串常赋值时，其字符串值保存的是一个指向栈中数据的引用。又因为两个对象引用的是同一个常量，用“一”比较发现两者指向了相同的地址，所以结果会返回 true，如图 5.32 所示。
如果tom和jerry创对象，算处理方式就不一样了。当tom使用new方法时，会在堆中创建一个新的 String对象，并为这个对象单独在栈中创建值，即使与栈中已有相同数据，也不会共享。用“-”比较发现两者指向不同的对象地址，结果会返回 false，如图 5.33 所示。
想要比较两个字符串对象的内容是否相同，就需要用equalsO和equalsIgnoreCaseO方法。
1. equals(String str);
将此字符串与指定的对象比较。当且仅当该参数不为null，并且是与此对象表示相同字符序列的String 对象时，结果才为true。
语法如下:
a.equals(str);//该方法的使用方式解释说明：
a:任意字符串。
str:进行比较的字符串。
例5.26创建String变量，分别用“=”和equals()方法判断两个字符串是否相等。
package javaProject001;//包名
public class StringEquals {//创建类
public static void main(String[] args) {//主方法
String str1 = "Hello";//创建字符串对象
String str2 = new String ("Hello");//用new创建字符串对象
String str3 = new String ("你好");//用new创建字符串对象
String str4 = str2;//创建和str2相同内容的字符串
System.out.println("str1==str2 的结果：" + (str1 == str2));//输出结果
System.out.println("str1==str3 的结果：" + (str1 == str3));//输出结果
System.out.println("str1==str4 的结果：" + (str1 == str4));//输出结果
System.out.println("str2==str4 的结果：" + (str2 == str4));//输出结果
System.out.println("str1.equals(str2) 的结果" + str1.equals(str2));//使用equals方法比较
System.out.println("str1.equals(str3) 的结果" + str1.equals(str3));//使用equals方法比较
System.out.println("str1.equals(str4) 的结果" + str1.equals(str4));//使用equals方法比较
}
}
运行结果如下：
注意：
String str = null;和String str = "";是两种不同的概念。前者是空对象，没有指向任何引用地址，调用String的API会抛出NullPointerException 空指针异常，""是一个字符串，分配了内存空间，可以调用String的API，只是没有显示任何东西而已。
2. equalslgnoreCase(String anotherString)
此字符串对象与指定的对象比较，不考虑大小写。如果两个字符串的长度相同，并且其中相应的字符都相等(忽略大小写) 则认为这两个字符串是相等的。
语法如下：
a.equalsIgnoreCase(String anotherString);//此方法的使用方式解释说明:a:任意字符串。
anotherString：进行比较的字符串。
例：使用equals()和equalsIgnoreCase()方法判断两个字符串支付相等。
package javaProject001;
public class StringEqualsIgnoreCase {
public static void main(String[] args) {
String str1 = "abc";//创建字符串对象，内容全部小写
String str2 = "ABC";//创建字符串对象，内容全部大写
System.out.println("区分大小写的结果：" +str1.equals(str2));//比较两个字符串的内容是否相等
System.out.println("不区分大小写的结果：" +str1.equalsIgnoreCase(str2));//比较两个字符串的内容是否相等
}
}
运行结果如下：
多学两招：
(1)字符串常量也可以使用equals和equalsIgnoreCase()方法，例如：
boolean a = "一闪一闪".equals.("亮晶晶");//布尔类型数据判断两个字符串是否相等
boolean b = "功夫".equals.("java");//布尔类型数据判断两个字符串是否相等（2）判断一个字符串str是否为空，需要分别判断str是否等于null或""。判断null用“==”，判断""用equals()方法，两者不可混淆。str一个作为equals的参数，否则当str是空对象时，调用equals()会抛出空指针异常
String str = "123";//创建字符串对象
if ( null == str || "".equals(str)){//if语句判断字符串是否为空
System.out.println("str时候空的");//输出结果
String类的静态format()方法用于创建格式化的字符串。format()方法有两种重载形式。
（1） format(String format,Object...args)
该方法使用指定的格式字符串和参数返回一个格式化字符串，格式化后的新字符串使用本地默认的语言环境。
语法如下：
str.format(String format,Object ...args)//该方法的使用方式解释说明：
format：格式化字符串。
args ：格式字符串中由格式说明符引用的参数。如果还有格式说明符以外的参数，则忽略这些额外的参数。此参数的数目是可变的，可为0。
（2）format(Local 1,String format,Object...args)
1：格式化过程中要应用的语言环境。如果1为null，则不进行本地化。
format：格式化字符串。。
args：格式化字符串中有格式说明符引用的参数。如果还有格式说明符以外的参数，则忽略这些额外的参数。此参数的数目是可变的，可为0。
1.日期和时间字符串格式化
在应用程序设计中，需要经常使用时间和日期。如果想输出满意的日期和时间格式，一般需要编写大量的代码。format()方法通过给定的特殊转换符作为参数来实现对日期和时间的格式化。
（1）日期格式化
返回一个月中的天数。实例代码如下：
Date date = new Date();//创建Date对象date
String s = String.format("%te",date);//通过format()方法对大同人进行格式化上述代码中变量s的值是当前日期中的天数，如果建团是15号，则s的值为15；%te是转换符，常用的日期格式化转换符如下表所示。
例：显示当前日期
package boketask;//包名
import java.util.Date;//引入Date方法
public class Eval {//创建类
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);//将date进行格式化
String day = String.format("%td", date);//将date进行格式化
System.out.println("今年是：" + year+"年");//输出信息
System.out.println("现在是：" + month);//输出信息
System.out.println("今天是：" + day+"号");//输出信息
}
}
运行结果如下：
（2） 时间格式化
使用format()方法也能实现时间的格式化，可以将时间格式化为时、分、秒、毫秒。如下图所示：
例：显示当前的时间
package boketask;//包名
import java.util.Date;//引入方法
public class getDate {//创建类
public static void main(String[] args) {//主方法
Date date = new Date();//创建Date对象date
String hour = String.format("%tH",date);//将date进行格式化
String minute = String.format("%tM",date);//将date进行格式化
String second = String.format("%tS",date);//将date进行格式化
System.out.println("现在是："+hour + "时"+ minute+ "分");//输出内容
}
}
运行结果如下：
（3）格式化常见的日期时间组合
例:：显示日期时间
package boketask;//包名
import java.util.Date;//导入java.util.Date类
public class DateAndTime {//创建类
public static void main(String[] args) {//主方法
Date date = new Date();//创建Date对象
String time = String.format("%tc",date);//将date格式化
String form = String.format("%tF", date);//将date格式化
System.out.println("全部的时间信息是：" +time);//输出格式化的日期时间
System.out.println("年-月-日格式："+form);//输出格式化的日期时间
}
}
运行结果如下：
2.常规类型格式化
常规类型格式化可应用于他人和类型参数，可以通过下表的转换符来实现。
例：实现不同类型的格式转化
package boketask;//包名
public class StringFormat {//创建类
public static void main(String[] args) {//主方法
String str1 = String.format("%c", 'X');//输出字符
System.out.println("字母x大写：" + str1 );//输出字符
String str2 = String.format("%d",125+231);//格式转化
System.out.println("123+312d的结果：" +str2);//输出字符
String str3 = String.format("%.2f",Math.PI);//格式转化
System.out.println("n取连伟小数点："+ str3);//输出字符
String str4 = String.format("%b",2<3);//格式转化
System.out.println("2<3的结果为："+str4);//输出字符
String str5 = String.format("%h",3521);//格式转化
System.out.println("3521的hashCode值：" + str5);//输出内容
String str6 = String.format("%o",33);//格式转化
System.out.println("33的八进制结果："+str6);//输出内容
String str7 = String.format("%x",33);//格式转化
System.out.println("33的16进制结果："+str7);//输出内容
String str8 = String.format("%e",12000.1);//格式转化
System.out.println("12000.1用科学计数法表示："+str8);//输出内容
String str9 = String.format("%a",40.0);//格式转化
System.out.println("40.0的16进制浮点值："+ str9);//输出内容
System.out.println(String.format("天才是由%d%%的灵感,%d%%的汗水。",1,99));//输出百分号和数字
}
}
运行结果如下：
5.5可变字符
类名 对象类型 执行效率 线程安全性
String 指向另外的空间 常量 慢 不安全
StringBuffer 指向在原来的基础上添加 变量 中 有锁 安全
Stringbuilder 在原来的基础上添加 变量 快 无 锁 不安全
1.创建StringBuffer类
StringBuffer sbf=new StringBuffer();//创建StringBuffer对象
StringBuffer sbf=new StringBuffer("abc");//创建对象并传入值
StringBuffer sbf=new StringBuffer(32);//创建对象并传入值
2.append()方法
将参数转换成字符串，将所有字符串中的字符追加到此序列中。
str.append(obj);//该方法的使用方法解释说明:
sbf:任意StringBuffer对象
obj:任意数据类型的对象，使append()方法都转变成字符串的表示形式。
public static void main(String[] args) {
StringBuffer sbf=new StringBuffer("门前大桥下,");//创建StringBuffer对象
sbf.append("游过一群鸭,");//追加字符串常量
StringBuffer tmp=new StringBuffer("快来快来数一数,");//追加StringBuffer对象
sbf.append(tmp);//追加字符串常量
int x=24678;//定义一个整型常量
sbf.append(x);//追加字符串常量
System.out.println(sbf.toString());//输出
}
3.setCharAt(int index,char ch)方法
将给定索引处的字符修改成ch.
sbf.setCharAt(index,ch);//该方法的使用方法解释说明：
sbf:任意StringBuffer对象
index:被替换字符的索引
替换后的字符
public static void main(String[] args) {
StringBuffer sbf=new StringBuffer("0123456");//创建StringBuffer对象
System.out.println("sbf的原值是："+sbf);//输出信息
sbf.setCharAt(3, 'A');//将索引为3的字符改成‘A’
System.out.println("修改后的值是："+sbf);//输出信息
}
4.insert(int offset,String str)方法
将字符串插入此字符序列中
sbf.insert(offset,str);//该方法的使用方法解释说明：
sbf:任意StringBuffer对象
offset:插入的索引
str:插入的字符串
public class test35 {
public static void main(String[] args) {
StringBuffer sbf=new StringBuffer("0123456");//创建StringBuffer对象
System.out.println("sbf的原值为："+sbf);//输出信息
sbf=sbf.insert(5, "F");//在索引为5的位置插入“F”，将返回值赋给sbf自己
System.out.println("修改之后的值为："+sbf);//输出信息
}
}
5.reverse()方法
sbf.reverse();//该方法的使用方法例：
public static void main(String[] args) {
StringBuffer sbf=new StringBuffer("同一个世界，同一个梦想");//创建一个StringBuffer对象
System.out.println("sbf的原值为："+sbf);//输出信息
sbf=sbf.reverse();//将字符序列sbf反转
System.out.println("修改之后的值为："+sbf);//输出信息
}
6.delete(int start,int end)方法
sbf.delete(start,end);
sbf:任意StringBuffer对象
start:起始索引
end:结束索引
例：
public static void main(String[] args) {
StringBuffer sbf=new StringBuffer("天行健，君子以自强不息");//创建StringBuffer对象
System.out.println("sbf的原值为："+sbf);//输出信息
sbf=sbf.delete(4, 7);//删除从索引4开始至索引7之前的内容
System.out.println("删除之后的值为："+sbf);//输出信息
}
其他方法：
public static void main(String[] args) {
StringBuffer sbf=new StringBuffer("ABCDEFG");//创建字符串序列
int lenght=sbf.length();//获取字符串序列的长度
char chr=sbf.charAt(5);//获取索引为5的字符
int index=sbf.indexOf("DEF");//获取DEF字符串所在的索引位置
String substr=sbf.substring(0,2);//截取从索引0开始至索引2之间的字符串
StringBuffer tmp=sbf.replace(2, 5, "1234");//将从索引2开始至索引5之间的字符序列替换成“1234”
System.out.println("sbf的原值为："+sbf);//输出信息
System.out.println("sbf的长度为："+lenght);//输出信息
System.out.println("索引为5的字符为："+chr);//输出信息
System.out.println("DEF字符串的索引位置为："+index);//输出信息
System.out.println("索引0开始至索引2之间的字符串："+substr);//输出信息
System.out.println("替换后的字符串为："+tmp);//输出信息
}StringBuilder类使用方法
public static void main(String[] args) {
StringBuffer sbd=new StringBuffer();//创建一个StringBuffer对象
System.out.println("sbd的原值为空");//输出信息
sbd.append("我是StringBuffer类");//追加字符串
System.out.println("sbd追加字符串："+sbd);//输出信息
int length=sbd.length();//获取sbd字符串的长度
System.out.println("sbd的长度为："+length);//输出信息
sbd=sbd.insert(length-1, "123456");//插入字符串
System.out.println("插入字符串："+sbd);//输出
sbd=sbd.delete(sbd.length()-1,sbd.length());//删除字符串
System.out.println("删除最后一个字："+sbd);//输出
sbd=sbd.reverse();//反序输出
System.out.println("反序输出："+sbd);//输出
}22.StringBuffer、StringBuilder、String之间的相互转换
public static void main(String[] args) {
String str="String";//创建一个字符串
StringBuffer sbf=new StringBuffer(str);//String转换成StringBuffer
StringBuilder sbd=new StringBuilder(str);//String转换成Stringbuilder
str=sbf.toString();//StringBuffer转换成String
str=sbd.toString();//StringBuilder转换成String
StringBuilder bufferTobuilder=new StringBuilder(sbf.toString());//StringBuffer转换成StringBuilder
StringBuffer buliderToBuffer=new StringBuffer(sbf.toString());//StringBuilder转换成StringBuffer
}
public static void main(String[] args) {
// TODO Auto-generated method stub
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循环1万次消耗时间：" + 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循环1万次消耗时间：" + time); // 将操作时间输出
StringBuilder builder2 = new StringBuilder(""); // 创建字符串生成器
starTime = System.currentTimeMillis(); // 定义操作执行前的时间
for (int j = 0; j < 50000; j++) { // 利用for循环进行操作
builder2.append(j); // 循环追加字符
}
endTime = System.currentTimeMillis(); // 定义操作后的时间
time = endTime - starTime; // 追加操作执行的时间
System.out.println("StringBuilder循环5万次消耗时间：" + time); // 将操作时间输出
}
}欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）