查看 API 会发现,String、StringBuffer、StringBuilder 都实现了 CharSequence 接口,内部都是用一个char数组实现,虽然它们都与字符串相关,但是其处理机制不同。
使用 StringBuffer 类的场景:在频繁进行字符串运算(如拼接、替换、删除等),并且运行在多线程环境中,则可以考虑使用 StringBuffer,例如 XML 解析、HTTP 参数解析和封装。
使用 StringBuilder 类的场景:在频繁进行字符串运算(如拼接、替换、和删除等),并且运行在单线程的环境中,则可以考虑使用 StringBuilder,如 SQL 语句的拼装、JSON 封装等。
在性能方面,由于 String 类的操作是产生新的 String 对象,而 StringBuilder 和 StringBuffer 只是一个字符数组的扩容而已,所以 String 类的操作要远慢于 StringBuffer 和 StringBuilder。
简要的说, String 类型和 StringBuffer 类型的主要性能区别其实在于 String 是不可变的对象, 因此在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象
,然后将指针指向新的 String 对象
。所以经常改变内容的字符串最好不要用 String ,因为每次生成对象都会对系统性能产生影响
,特别当内存中无引用对象多了以后, JVM 的 GC(垃圾回收) 就会开始工作,那速度是一定会相当慢的
。
而如果是使用 StringBuffer 类则结果就不一样了,每次结果都会对 StringBuffer 对象本身进行操作,而不是生成新的对象,再改变对象引用。所以在一般情况下我们推荐使用 StringBuffer ,特别是字符串对象经常改变的情况下。
而在某些特别情况下, String 对象的字符串拼接其实是被 JVM 解释成了 StringBuffer 对象的拼接,所以这些时候 String 对象的速度并不会比 StringBuffer 对象慢,而特别是以下的字符串对象生成中, String 效率是远要比 StringBuffer 快的,例如下例:
你会很惊讶的发现,生成 String S1 对象的速度简直太快了,而这个时候 StringBuffer 居然速度上根本一点都不占优势。其实这是 JVM 的一个把戏,在 JVM 眼里,这个
这时候 JVM 会规规矩矩的按照原来的方式去做。因为每个变量都在内存中开辟了新的空间,最终指针指向的是字符串拼接后的那块地址。所以没有指针指向的空间就成了垃圾,GC在回收的时候就会影响性能。
根据打印的可以发现使用equal比较时无论是使用自动装箱来实例化还是用new来实例化,返回的都true,而用==则不一样了,自动装箱来实例化的返回的是true,而用new来
获取方法
•int length()获取字符串长度
•char charAt(int index)根据位置获取某个字符
•int indexOf(int ch) 返回的是ch在字符串中第一次出现的位置
•int indexOf(int ch,int fromIndex)从fromIndex指定位置开始,获取ch在字符串中第一次出现的位置
•int indexOf(String str)
•int indexOf(String str,int fromIndex)
•int lastIndexOf(int ch)
实例1( length()字符串长度)
package com.java.demo_6;
public class StrTest2 {
public static void main(String[] args) {
String str = "我是黑猫警长!";
int str1 = str.length();
System.out.println(str1);
}
}
结果为:7
注释:“我是黑猫警长!”这个字符串中,双引号中的字符串算上!号同7个字符,所以结果为7。而.length();返回的结果是整个字符串的长度值。
实例2(charAt(int index)根据位置获取某个字符)
package com.java.demo_6;
public class StrTest2 {
public static void main(String[] args) {
String str = "我是黑猫警长!";
System.out.println(str.charAt(3));//获取某一个字符
System.out.println(str.charAt(str.length() -1));//获取最后一个字符
}
}
结果: (1) 输出的是“猫”。因为字符位是从0开始算起的,.charAt(3)指向的是第4个标致位,所以取的是“猫”。
(2)输出的是 “!”号。因为.charAt()中输入的是str.length()-1所以代表字符串长度的最后一位的意思,所以取值为“!”号。
实例3(indexOf(int ch) 返回的是ch在字符串中第一次出现的位置)
package com.java.demo_6;
public class StrTest2 {
public static void main(String[] args) {
String str = "我是黑猫警长!我是黑猫警长!我是黑猫警长!";
int index = str.indexOf("!");
System.out.println(index);
}
}
结果:6 。indexof(“!”); 查找的对象是“!” ,而“!”在整个字符串中出现的第一个位置为第6个下标。所以返回值为6.
实例4(indexOf(int ch,int fromIndex)从fromIndex指定位置开始,获取ch在字符串中第一次出现的位置)
package com.java.demo_6;
public class StrTest2 {
public static void main(String[] args) {
String str = "我是黑猫警长!我是黑猫警长!我是黑猫警长!";
int index1 = str.indexOf("黑", 6);
int index2 = str.indexOf("黑", 0);
System.out.println(index1);
System.out.println(index2);
}
}
结果:(1)输出结果为9.indexof(int ch,int fromIndex)的语法是ch为要查找的字符,fromIndex代表从哪里起始查找。因为输出的是6所以是从整个字符串中的第6个位置开始查找字符"黑"。而黑在整个字符串中的下标为9所以输出值为9.
(2)输出结果为2.同上因为0是从第0个位置开始查找,所以查找的字符串在整个字符串中的下标为第2个位置所以输出值为2(再次强调字符串下标是从0开始起始的)
实例5(indexOf(String str))跟 (indexOf(int ch))
在查找的效果上没有什么不同。一个是查找一段字符串,一个是查找一个字符。但是不管你是查找字符串还是字符,查找的都是字符串,字符中的第一个元素的下标。只要查找到就结束,因此从输出上来看其实返回的结果都一样。都是为第一个元素位。
实例6( indexOf(String str,int fromIndex))跟(indexOf(int ch,int fromIndex))
同上的原理,查找的都是第一个字符串,字符的第一个下标位后结束。只不过fromIndex是只从哪里开始查找而已,其他跟上述没任何区别。
实例7(lastIndexOf(int ch))
package com.java.demo_6;
public class StrTest2 {
public static void main(String[] args) {
String str = "我是黑猫警长!我是黑猫警长!我是黑猫警长!";
int str1 = str.lastIndexOf("是");
System.out.println(str1);
}
}
结果:15 .lastIndexof用法是从最后一位开始查找要查的字符或者字符串,只要查到就结束。其他 lastIndexof(int ch , formIndex)等用法不在重复同上。
注释:indexof的总结是获取的是查找字符串在整个字符串中的下标,而不是字符串的值本身。要想获取字符串的值要通过切割的方法来获取,请参考切割方法中subString的用法。
判断方法
•boolean contains(String str) 另一种判断方法:if(str.index(str)!=-1)
注释:判断一个字符串是否包含在另一个字符串中时使用。
实例1(contains(String str))返回值为True或者false
package com.java.demo_9;
public class test1 {
public static void main(String[] args) {
String str1 = "最近推荐一款热门游戏 给你,名字叫做<阴阳师>.";
String str2 = "阴阳师";
String str3 = "茨木童子";
boolean result = str1.contains(str2);
boolean result1 = str1.contains(str3);
System.out.println(result);
System.out.println(result1);
}
}
结果: result返回结果为True.result1返回结果为false.
•boolean startsWith(String str) and startsWith(prefix, toffset)
注释:startWith是判断如果参数所表示的字符序列是由该字符串所表示的字符序列的前缀,则返回true,否则为false。
实例2(startsWith(String str))
package com.java.demo_9;
public class test {
public static void main(String[] args) {
String str1 = "茨木童子御魂搭配:";
String str2 = "茨木童子最好搭配,4破式套装+2心眼(提高攻击加成)";
String str3 = "搭配";
System.out.println(str1.startsWith("茨"));
System.out.println(str1.startsWith("木"));
System.out.println(str1.startsWith("子", 3));
//System.out.println(str1.startsWith(prefix, toffset));
}
}
结果: (1)True (2) false (3) True
(1)str1字符串第一个字符是"茨"字所以匹配成功,返回True
(2)str1字符串第一个字符是“茨”,而我们search的字符是“木”,所以不匹配。返回结果为false。
(3)是从str1这个字符串中查找“子”字。但是后面定义toffset就是从哪里开始起始的意思。因为3正好是子的下标位,因此返回的是True.
•boolean endsWith(String str)
实例3(endsWith(String str))
注释:同startsWith相反,是从一个字符串的最末尾开始查找。参数可以输入变量也可以直接输入字符串。startsWith也是一样。
package com.java.demo_9;
public class test {
public static void main(String[] args) {
String str1 = "茨木童子御魂搭配:";
String str2 = "茨木童子最好搭配,4破式套装+2心眼(提高攻击加成)";
String str3 = "搭配";
String str4 = ":";
System.out.println(str1.endsWith(str3));
System.out.println(str1.endsWith(str4));
}
}
结果:
(1)返回值为false. (str1的最后一个字符为:号所以不匹配)
(2)返回值为True. (str4赋值的就是:号因此在str1末尾查找时匹配的也是:号,因此返回true)
•bolean isEmpty(String str)
注释:判断一个字符串是否为空。(这种说法不是很准确。因为字符串如果是null的话,不会返回。而是抛出异常)
实例4(isEmpty(String str))
package com.java.demo_9;
public class test1 {
/**
* @param args
*/
public static void main(String[] args) {
String str = "今天星期五";
String str1 = "";
String str2 = null;
System.out.println("字符串长度为 = " + str.length());
System.out.println("判断字符串是否为空 = " + str.isEmpty());
System.out.println("判断字符串是否为空 = " + str1.isEmpty());
System.out.println("判断字符串是否为空 = " + str2.isEmpty());
}
}
结果:
(1)返回:5 因为使用的是.length()方法,是测试字符串长度的。因此返回值为字符串总下标数。
(2)返回值为true.因为str1中“”是代表空字符串。因此用.isEmpty()返回的结果为true.
(3)不会返回true或者false。会抛出下列异常。因此如果字符串为null的情况,要想判断字符串是否为空最好的方法是通过if语句来判断。if(str2 == null || str2.length()==0)后面返回true,false。
“Exception in thread "main" java.lang.NullPointerException“
at com.java.demo_9.test1.main(test1.java:17)
※※•boolean equals(String str)
注释:对比2个字符串是否相等。也是字符串中比较常用的方法之一。
这里要强调一点的是,很多人在判断2个字符串是否相等时都习惯用==来判断。其实在java中.equals跟==的关系是有区别的。
==判断的其实是指向字符串的指针是否相等。而.equals判断的是2个字符串的值是否相等。所以要想判断值的时候就不能用==,一定要使用.equlas来进行判断。
实例4(equals(String str))
package com.java.demo_9;
public class test1 {
public static void main(String[] args) {
String str1 = "星期五";
String str2 = "星期五";
String str3 = new String("星期五");
System.out.println("str1==str2:"+(str1.equals(str2)));
System.out.println("str1==str2:"+(str1==str2));
System.out.println("str1==str3:"+(str1==str3));
}
}
结果:
(1) 返回结果为:str1==str2:true 分析:对比的是2个结果的值,很显然值相同所以返回true.
(2) 返回结果为:str1==str2:true 分析:这里涉及到一个常量池的概念。因为str1在赋值“星期五”的时候,已经分配了一块内存来存这些数据。而str2再出现相同的字符串时,系统首先会先去内存找是否有相同的字符串存在。如果有直接把指针指向之前被创建的字符串。如果没有就新开辟空间。因此这里在用==的时候指针其实是指向的同一块地址,因此返回值为true.
(3) 返回结果为:str1==str3:false 分析:str3是new出来的,而我们知道只要new了,就存在堆跟栈的概念(这里不重复提)。说明str3中的星期五是独立的。跟str2不同的是指针指向的是自己而不是之前创建相同的相同字符串。指针不同所以==在这里是不同的。因此返回结果为fasle.
※※•boolean equalsIgnoreCase(String str);
注释:不区分大小写的情况下来判断字符串是否一致。(在某种情况下这个用法更实用。比如说用来判断用户名的情况。要求不严格的情况下可以忽略大小写。当然判断密码的话另当别论。一定要用equals不要用equalsIgnoreCase)
实例5(equalslgnoreCase(String str))
package com.java.demo_9;
public class test1 {
public static void main(String[] args) {
String str1 = "Friday";
String str2 = "friday";
System.out.println(str1.equals(str2));
System.out.println(str1.equalsIgnoreCase(str2));
}
}
另外补充一点下面实例中str3的字符串明显前后有空格。如果直接对比肯定返回为false。去除空格用.trim方法。然后再跟.equalsIgnoreCase来判断的例子比较多。这里要注意对比的对象是谁对比谁。
因为有空格的是str3,因此我们首先要使用str3.trim()去除空格后再跟str1做对比。
实例6(.trim().equalslgnoreCase(String str))
package com.java.demo_9;
public class test1 {
public static void main(String[] args) {
String str1 = "Friday";
String str2 = "friday";
String str3 = " friday ";
System.out.println(str1.equals(str2));
System.out.println(str1.equalsIgnoreCase(str2));
System.out.println(str3.trim().equalsIgnoreCase(str1));
}
}
转换方法
•将字符数组转换为字符串
注释:关于char数组跟String之间的关系请参考下列博客
http://blog.csdn.net/u010297957/article/details/48495791
构造函数
1.String(char[] chs)
2.String(char[] chs,offset,count)将字符数组中的一部分转成字符串。
静态方法
1.static String copyValueOf(char[] chs)
注释:用途是把cha[]数组中的每个字符拼接成字符串。
实例1(static String copyValueOf(char[] chs))
package com.java.demo_9;
public class test1 {
public static void main(String[] args) {
char[] cha = {'h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd'};
String str = "";
/**
* 打印cha字符数组中的每个元素
*/
for(int i=0;i<cha.length;i++){
System.out.println(cha[i]);
}
System.out.println("++++++++++++++++++++++++++++++++++++++++++++");
/**
* 把cha字符数组转成字符串
*/
str = str.copyValueOf(cha);
System.out.println(str);
System.out.println("++++++++++++++++++++++++++++++++++++++++++++");
str = str.copyValueOf(cha, 2, 6);
System.out.println(str);
}
}
结果:
(1)返回的是每个cha数组中的每个元素。
(2)返回的是一个String 类型的字符串。内容把cha[]中的元素拼接成了字符串。
(3)copyValueof中的另一个用法String copyValueOf(char[] chs,int offset,int count),也就是下列2中的方法。具体情况请参考博客。
2.static String copyValueOf(char[] chs,int offset,int count)
注释:详情请参照博客:http://www.yiibai.com/java/java_string_copyvalueof.html
3.static String valueOf(char[] )
注释:这里的参数代表把字符转换为字符串,其实类型转换包括很多种。int,boolean,double等等都可以通过String valueOf()的方式进行转换,详细请参考下列博客。
参考:(1)http://blog.csdn.net/yuan444075705/article/details/11375969
(2)http://www.runoob.com/java/java-string-valueof.html
这里指举一个案例
package com.java.demo_9;
public class test {
public static void main(String[] args) {
int a = 3;
String c = "今年";
System.out.println(c.contains(a));
//The method contains(CharSequence) in the type String is not applicable for the arguments (int)
//CharSequence a = 3;
String b = String.valueOf(a);
System.out.println(b);
System.out.println(c.contains(b));
}
}
结果:
(1)System.out.println(c.contains(a));上述我们有讲过.contains是判断一个字符串是否包含在另一个字符串中的。当我们在使用.contains来对int类型的值做比较的时候语句会抛出异常。提示该方法包含(CharSequence)在字符串类型不适用于参数(int)。必须把int类型转换成CharSequence才可以。
(2)System.out.println(c.contains(b));当我们用.valueOf()把int转换为String后再通过.contains来判断的时候发现有返回值了。返回值必然为false,因为b字符串中没有3这个字符串。但是可以判断了说明我们用.valueOf已经把int类型转换成了String 类型。
4.static String valueOf(char[] chs,int offset,int count)
这个语句用法请参照上述博客,在此不再详细说明了。
•将字符串转换成字符数组
char[] toCharArray
实例2(char[] toCharArray)
package com.java.demo_9;
public class test {
public static void main(String[] args) {
/**
* char数组的创建以及输出
*/
char[] result = {'a','b','c','d'};
System.out.println(result);
System.out.println("++++++++++++++++++++++++++++++++++++");
/**
* 字符串转数组后输出
*/
String str = "abc";
char[] arr = str.toCharArray();//通过String的.toCharArray()方法进行转换.
System.out.println(arr);
}
}
结果:通过上面案例可以看出System.out.println(arr);最终的输出是abc。我们看起来是字符数组连接好的呈现。其实内部还是[a,b,c]的方式进行排列的。这一点需要注意。
•将字符数组转换成字符串
实例3(String .copyValueOf()以及.valueOf())
package com.java.demo_9;
public class charChangetoString {
public static void main(String[] args) {
char[] arr = {'a','b','c','d','e','f','g'};
//方法1:
String str = "";
str = str.copyValueOf(arr);
System.out.println(str);
//方法2:
String str1 = null;
str1 = str1.valueOf(arr);
System.out.println(str1);
}
}
结果:当然方法很多。上面列举我们这次学过的2种方法。(1)是通过.copyValueOf的方式把字符数组中的元素copy到String类型的空字符串中。然后再打印。(2)直接通过.valueOf的方式进行类型转换成String,
•将字符串转换成字节数组
byte[] toBytes
注释:以后在数据传输过程中经常会遇到字节等的数据转换,下面的案例是String转Byte,以及Byte如何再转回String的简单案例。
实例4(byte[] toBytes)
package com.java.demo_9;
public class charChangetoString {
public static void main(String[] args) {
/**
* String 转 byte[]
*/
String str = "hello";
byte[] strbyte = str.getBytes();
for(int i=0;i<strbyte.length;i++){
System.out.println(strbyte[i]);
}
/**
* byte[]转String
*/
byte [] a = {104,101,108,108,111};
String str1 = new String(a);
System.out.println(str1);
/*
* byte转String(单一值)
*/
byte b = 101;
System.out.println(Byte.toString(b));
System.out.println(b + "");
System.out.println(new String(new byte[] {b}));
}
}
结果:
(1)其实先把字符串拆分成了byte[]数组。然后通过str.getBytes()方法分别放到数组中。再通过for循环的方式打印它们的值。如果不用for循环打印出来的是乱码。
(2)是把byte数组中的元素,逐一转换成字符串。个人感觉这种方法比较好用。
(3)提供了3种转换方法。任何一种方法都可以。但是要注意的是,第一种跟第二种方法虽然转换成了字符串但是值还是byte本身。要想转换成字符串值最好通过第三种方法或者(2)种的方法。
替换方法
String replace(olderStr,newStr)
注释:字符串替换。olderStr为原有字符串值,newStr为替换后的字符串值。
实例4(String replace(olderStr,newStr))
package com.java.demo_9;
public class charChangetoString {
public static void main(String[] args) {
String str = "www.google.com";
System.out.println("修改前:" + str);
String str1=null;
str1 = str.replaceAll("com","jp.com");
System.out.println("修改后:" + str1);
}
}
结果:上面的结果非常的显而易见,修改前的字符串为“www.google.com”。而通过.replaceAll(oldStr,newStr)转换后的值为“www.google.jp.com”
切割方法
String split(regex)
注释:通过split来进行字符串的分隔。但是这里要强调一点的是,java中的split并没有想象中的那么好用。因为它的部分字符要求不得跟ASIC码中的特殊字符相重。如果重复的话就不会取到我们想要的结果。通常在这种情况下需要通过\\转译符再加上要分隔对象来进行取值。但是这种方法只能解决80%的问题。但是大部分还是可以取到的。具体案件具体分析。那么接下来我们一起来看一下split的用法。具体内容可以参照下列博文。
实例5(String split(regex))
package com.java.demo_9;
public class charChangetoString {
public static void main(String[] args) {
String str = "192.168.9.121";
System.out.println("原始数据:"+str);
System.out.println("+++++++++++++++++++++++++++++++++");
String []str1 = str.split("\\.");
System.out.println("分割后打印数据:"+str1);
System.out.println("++++++++++++++++++++++++++++++++++");
for(int i=0;i<str1.length;i++){
System.out.println("for循环过后数据:"+str1[i]);
}
}
}
结果:除了分隔符"++++"以外,System.out.println();打印出来的三段数据如下。
(1)原始数据。
(2)通过.split(“分隔符”)方法后直接打印的数据。这里可以看出打印出来的是个迭代器。并不能直观的看到里面的值。(这里需要注意一点的是:当我们通过split方法来对特殊符号.来进行分隔的时候必须加上\\转译符再加上点,例如(\\.)的方式来进行分隔。不然是没有数据的。这就是split方法不遍的地方)
(3)基于.split方法分隔后的数据然后再加上for循环来打印分隔后字符串数组中的每个元素。
更详细的方法解读请参照下列博客博文。
原始数据:192.168.9.121
+++++++++++++++++++++++++++++++++
分割后打印数据:[Ljava.lang.String;@c21495
++++++++++++++++++++++++++++++++++
for循环过后数据:192
for循环过后数据:168
for循环过后数据:9
for循环过后数据:121
博客:http://www.cnblogs.com/mingforyou/archive/2013/09/03/3299569.html
获取子串[编辑分类]
注释:这个也可以取字符串,但是你必须清楚的知道每个字符的下标后才方便于截取。beginIndex就是从起始位开始0就是第一个字符。endIndex顾名思义就是结束位。重点要说一下String subString(beginIndex,endIndex)。因为它是顾头不顾尾的,因此如果想要从一个字符串任意一位直接到末尾的话,直接用beginIndex就够了。如果想要精确截取字符串中的某一段字符的话,必须要清楚的知道起始位以及结束位的下标,然后才能精准的截取。一起来看一下下面的例子。
String subString(beginIndex)
String subString(beginIndex,endIndex)包含头不包含尾
实例6(String subString(beginIndex) 以及String subString(beginIndex,endIndex))
package com.java.demo_9;
public class charChangetoString {
public static void main(String[] args) {
String str = "192.168.9.121";
String str1 = str.substring(0, 8);
System.out.println(str1);
String str2 = "今天的天气不错!";
String str3 = str2.substring(3);
System.out.println(str3);
String str4 = str2.substring(2, 5);
System.out.println(str4);
String str5 = str2.substring(0, 9);
System.out.println(str5);
}
}
结果:
(1)返回结果为:192.168. 分析:起始位为0,endIndex为8,按道理“192.168.9.121”中的第8位应该为9,那为什么只截取到了.而没包含9呢。这里要说明的是endIndex截取的其实是endIndex -1后的字符。而不是endIndex指向的字符。这点一定要注意!!
(2)返回结果为:天气不错! 分析:因为这里用到的是beginIndex的用法。只要指定开头位就可以了,然后一直截取到最后。最终得到的值就是天气不错!
(3)返回结果为:的天气 分析:这里用到的方法是beginIndex,endIndex方法。精确指定了要截取的位置下标。所以把这中间包含的字符串一并截取出来了。
(4)返回结果为下列异常:
Exception in thread "main" java.lang.StringIndexOutOfBoundsException: String index out of range: 9
at java.lang.String.substring(String.java:1935)
at com.java.demo_9.charChangetoString.main(charChangetoString.java:20)
分析:今天的天气不错!总共加起来就8个字符。而我们的endIndex设定的为9超出了字符串的长度因此会抛出异常。另外起始位<0或者结束位>字符串长度都会抛出这个异常。
将字符串转换成大小写
String toUpperCase()
String toLowerCase()
注释:toUpperCase()是将字符串全部转换为大写。相反toLowerCase()是将字符串全部转换为小写。
实例7(String toUpperCase() 以及 String subString(beginIndex,endIndex))
package com.java.demo_9;
public class charChangetoString {
public static void main(String[] args) {
/**
* 讲字符串全部转换为大写
*/
String str = "my name is liupeng. comefrom shandong yantai!";
String str1 = str.toUpperCase();
System.out.println(str1);
/**
* 讲字符串全部转换为小写
*/
String str2 = str.toLowerCase();
System.out.println(str2);
/**
* 字符串首字母大写
*/
str =str.replaceFirst(str.substring(0, 1),str.substring(0, 1).toUpperCase());
System.out.println(str);
}
}
结果:
(1)返回值:MY NAME IS LIUPENG. COMEFROM SHANDONG YANTAI!
(2)返回值:my name is liupeng. comefrom shandong yantai!
(3)返回值:My name is liupeng. comefrom shandong yantai! 分析:先.replaceFirst方法来替换字符串,然后内部先通过.subString方法找到要替换字符串的下标。找到后再通过.toUpperCase()的方法进行转换。据说这种方法不太好。有更好的方法的大神们可以多多指导。谢谢。
另外添加一个案例:(一并替换相同的字符)
package com.java.demo_9;
public class tes {
public static void main(String[] args) {
String a = "come,come,come";
String c = a.replaceAll("c", "C");
System.out.println(c);
/*String b = a.replaceFirst(a.substring(0, 1), a.substring(0, 1).toUpperCase());
System.out.println(b);
for(int i=0;i<a.length();i++){
if(a.contains("c")){
a=a.replaceAll("c", "C");
}
}
System.out.println(a);*/
}
}
结果:返回值为:Come,Come,Come由此可以看出这个语句是替换指定的字符的。我只是用了replaceAll这个方法来直接替换了。这么做也有不要的地方,如果字符串中有c但是不是你指向替换指定的c而不想替换某个c的时候不适合用这个方法。
将字符串两端的空格去除
String trim()
实例7(String trim())
注释:这个在上面的案例中其实已经列举过了。在此不多加说明直接上案例。(作用:去除字符串前后空格用的。注意:字符串中间的空格是去除不了的。不要问为什么。。)
package com.java.demo_9;
public class tes {
public static void main(String[] args) {
String str = " 今天天气不错呀! ";
System.out.println("修改前:"+str);
String result = str.trim();
System.out.println("修改后:"+result);
}
}
结果:(自己看差异)
(1)修改前: 今天天气不错呀!
(2)修改后:今天天气不错呀!
对两个字符串进行自然顺序的比较
int compareTo(String str)
实例8(int compareTo(String str))
注释:返回一个int类型的数据。其比较规则是:拿出字符串的第一个字符与参数的第一个字符进行比较,如果两者不等,比较结束,返回两者的ascii差,即字符串的第一个字符减去参数的第一个字符的ascii码值。如果比较到最后结果全部相等的话,返回值为0。
这里有一点需要注意:如果两个字符串的长度不同,并且一个字符串与另一个字符串的前面N个字符相等,那么这个方法返回返回两个字符串长度之差。
package com.java.demo_9;
public class tes {
public static void main(String[] args) {
String str1 = "abac";
String str2 = "abac";
String str3 = "abad";
System.out.println(str1.compareTo(str2));
System.out.println(str1.compareTo(str3));
String str4 = "今天天气不错";
String str5 = "今天天气不错!!";
String str6 = "今天天气不错";
System.out.println(str4.compareTo(str5));
System.out.println(str4.compareTo(str6));
}
}
结果:
(1)返回值为:0 对比结果相等因此返回0
(2)返回值为:-1 分析:因为abac跟abad之间最后一位c跟d比较缺少1位因此返回为-1。以此类推如果是abae返回-2,abaf返回-3
(3)返回值为:-2 分析:最后2个字符明显多余对比的字符因此返回-2
(4)返回值为:0 对比结果相等因此返回0
字符串的用法实在很多,上述只是列举了最基础的一些方法,方便记忆。灵活应用才是王道。后续项目中遇到更复杂的会另外更新。