String开发中与面试中的常用类 -JavaSE篇

String类

1.概述

String:字符串，使用一对""引起来表示。
1.String声明为final的，不可被继承
2.String实现了Serializable接口：表示字符串是支持序列化的,实现了Comparable接口：表示String可以比较大小
3.String内部定义了final char[] value用于存储字符串数据
4.通过字面量的方式（区别于new给一个字符串赋值，此时的字符串值声明在字符串常量池中)。
5.字符串常量池中是不会存储相同内容(使用String类的equals()比较，返回true)的字符串的。

2.String的不可变性

2.1.1 说明

1.当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值。
2.当对现的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。
3.当调用String的replace()方法修改指定字符或字符串时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值。

2.1.2图示

2.2 代码举例

String s1 = "abc";//字面量的定义方式
String s2 = "abc";
s1 = "hello";

System.out.println(s1 == s2);//比较s1和s2的地址值 

System.out.println(s1);//hello
System.out.println(s2);//abc

System.out.println("*****************");

String s3 = "abc";
s3 += "def";
System.out.println(s3);//abcdef
System.out.println(s2);

System.out.println("*****************");

String s4 = "abc";
String s5 = s4.replace('a', 'm');
System.out.println(s4);//abc
System.out.println(s5);//mbc

2.3 图示

3.String实例化的不同方式

3.1 方式说明

方式一：通过字面量定义的方式
方式二：通过new + 构造器的方式

3.2 代码举例

//通过字面量定义的方式：此时的s1和s2的数据javaEE声明在方法区中的字符串常量池中。
String s1 = "javaEE";
String s2 = "javaEE";
//通过new + 构造器的方式:此时的s3和s4保存的地址值，是数据在堆空间中开辟空间以后对应的地址值。
String s3 = new String("javaEE");
String s4 = new String("javaEE");

System.out.println(s1 == s2);//true
System.out.println(s1 == s3);//false
System.out.println(s1 == s4);//false
System.out.println(s3 == s4);//false

3.3 面试题

String s = new String(“abc”);方式创建对象，在内存中创建了几个对象？
两个:一个是堆空间中new结构，另一个是char[]对应的常量池中的数据：“abc”

3.4 图示

4.字符串拼接方式赋值的对比

4.1 说明

1.常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量。
2.只要其中一个是变量，结果就在堆中。
3.如果拼接的结果调用intern()方法，返回值就在常量池中

4.2 代码举例

 String s1 = "hello";
 String s2 = "world";

 String s3 = "hello" + "world";
 String s4 = "helloworld";

 String s5 = s1 + s2;
 String s6 = (s1 + s2).intern();
 String s7 = "hello" + s2;

 System.out.println(s3 == s4);//true
 System.out.println(s3 == s5);//false
 System.out.println(s3 == s6);//true
 System.out.println(s3 == s7);//false
 System.out.println(s5 == s6);//false
 System.out.println(s5 == s7);//false
 System.out.println(s6 == s7);//false

****************************

String s1 = "javaEEhadoop";
String s2 = "javaEE";
String s3 = s2 + "hadoop";
System.out.println(s1 == s3);//false

final String s4 = "javaEE";//s4:常量
String s5 = s4 + "hadoop";
System.out.println(s1 == s5);//true

4.3 内存图

4.4 String的使用陷阱

5.String常用方法

**int length()：**返回字符串的长度： return value.length
char charAt(int index)： 返回某索引处的字符return value[index]
**boolean isEmpty()：**判断是否是空字符串：return value.length == 0
**String toLowerCase()：**使用默认语言环境，将 String 中的所字符转换为小写
**String toUpperCase()：**使用默认语言环境，将 String 中的所字符转换为大写
**String trim()：**返回字符串的副本，忽略前导空白和尾部空白
**boolean equals(Object obj)：**比较字符串的内容是否相同
**boolean equalsIgnoreCase(String anotherString)：**与equals方法类似，忽略大小写
**String concat(String str)：**将指定字符串连接到此字符串的结尾。 等价于用“+”
int compareTo(String anotherString)：比较两个字符串的大小
**String substring(int beginIndex)：**返回一个新的字符串，它是此字符串的从beginIndex开始截取到最后的一个子字符串。
**String substring(int beginIndex, int endIndex) ：**返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。

**boolean endsWith(String suffix)：**测试此字符串是否以指定的后缀结束
**boolean startsWith(String prefix)：**测试此字符串是否以指定的前缀开始
boolean startsWith(String prefix, int toffset)：测试此字符串从指定索引开始的子字符串是否以指定前缀开始

**boolean contains(CharSequence s)：**当且仅当此字符串包含指定的 char 值序列时，返回 true
**int indexOf(String str)：**返回指定子字符串在此字符串中第一次出现处的索引
**int indexOf(String str, int fromIndex)：**返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
**int lastIndexOf(String str)：**返回指定子字符串在此字符串中最右边出现处的索引
**int lastIndexOf(String str, int fromIndex)：**返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索

注：indexOf和lastIndexOf方法如果未找到都是返回-1

替换：
String replace(char oldChar, char newChar)：返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所 oldChar 得到的。
String replace(CharSequence target, CharSequence replacement)：使用指定的字面值替换序列替换此字符串所匹配字面值目标序列的子字符串。
String replaceAll(String regex, String replacement)：使用给定的 replacement 替换此字符串所匹配给定的正则表达式的子字符串。
String replaceFirst(String regex, String replacement)：使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
匹配:
boolean matches(String regex)：告知此字符串是否匹配给定的正则表达式。
切片：
String[] split(String regex)：根据给定正则表达式的匹配拆分此字符串。
String[] split(String regex, int limit)：根据匹配给定的正则表达式来拆分此字符串，最多不超过limit个，如果超过了，剩下的全部都放到最后一个元素中。

StringBuffer与StringBuilder类

1.StringBuffer与StringBuilder的内存解析

//以StringBuffer为例：
String str = new String();//char[] value = new char[0];
String str1 = new String("abc");//char[] value = new char[]{'a','b','c'};

StringBuffer sb1 = new StringBuffer();//char[] value = new char[16];底层创建了一个长度是16的数组。
System.out.println(sb1.length());//
sb1.append('a');//value[0] = 'a';
sb1.append('b');//value[1] = 'b';

StringBuffer sb2 = new StringBuffer("abc");//char[] value = new char["abc".length() + 16];

//问题1. System.out.println(sb2.length());//3
//问题2. 扩容问题:如果要添加的数据底层数组盛不下了，那就需要扩容底层的数组。

默认情况下，扩容为原来容量的2倍 + 2，同时将原数组中的元素复制到新的数组中。

指导意义：开发中建议大家使用：StringBuffer(int capacity) 或 StringBuilder(int capacity)

2.StringBuffer、StringBuilder中的常用方法

增：append(xxx)
删：delete(int start,int end)
改：setCharAt(int n ,char ch) / replace(int start, int end, String str)
查：charAt(int n )
插：insert(int offset, xxx)
长度：length();
遍历：for() + charAt() / toString()

StringBuilder三者的对比

String:不可变的字符序列；底层使用char[]存储
StringBuffer:可变的字符序列；线程安全的，效率低；底层使用char[]存储
StringBuilder:可变的字符序列；jdk5.0新增的，线程不安全的，效率高；底层使用char[]存储

对比String、StringBuffer、StringBuilder三者的执行效率

从高到低排列：StringBuilder > StringBuffer > String

总结：

以上就是String的常用类，String的不可变性也是面试中常被问到的问题。
喜欢本文可以关注作者公众号：小白编码