认识String类

在开发和校招笔试中，字符串也是常客，

比如： 字符串转整形数字 字符串相加

而且在面试中也频繁被问到，比如：String、StringBuff和StringBulider之间的区别等。

1. 常用方法

String类提供的构造方式非常多，常用的就以下三种：

public static void main(String[] args) {
    // 使用常量串构造
    String s1 = "hello bit";
    System.out.println(s1);

    // 直接newString对象
    String s2 = new String("hello bit");
    System.out.println(s1);

    // 使用字符数组进行构造
    char[] array = {'h','e','l','l','o','b','i','t'};
    String s3 = new String(array);
    System.out.println(s1);
}

【注意】

1. String是引用类型，内部并不存储字符串本身，在String类的实现源码中，String类实例变量如下：

 

public static void main(String[] args) {
    // s1和s2引用的是不同对象 s1和s3引用的是同一对象
    String s1 = new String("hello");
    String s2 = new String("world");
    String s3 = s1;

    System.out.println(s1.length()); // 获取字符串长度---输出5
    System.out.println(s1.isEmpty()); // 如果字符串长度为0，返回true，否则返回false
}

 

 2. 在Java中“ ”引起来的也是String类型对象。

// 打印"hello"字符串(String对象)的长度

System.out.println("hello".length());

 1.2 String对象的比较

字符串的比较是常见操作之一，比如：字符串排序。Java中总共提供了4中方：

1. ==比较是否引用同一个对像

注意：对于内置类型，==比较的是变量中的值；对于引用类型==比较的是引用中的地址。

2. boolean equals(Object anObject) 方法：按照字典序比较

 

public static void main(String[] args) {
    int a = 10;
    int b = 20;
    int c = 10;
    // 对于基本类型变量，==比较两个变量中存储的值是否相同
    System.out.println(a == b); // false
    System.out.println(a == c); // true
    // 对于引用类型变量，==比较两个引用变量引用的是否为同一个对象
    String s1 = new String("hello");
    String s2 = new String("hello");
    String s3 = new String("world");
    String s4 = s1;
    System.out.println(s1 == s2); // false
    System.out.println(s2 == s3); // false
    System.out.println(s1 == s4); // true
}

2. boolean equals(Object anObject) 方法：按照字典序比较

字典序：字符大小的顺序

String类重写了父类Object中equals方法，Object中equals默认按照==比较，String重写equals方法后，按照 如下规则进行比较，比如： s1.equals(s2)

public boolean equals(Object anObject) {
	// 1. 先检测this 和 anObject 是否为同一个对象比较，如果是返回true
	if (this == anObject) {
	return true;
	}
	// 2. 检测anObject是否为String类型的对象，如果是继续比较，否则返回false
	if (anObject instanceof String) {
	// 将anObject向下转型为String类型对象
	String anotherString = (String)anObject;
	int n = value.length;
	// 3. this和anObject两个字符串的长度是否相同，是继续比较，否则返回false
	if (n == anotherString.value.length) {
	char v1[] = value;
	char v2[] = anotherString.value;
	int i = 0;
	// 4. 按照字典序，从前往后逐个字符进行比较
	while (n-- != 0) {
	if (v1[i] != v2[i])
	return false;
	i++;
	}
	return true;
	}
	}
	return false;
}

 

public static void main(String[] args) {
	String s1 = new String("hello");
	String s2 = new String("hello");
	String s3 = new String("Hello");
	
	// s1、s2、s3引用的是三个不同对象，因此==比较结果全部为false
	System.out.println(s1 == s2); // false
	System.out.println(s1 == s3); // false

	// equals比较：String对象中的逐个字符
	// 虽然s1与s2引用的不是同一个对象，但是两个对象中放置的内容相同，因此输出true
	// s1与s3引用的不是同一个对象，而且两个对象中内容也不同，因此输出false
	System.out.println(s1.equals(s2)); // true
	System.out.println(s1.equals(s3)); // false
}

 3. int compareTo(String s) 方法: 按照字典序进行比较

与equals不同的是，equals返回的是boolean类型，而compareTo返回的是int类型。具体比较方式：

1. 先按照字典次序大小比较，如果出现不等的字符，直接返回这两个字符的大小差值

