小小的String（2）

前言

老韩讲解的还是深得我心，醍醐灌顶呀，特此来留念。

1、String类

String对象用于保存字符串，也就是一组字符序列
字符串常量对象是用双引号括起的字符序列。例如: “你好”、 “12.97”、 "boy"等
字符串的字符使用Unicode字符编码，一个字符(不区分字母还是汉字)占两个字节。
String类较常用构造器:

String s1 = new String(); 
String s2 = new String(String original);
String s3 = new String(char[] a);
String s4 = new String(char[] a,int startIndex,int count)

 

Serializable 意味着可以在网络传输

Comparable 可以比较

2、创建String对象的方式

public class String01 {
    public static void main(String[] args) {
        // 方式1: 先从常量池查看是否有"hsp"数据空间，如果有，直接指向;
        // 如果没有则重新创建，然后指向。
        // s1最终指向的是常量池的空间地址
        String s1 = "hsp";
        // 方式二:先在堆中创建空间，里面维护了value属性，指向常量池的hsp空间。
        // 如果常量池没有"hsp"，重新创建，如果有，直接通过value指向。
        // 最终指向的是堆中的空间地址。
        String s2 = new String("hsp");
    }
}

 

举例

public class String01 {
    public static void main(String[] args) {
        String a = "hsp";//指向常量池中的"hsp"
        String b = new String("hsp");//指向堆中对象, 堆的对象再指向常量"hsp"
        System.out.println(a.equals(b));//T, 内容相同
        System.out.println(a == b);//F
        System.out.println(a == b.intern()); //T, b.intern()方法返回常量池中的地址
        System.out.println(b == b.intern());//F
    }
}

 

3、String的特点

1. String是一个final类， 代表不可变的字符序列
2. 字符串是不可变的。一个字符串对象一旦被分配，其内容是不可变的.

以下语句创建了几个对象?画出内存布局图。

String s1 = "hello";
s1 = "haha"; 

答：2个

String a="hello"+"abc";

此代码创建了多少个对象？
 

答：1个

分析

 编译器做一个优化，判断创建的常量池对象，是否有引用指向
String a = "hello"+"abc"; =》String a = "helloabc";

 以下语句创建了几个对象

String a="hello";
String b="abc";
String c=a+b;

在第三句话 打断点咱们来瞅瞅

首先新建了StringBuilder对象, 然后append “hello”, 然后append “abc”, 最后toString().

所以新建了三个对象

底层是StringBuilder sb = new StringBuilder( sb.append(a);  sb.append(b); sb是在堆中，并且append是在原来字符串的基础上追加的.

重要规则，

String c1 = "ab" + "cd"; 常量相加，看的是池。

String c1 = a+b; 变量相加, 是在堆中

public class String01 {
    public static void main(String[] args) {
        String a = "hello"; //创建a对象
        String b = "abc";//创建 b对象
        //老韩解读
        //1. 先创建个StringBuilder sb = StringBuilder()
        //2.执行sb. append("hello");
        //3. sb.append("abc");
        //4. String c= sb.toString()
        //最后其实是c指向堆中的对象(String) value[] ->池中"helloabc"
        String c = a + b;
        String d = "helloabc";
        System.out.println(c == d);// 真还是假?是false
        String e = "hello" + "abc";// 直接看池，e指向常量池
        System.out.println(d == e);//真还是假?是true
    }
}

4、String类的常用方法

String类是保存字符串常量的。每次更新都需要重新开辟空间，效率较低，因此java设计者还提供了StringBuilder和StringBuffer来增强String的功能，并提高效率。

equals /区分大小写，判断内容是否相等
equalslgnoreCase //忽略大小写的判断内容是否相等
length //获取字符的个数，字符串的长度
indexOf //获取字符在字符串中第1次出现的索引,索引从开始，如果找不到,返回-1
lastIndexOf //获取字符在字符串中最后1次出现的索引,索引从0开始,如找不到,返回-1
substring //截取指定范围的子串
trim //去前后空格
charAt //获取某索引处的字符，注意==不能使用Str[index]==这种方式.
 

5、StringBuffer类

java.lang.StringBuffer代表可变的字符序列，可以对字符串内容进行增删。
很多方法与String相同，但StringBuffer是 可变长度的。
StringBuffer是一个容器。

String VS StringBuffer
String保存的是字符串常量，里面的值不能更改，每次String类的更新实际上就是更改地址，效率较低 //private final char value[];
StringBuffer保存的是字符串变量，里面的值可以更改，每次StringBuffer的更新实际上可以更新内容，不用更新地址，效率较高
//char[] value; // 这个放在堆.
 

//1. StringBuffer 的直接父类是AbstractStringBuilder
//2. StringBuffer 实现了Serializable, 即StringBuffer的对象可以串行化
//3. 在父类中 AbstractStringBuilder 有属性char[] value, 不是final
// 该vaLue数组存放字符串内容，引用存放在堆中的
//4. StringBuffer 是一个final类， 不能被继承
//5. 因为StringBuffer字符内容是存在char[] vaLue, 所有在变化(增加/删除) 不用每次都更换地址(即创建新对象), 所以效率高于String
 

StringBuffer的构造器

StringBuffer类常见方法

1)增append
2)删delete(start,end)
3)改replace(start,end,string)//将start-end间的内容替换掉,不含end
4)查indexOf //查找子串在字符串第1次出现的索引,如果找不到返回-1
5)插insert
6)获取长度length

