[19/03/15-星期五] 常用类_String类&StringBuilder和StringBuffer类

最新推荐文章于 2024-09-12 21:36:48 发布

Hellowongwong

最新推荐文章于 2024-09-12 21:36:48 发布

阅读量64

点赞数

文章标签： runtime java

原文链接：http://www.cnblogs.com/ID-qingxin/p/10532902.html

版权

一、基本概念

String 类对象代表不可变的Unicode字符序列，因此我们可以将String对象称为“不可变对象”。那什么叫做“不可变对象”呢? 指的是对象内部的成员变量的值无法再改变。String类

的源码中发现字符串内容全部存储到value[]数组中，而变量value是final类型的，也就是常量(即只能被赋值一次)。这就是“不可变对象”的典型定义方式。

如：substring()是对字符串的截取操作，但本质是读取原字符串内容生成了新的字符串。测试代码如下：

1         String s1 = new String("abcdef");
2         String s2 = s1.substring(2, 4);
3 
4         // 打印出：ab199863
5         System.out.println(Integer.toHexString(s1.hashCode()));
6 
7         // 打印出：c61, 显然s1和s2不是同一个对象
8         System.out.println(Integer.toHexString(s2.hashCode()));

 1        //编译器做了优化,直接在编译的时候将字符串进行拼接
 2         String str1 = "hello" + " java";//相当于str1 = "hello java";
 3         String str2 = "hello java";
 4         System.out.println(str1 == str2);//输出 true
 5 
 6         String str3 = "hello";
 7         String str4 = " java";
 8         //编译的时候不知道变量中存储的是什么,所以没办法在编译的时候优化
 9         String str5 = str3 + str4;
10         System.out.println(str2 == str5);//输出false
11     }

【常用方法】

1. String类的下述方法能创建并返回一个新的String对象: concat()、 replace()、substring()、 toLowerCase()、 toUpperCase()、trim()。

2. 提供查找功能的有关方法: endsWith()、 startsWith()、 indexOf()、lastIndexOf()。

3. 提供比较功能的方法: equals()、equalsIgnoreCase()、compareTo()。

4. 其它方法: charAt() 、length()

【举例】

1、public int indexOf(String str) 返回字符串中从下标0开始出现字符串str的第一个位置(下标)

2、public int indexOf(String str,int fromIndex) 返回字符串中从下标fromIndex开始出现字符串str的第一个位置(下标)

3、public String substring(int start) 从数字start下标开始提取字符串

4、public String substring(int start,int end) 从数字start下标开始提取字符串到end下标为止，但不包含end下标的字符

5、public int length() 返回字符串长度

6、char charAt(int index) 返回字符串中第index个字符

二、StringBuilder和StringBuffer类 ( 可以存储和操作字符串类)

StringBuffer和StringBuilder非常类似，均代表可变的字符序列。这两个类都是抽象类

【区别】

1. StringBuffer JDK1.0版本提供的类，线程安全，做线程同步检查，效率较低。

2. StringBuilder JDK1.5版本提供的类，线程不安全，不做线程同步检查，因此效率较高。建议采用该类。

【StringBuilder类的方法】

1. 重载的public StringBuilder append(…)方法可以为该StringBuilder 对象添加字符序列，仍然返回自身对象。

2. 方法 public StringBuilder delete(int start,int end) 可以删除从start开始到end-1为止的一段字符序列，仍然返回自身对象。

3. 方法 public StringBuilder deleteCharAt(int index) 移除此序列指定位置上的 char，仍然返回自身对象。

4. 重载的public StringBuilder insert(…)方法可以为该StringBuilder 对象在指定位置插入字符序列，仍然返回自身对象。

5. 方法 public StringBuilder reverse() 用于将字符序列逆序，仍然返回自身对象。

6. 方法 public String toString() 返回此序列中数据的字符串表示形式。

【示例】

 1 /**测试StringBuilder类
 2  * 
 3  */
 4 package cn.sxt.test;
 5 
 6 public class Test_0315_StringBuilder {
 7     public static void main(String[] args) {
 8     StringBuilder sb =new StringBuilder(); 
 9         //实现输出26个英文字母
10         for(int i=0;i<26;i++){
11             char temp=(char)('a'+i); //'a'的ASCII码是97，然后让它加0还等于97是int型数字，再强制转型为char型用temp接收
12             sb.append(temp);//依次循环    append方法，可以实现数组对象sb不变，依次在数组后边累加字符      append：累加、粘贴
13         }
14         System.out.println(sb);
15         
16         //验证各个方法
17         
18         System.out.println(sb.reverse());//实现对对象sb掉头翻转,返回对象本身，可以写在System.out.println()中
19         
20         sb.setCharAt(4, '李');//实现对s下标为4的位置的字符换成字符'李'
21         System.out.println(sb); //setCharAt() 空的返回值方法，不能直接写在System.out.println()中
22         
23         System.out.println(sb.insert(7, '我')); //在下标为7的位置插入字符'我'
24         
25         System.out.println(sb.delete(3, 5));//删除下标从0开始到5结束的字符段
26         
27         
28     }
29 
30 }

三、区别

String一经初始化后，就不会再改变其内容了。对String字符串的操作实际上是对其副本(原始拷贝)的操作，原来的字符串一点都没有改变。比如： String s ="a"; 创建了一个字符

串s = s+"b"; 实际上原来的"a"字符串对象已经丢弃了，现在又产生了另一个字符串s+"b"(也就是"ab")。如果多次执行这些改变串内容的操作，会导致大量副本字符串对象存留在内存

中，降低效率。如果这样的操作放到循环中，会极大影响程序的时间和空间性能，甚至会造成服务器的崩溃。相反，StringBuilder和StringBuffer类是对原字符串本身操作的，可以对

字符串进行修改而不产生副本拷贝或者产生少量的副本。因此可以在循环中使用。

 1 public class Test {
 2     public static void main(String[] args) {
 3         /**使用String进行字符串的拼接*/
 4         String str8 = "";
 5         //本质上使用StringBuilder拼接, 但是每次循环都会生成一个StringBuilder对象
 6         long num1 = Runtime.getRuntime().freeMemory();//获取系统剩余内存空间
 7         long time1 = System.currentTimeMillis();//获取系统的当前时间
 8         for (int i = 0; i < 5000; i++) {
 9             str8 = str8 + i;//相当于产生了10000个对象
10         }
11         long num2 = Runtime.getRuntime().freeMemory();
12         long time2 = System.currentTimeMillis();
13         System.out.println("String占用内存 : " + (num1 - num2));
14         System.out.println("String占用时间 : " + (time2 - time1));
15         /**使用StringBuilder进行字符串的拼接*/
16         StringBuilder sb1 = new StringBuilder("");
17         long num3 = Runtime.getRuntime().freeMemory();
18         long time3 = System.currentTimeMillis();
19         for (int i = 0; i < 5000; i++) {
20             sb1.append(i);
21         }
22         long num4 = Runtime.getRuntime().freeMemory();
23         long time4 = System.currentTimeMillis();
24         System.out.println("StringBuilder占用内存 : " + (num3 - num4));
25         System.out.println("StringBuilder占用时间 : " + (time4 - time3));
26     }
27 }