Java基础——字符串

1. Java 程序中的所有字符串字面值(如 “abc” )都作为此类的实例实现。
2. String是一个final类,代表不可变的字符序列。
3. 字符串是常量,用双引号引起来表示。它们的值在创建之后不能更改。
4. String对象的字符内容是存储在一个字符数组value[]中的

创建

存储

String 被声明为 final，因此它不可被继承。(Integer 等包装类也不能被继承）
在 Java 8 中，String 内部使用 char 数组存储数据。

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];
}
1
2
3
4
5

不可变的好处

1. 可以缓存 hash 值
   因为 String 的 hash 值经常被使用，例如 String 用做 HashMap 的 key。不可变的特性可以使得 hash 值也不可变，因此只需要进行一次计算。
2. String Pool 的需要
   如果一个 String 对象已经被创建过了，那么就会从 String Pool 中取得引用。只有 String 是不可变的，才可能使用 String Pool。
   
3. 安全性
   String 经常作为参数，String 不可变性可以保证参数不可变。例如在作为网络连接参数的情况下如果 String 是可变的，那么在网络连接过程中，String 被改变，改变 String 对象的那一方以为现在连接的是其它主机，而实际情况却不一定是。
4. 线程安全
   String 不可变性天生具备线程安全，可以在多个线程中安全地使用。

空字符串
""表示空字符串，表示没有任何内容，空字符串是分配了内存空间，
null是没有分配内存空间。

类型转换

valueOf
基本数据类型、包装类 转成字符串，调用String类的public String valueOf(int n)可将int型转换为字符串相应的valueOf(byte b)、valueOf(long l)、valueOf(float f)、valueOf(doubled)、valueOf(boolean b)可由参数的相应类型到字符串的转换

        String intVal = String.valueOf(1);
        System.out.println(intVal);
        String floatVal = String.valueOf(2.5);
        System.out.println(floatVal);
        char[] charList = {'a','b','c'};
        String charVal = String.valueOf(charList);
        System.out.println(charVal);
1
2
3
4
5
6
7

parseXXX
Integer包装类的public static int parseInt(String s):可以将由“数字”字符组成的字符串转换为整型。
类似地,使用java.lang包中的Byte、Short、Long、Float、Double类调相应的类方法可以将由“数字”字符组成的字符串,转化为相应的基本数据类型。

        int i = Integer.parseInt("10");
        System.out.println(i);
        float v = Float.parseFloat("3.1415926");
        System.out.println(v);
1
2
3
4

StringBuffer

StringBuffer是线程安全的，它的方式支持线程同步，线程同步会操作串行顺序执行，在单线程环境下回影响效率。

StringBuffer append(xxx):提供了很多的append()方法,用于进行字符串拼接
StringBuffer delete(int start,int end):删除指定位置的内容
StringBuffer replace(int start, int end, String str):把[start,end)位置替换为str
StringBuffer insert(int offset, xxx):在指定位置插入xxx
StringBuffer reverse() :把当前字符序列逆转
public int indexOf(String str)
public String substring(int start,int end)
public int length()
public char charAt(int n )
public void setCharAt(int n ,char ch)
1
2
3
4
5
6
7
8
9
10

StringBuider

StringBuilder是StringBuffer单线程版本，它不是线程安全的，但它的执行效率最高

		StringBuilder str = new StringBuilder();
        System.out.println(str.length());
        System.out.println(str.capacity());//默认缓冲器容量是16
        StringBuilder str1 = new StringBuilder("hello");
        System.out.println(str1.length());
        System.out.println(str1.capacity());//
1
2
3
4
5
6

字符串增加

		StringBuilder str = new StringBuilder("Hello");
		str.append(" ").append("World");
		System.out.println(str);
1
2
3

字符串插入，删除，替换

		StringBuilder str = new StringBuilder("Hello World");
        str.insert(5," Java");
        System.out.println(str);
        str.delete(5," Java".length()+5);
        System.out.println(str);
        str.replace(6,11,"Java");
        System.out.println(str);
1
2
3
4
5
6
7

String Pool

字符串常量池（String Pool）保存着所有字符串字面量（literal strings），这些字面量在编译时期就确定。不仅如此，还可以使用 String 的 intern() 方法在运行过程中将字符串添加到 String Pool 中。

当一个字符串调用 intern() 方法时，如果 String Pool 中已经存在一个字符串和该字符串值相等（使用 equals() 方法进行确定），那么就会返回 String Pool 中字符串的引用；否则，就会在 String Pool 中添加一个新的字符串，并返回这个新字符串的引用。

下面示例中，s1 和 s2 采用 new String() 的方式新建了两个不同字符串，而 s3 和 s4 是通过 s1.intern() 方法取得一个字符串引用。intern() 首先把 s1 引用的字符串放到 String Pool 中，然后返回这个字符串引用。因此 s3 和 s4 引用的是同一个字符串。

String s1 =newString("aaa");
String s2 =newString("aaa");
System.out.println(s1 == s2);           // false
String s3 = s1.intern();
String s4 = s1.intern();
System.out.println(s3 == s4);           // true
1
2
3
4
5
6

如果是采用 “bbb” 这种字面量的形式创建字符串，会自动地将字符串放入

String Pool 中。
String s5 ="bbb";
String s6 ="bbb";
System.out.println(s5 == s6);  // true
1
2
3
4

在 Java 7 之前，String Pool 被放在运行时常量池中，它属于永久代。而在 Java 7，String Pool 被移到堆中。这是因为永久代的空间有限，在大量使用字符串的场景下会导致 OutOfMemoryError 错误。

new String(“abc”)

使用这种方式一共会创建两个字符串对象（前提是 String Pool 中还没有 “abc” 字符串对象）。

• “abc” 属于字符串字面量，因此编译时期会在 String Pool 中创建一个字符串对象，指向这个 “abc” 字符串字面量；
• 而使用 new 的方式会在堆中创建一个字符串对象。
  创建一个测试类，其 main 方法中使用这种方式来创建字符串对象。

public class NewStringTest {
    public static void main(String[] args) {
        String s = new String("abc");
    }
}
1
2
3
4
5

String 的编码方式

String 可以看成一个字符序列，可以指定一个编码方式将它编码为字节序列，也可以指定一个编码方式将一个字节序列解码为 String。

String str1 ="中文";
byte[] bytes = str1.getBytes("UTF-8");
String str2 =newString(bytes, "UTF-8");
System.out.println(str2);
1
2
3
4

在调用无参数 getBytes() 方法时，默认的编码方式不是 UTF-16be。双字节编码的好处是可以使用一个 char 存储中文和英文，而将 String 转为 bytes[] 字节数组就不再需要这个好处，因此也就不再需要双字节编码。getBytes() 的默认编码方式与平台有关，一般为 UTF-8。
byte[] bytes = str1.getBytes();