输入商品价格，要求打印效果示例，使用前面学习的方法完成:
手机123,564.59 //比如价格3,456,789.88

要求:价格的小数点前面每三位用逗号隔开，在输出。

public class String01 {
    public static void main(String[] args) {
        String price = "38976666.66";
        StringBuffer sb = new StringBuffer(price);//转成StringBuffer
        // 找到小数点的索引, 然后在该位置的前面每三位插入即可
        int i = sb.lastIndexOf(".");
        for (int j = i; j > 3; j -= 3) {
            sb.insert(j - 3, ',');
        }
        System.out.println(sb);
    }
}

6、StringBuilder类

1)一个可变的字符序列。此类提供一个与StringBuffer兼容的API,但不保证同步(StringBuilder不是线程安全)。该类被设计用StringBuffer的一个简易替换，用在字符串缓冲区被单个线程使用的时候。如果可能，建议优先采用该类因为在大多数实现中，它比StringBuffer要快。
2)在StringBuilder上的主要操作是append和insert方法，可重载这些方法，以接受任意类型的数据。

 

StringBuilder 继承AbstractStringBuilder类
实现了Serializable ,说明StringBuilder对象是可以串行化(对象可以网络传输，可以保存到文件)
StringBuilder 是final类，不能被继承
StringBuilder 对象字符序列仍然是存放在其父类AbstractStringBuilder的 char[] value ;
因此，字符序列是存在堆中
StringBuilder 的方法，没有做互斥的处理，即没 有synchronized 关键字,因此在 单线程的情况下使用StringBuilder
String、 StringBuffer和StringBuilder的比较
StringBuilder和StringBuffer非常类似，均代表可变的字符序列，而且方法也一样

String:不可变字符序列，效率低,但是复用率高。

StringBuffer:可变字符序列、效率较高(增删)、线程安全，看源码

StringBuilder:可变字符序列、效率最高、线程不安全

String使用注意说明:
string s=“a”; //创建了一个字符串
s += “b”; //实际上原来的"a"字符串对象已经丢弃了，现在又产生了一个字符串s+“b” (也就是ab")。
如果多次执行这些改变串内容的操作，会导致大量副本字符串对象存留在内存中，降低效率。
如果这样的操作放到循环中，会极大影响程序的性能=>
结论:如果我们对String做大量修改，不要使用String

String、 StringBuffer和StringBuilder的效率测试
public class String01 {
    public static void main(String[] args) {
        String text = "";
        long startTime = 0L;
        long endTime = 0L;
        StringBuffer buffer = new StringBuffer("");
        StringBuilder builder = new StringBuilder("");
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 200000; i++) {
            buffer.append(String.valueOf(i));
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuffer的执行时间: " + (endTime - startTime));
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 200000; i++) {
            builder.append(String.valueOf(i));
        }
        endTime = System.currentTimeMillis();
        System.out.println("StringBuilder的执行时间: " + (endTime - startTime));
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 200000; i++) {
            text = text + i;
        }
        endTime = System.currentTimeMillis();
        System.out.println("String的执行时间:" + (endTime - startTime));
    }
}

StringBuffer的执行时间: 23
StringBuilder的执行时间: 18
String的执行时间:28168

7、String、 StringBuffer和StringBuilder的选择原则

使用的原则，结论:
1.如果字符串存在大量的修改操作，一般使用StringBuffer或StringBuilder
2.如果字符串存在大量的修改操作，并在单线程的情况，使用StringBuilder
3.如果字符串存在大量的修改操作，并在多线程的情况，使用StringBuffer
4.如果我们字符串很少修改，被多个对象引用，使用String, 比如配置信息等
StringBuilder的方法使用和StringBuffer一样，不再说
 

关于String的请收藏这两篇吧，够用啦！