2. 如果前k个字符相等(k为两个字符长度最小值)，返回值两个字符串长度差值

public static void main(String[] args) {
	String s1 = new String("abc");
	String s2 = new String("ac");
	String s3 = new String("abc");
	String s4 = new String("abcdef");
	System.out.println(s1.compareTo(s2)); // 不同输出字符差值-1
	System.out.println(s1.compareTo(s3)); // 相同输出 0
	System.out.println(s1.compareTo(s4)); // 前k个字符完全相同，输出长度差值 -3
}

 4. int compareToIgnoreCase(String str) 方法：与compareTo方式相同，但是忽略大小写比较

public static void main(String[] args) {
    String s1 = new String("abc");
    String s2 = new String("ac");
    String s3 = new String("ABc");
    String s4 = new String("abcdef");
    System.out.println(s1.compareToIgnoreCase(s2)); // 不同输出字符差值-1
    System.out.println(s1.compareToIgnoreCase(s3)); // 相同输出 0
    System.out.println(s1.compareToIgnoreCase(s4)); // 前k个字符完全相同，输出长度差值 -3
}

 1.3 字符串查找

字符串查找也是字符串中非常常见的操作，String类提供的常用查找的方法：

 

public static void main(String[] args) {
    String s = "aaabbbcccaaabbbccc";
    System.out.println(s.charAt(3)); // 'b'
    System.out.println(s.indexOf('c')); // 6
    System.out.println(s.indexOf('c', 10)); // 15
    System.out.println(s.indexOf("bbb")); // 3
    System.out.println(s.indexOf("bbb", 10)); // 12
    System.out.println(s.lastIndexOf('c')); // 17
    System.out.println(s.lastIndexOf('c', 10)); // 8
    System.out.println(s.lastIndexOf("bbb")); // 12
    System.out.println(s.lastIndexOf("bbb", 10)); // 3

 注意：上述方法都是实例方法。

1.4 转化

1. 数值和字符串转化

public static void main(String[] args) {
    // 数字转字符串
    String s1 = String.valueOf(1234);
    String s2 = String.valueOf(12.34);
    String s3 = String.valueOf(true);
    String s4 = String.valueOf(new Student("Hanmeimei", 18));
    System.out.println(s1);
    System.out.println(s2);
    System.out.println(s3);
    System.out.println(s4);
    System.out.println("=================================");
    // 字符串转数字
    // 注意：Integer、Double等是Java中的包装类型，这个后面会讲到
    int data1 = Integer.parseInt("1234");
    double data2 = Double.parseDouble("12.34");
    System.out.println(data1);
    System.out.println(data2);
}

 2. 大小写转换

public static void main(String[] args) {
    String s1 = "hello";
    String s2 = "HELLO";
    // 小写转大写
    System.out.println(s1.toUpperCase());
    // 大写转小写
    System.out.println(s2.toLowerCase());
}

 3. 字符串转数组

public static void main(String[] args) {
    String s = "hello";
    // 字符串转数组
    char[] ch = s.toCharArray();
    for (int i = 0; i < ch.length; i++) {
        System.out.print(ch[i]);
    }
    System.out.println();
    // 数组转字符串
    String s2 = new String(ch);
    System.out.println(s2);
}

4. 格式化

public static void main(String[] args) {
    String s = String.format("%d-%d-%d", 2019, 9,14);
    System.out.println(s);
}

1. 5 字符串替换

使用一个指定的新的字符串替换掉已有的字符串数据，可用的方法如下：

 1.6 字符串拆分

可以将一个完整的字符串按照指定的分隔符划分为若干个子字符串。 可用方法如下：

 代码示例: 实现字符串的拆分处理

String str = "hello world hello bit" ;
String[] result = str.split(" ") ; // 按照空格拆分
for(String s: result) {
    System.out.println(s);
}

 代码示例: 字符串的部分拆分

String str = "hello world hello bit" ;
String[] result = str.split(" ",2) ;
for(String s: result) {
    System.out.println(s);
}

 拆分是特别常用的操作. 一定要重点掌握. 另外有些特殊字符作为分割符可能无法正确切分, 需要加上转义.

代码示例: 拆分IP地址

String str = "192.168.1.1" ;
String[] result = str.split("\\.") ;
for(String s: result) {
    System.out.println(s);
}

 注意事项:

1. 字符"|","*","+"都得加上转义字符，前面加上 "\\" .

2. 而如果是 "\" ，那么就得写成 "\\\\" .

3. 如果一个字符串中有多个分隔符，可以用"|"作为连字符.

代码示例: 多次拆分
 

String str = "name=zhangsan&age=18" ;
String[] result = str.split("&") ;
for (int i = 0; i < result.length; i++) {
    String[] temp = result[i].split("=") ;
    System.out.println(temp[0]+" = "+temp[1]);
}

 这种代码在以后的开发之中会经常出现

1.7 字符串截取

从一个完整的字符串之中截取出部分内容。可用方法如下：

 代码示例: 观察字符串截取

String str = "helloworld" ;
System.out.println(str.substring(5));
System.out.println(str.substring(0, 5));

注意事项:

1. 索引从0开始

2. 注意前闭后开区间的写法, substring(0, 5) 表示包含 0 号下标的字符, 不包含 5 号下标

1.8 其他操作方法

 代码示例: 观察trim()方法的使用

String str = " hello world " ;
System.out.println("["+str+"]");
System.out.println("["+str.trim()+"]")

 trim 会去掉字符串开头和结尾的空白字符(空格, 换行, 制表符等).

代码示例: 大小写转换

String str = " hello%$$%@#$%world 哈哈哈 " ;
System.out.println(str.toUpperCase());
System.out.println(str.toLowerCase());

 这两个函数只转换字母。

1.9 字符串常量池

 1 创建对象的思考

下面两种创建String对象的方式相同吗？

public static void main(String[] args) {
    String s1 = "hello";
    String s2 = "hello";
    String s3 = new String("hello");
    String s4 = new String("hello");
    System.out.println(s1 == s2); // true
    System.out.println(s1 == s3); // false
    System.out.println(s3 == s4); // false
}

 上述程序创建方式类似，为什么s1和s2引用的是同一个对象，而s3和s4不是呢？

在Java程序中，类似于：1， 2， 3，3.14，“hello”等字面类型的常量经常频繁使用，为了使程序的运行速度更快、 更节省内存，Java为8种基本数据类型和String类都提供了常量池。

"池" 是编程中的一种常见的, 重要的提升效率的方式, 我们会在未来的学习中遇到各种 "内存池", "线程池", "数 据库连接池" ..

比如：家里给大家打生活费的方式

1. 家里经济拮据，每月定时打生活费，有时可能会晚，最差情况下可能需要向家里张口要，速度慢

2. 家里有矿，一次性打一年的生活费放到银行卡中，自己随用随取，速度非常快

方式2，就是池化技术的一种示例，钱放在卡上，随用随取，效率非常高。常见的池化技术比如：数据库连接 池、线程池等。

 为了节省存储空间以及程序的运行效率，Java中引入了：

1. Class文件常量池：每个.Java源文件编译后生成.Class文件中会保存当前类中的字面常量以及符号信息

2. 运行时常量池：在.Class文件被加载时，.Class文件中的常量池被加载到内存中称为运行时常量池，运行时常 量池每个类都有一份

3. 字符串常量池

 此处简单了解下，后序在讲JVM时会给同学们详细阐释。

2 字符串常量池(StringTable)

字符串常量池在JVM中是StringTable类，实际是一个固定大小的HashTable(一种高效用来进行查找的数据结构， 后序给大家详细介绍)，不同JDK版本下字符串常量池的位置以及默认大小是不同的：

 关于方法区、堆等内存结构的具体局部，后序JVM中会给大家详细介绍。

3 再谈String对象创建

由于不同JDK版本对字符串常量池的处理方式不同，此处在Java8 HotSpot上分析

1. 直接使用字符串常量进行赋值

public static void main(String[] args) {
    String s1 = "hello";
    String s2 = "hello";
    System.out.println(s1 == s2); // true
}

 

 结论：只要是new的对象，都是唯一的。

通过上面例子可以看出：使用常量串创建String类型对象的效率更高，而且更节省空间。用户也可以将创建的 字符串对象通过 intern 方式添加进字符串常量池中。

3. intern方法

intern 是一个native方法(Native方法指：底层使用C++实现的，看不到其实现的源代码)，该方法的作用是手 动将创建的String对象添加到常量池中。

public static void main(String[] args) {
    char[] ch = new char[]{'a', 'b', 'c'};
    String s1 = new String(ch); // s1对象并不在常量池中
    //s1.intern(); // s1.intern()；调用之后，会将s1对象的引用放入到常量池中
    String s2 = "abc"; // "abc" 在常量池中存在了，s2创建时直接用常量池中"abc"的引用
    System.out.println(s1 == s2);
}
// 输出false
// 将上述方法打开之后，就会输出true

注意：在Java6 和 Java7、8中Intern的实现会有些许的差别。

面试题：请解释String类中两种对象实例化的区别

JDK1.8中

1. String str = "hello"

只会开辟一块堆内存空间，保存在字符串常量池中，然后str共享常量池中的String对象

2. String str = new String("hello")

会开辟两块堆内存空间，字符串"hello"保存在字符串常量池中，然后用常量池中的String对象给新开辟 的String对象赋值。

3. String str = new String(new char[]{'h', 'e', 'l', 'l', 'o'})

现在堆上创建一个String对象，然后利用copyof将重新开辟数组空间，将参数字符串数组中内容拷贝到 String对象中

 1.10 字符串的不可变性

String是一种不可变对象. 字符串中的内容是不可改变。字符串不可被修改，是因为：

1. String类在设计时就是不可改变的，String类实现描述中已经说明了

以下来自JDK1.8中String类的部分实现：

 String类中的字符实际保存在内部维护的value字符数组中，该图还可以看出：

1. String类被final修饰，表明该类不能被继承

2. value被修饰被final修饰，表明value自身的值不能改变，即不能引用其它字符数组，但是其引用空间中 的内容可以修改。

2. 所有涉及到可能修改字符串内容的操作都是创建一个新对象，改变的是新对象

比如 replace 方法：

 【纠正】网上有些人说：字符串不可变是因为其内部保存字符的数组被final修饰了，因此不能改变。 这种说法是错误的，不是因为String类自身，或者其内部value被final修饰而不能被修改。

final修饰类表明该类不想被继承，final修饰引用类型表明该引用变量不能引用其他对象，但是其引用对象中的内 容是可以修改的。

public static void main(String[] args) {
    final int array[] = {1,2,3,4,5};
    array[0] = 100;
    System.out.println(Arrays.toString(array));
    // array = new int[]{4,5,6}; // 编译报错：Error:(19, 9) java: 无法为最终变量array分配值
}

为什么 String 要设计成不可变的?(不可变对象的好处是什么?) (选学)

1. 方便实现字符串对象池. 如果 String 可变, 那么对象池就需要考虑写时拷贝的问题了.

2. 不可变对象是线程安全的.

3. 不可变对象更方便缓存 hash code, 作为 key 时可以更高效的保存到 HashMap 中.

 那如果想要修改字符串中内容，该如何操作呢？

1.11 字符串修改

注意：尽量避免直接对String类型对象进行修改，因为String类是不能修改的，所有的修改都会创建新对象，效率 非常低下。

public static void main(String[] args) {
    String s = "hello";
    s += " world";
    System.out.println(s); // 输出：hello world
}

 但是这种方式不推荐使用，因为其效率非常低，中间创建了好多临时对象。

 

public static void main(String[] args) {
    long start = System.currentTimeMillis();
    String s = "";
    for(int i = 0; i < 100000; ++i){
        s += i;
    }
    long end = System.currentTimeMillis();
    System.out.println(end - start);

    start = System.currentTimeMillis();
    StringBuffer sbf = new StringBuffer("");
    for(int i = 0; i < 100000; ++i){
        sbf.append(i);
    }
    end = System.currentTimeMillis();
    System.out.println(end - start);
    start = System.currentTimeMillis();
    StringBuilder sbd = new StringBuilder();

    for(int i = 0; i < 100000; ++i){
        sbd.append(i);
    }

    end = System.currentTimeMillis();
    System.out.println(end - start);
}

输出：
27199
3
2

 可以看待在对String类进行修改时，效率是非常慢的，因此：尽量避免对String的直接需要，如果要修改建议尽量 使用StringBuffer或者StringBuilder。