1.String
String类:字符串是常量，使用一对""引起来表示。他们的值在创建之后不能修改。
1.String声明为final的，不可被继承
2.String实现了Serializable接口，表示字符串时支持序列化的。
实现了Comparable接口：表示String可以比较大小
3.String内部定义了final char[] value用于存储字符串数据
4.String:代表不可变的字符序列。简称：不可变性
体现：
1.当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值
2.当对现有的字符串进行连接( + )操作时，也需要重写指定内存区域赋值，不能使用原有的 value进行赋值
3.当调用String的replace()方法修改指定字符或字符串时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值
5.通过字面量的方式(区别于new)给一个字符串赋值，此时的字符串值声明在字符串常量池中。
6.字符串常量池是不会存储相同内容的字符串的。
public void test1(){
//体现1
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("********************************");
//体现2
String s3 = "abc";
s3 += "def";
System.out.println(s3);//abcdef
System.out.println(s2);//abc
System.out.println("***********************************");
//体现3
String s4 = "abc";
String s5 = s4.replace("a","m");
System.out.println(s4);//abc
System.out.println(s5);//mbc
}
String的实例化方式：
方式一：通过字面量定义的方式
方式二：通过new + 构造器的方式
面试题：String s = new String("abc")的方式创建对象，在内存中创建了几个对象？
两个：一个是堆空间中new结构，另一个是char[]对应的常量池中的数据："abc"
public void Test2(){
//通过字面量定义的方式:此时的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
System.out.println("******************************************");
Person p1 = new Person("Tom",12);
Person p2 = new Person("Tom",12);
System.out.println(p1.name.equals(p2.name));//true
System.out.println(p1.name == p2.name);//true//通过字面量的方式赋值，所以是true!!!!!!!!!!!!
}
public void Test3(){
String s1 = "javaEE";
String s2 = "hadoop";
String s3 = "javaEEhadoop";
String s4 = "javaEE" + "hadoop";
String s5 = s1 + "hadoop";
String s6 = "javaEE" + s2;
String s7 = s1 + s2;
System.out.println(s3 == s4);//true
System.out.println(s3 == s5);//false//字面值方式的储存在常量池，有变量的在堆里
System.out.println(s3 == s6);//false
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 s8 = s5.intern();//返回值得到的s8使用的常量池已经存在的"javaEEhadoop"
System.out.println(s3 == s8);//true
}
@Test
public void test4(){
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
}
结论：
1.常量与常量的拼接结果在常量池。且常量池中不会存在相同内容的常量。
2.只要其中有一个是变量，结果就在堆中。
3.如果拼接的结果调用intern()方法，返回值就在常量池中
一道有深度的面试题
public class StringTest {
String str = new String("good");
char[] ch = {"t","e","s","t"};
public void change(String str,char ch[]){
str = "test ok";
ch[0] = "b";
}
public static void main(String[] args) {
StringTest ex = new StringTest();
ex.change(ex.str,ex.ch);
System.out.println(ex.str);//good
System.out.println(ex.ch);//best
}
}
解析：
1.涉及的知识：
关于变量的赋值：如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。
Java中的方法的值传递机制：所谓的值传递，就是将实参值的副本传入方法里，而参数本身不受影响。
2.面试题的解析：因为传值过程中，传给形参的是地址值，而通过String试图修改实参是行不通的，因为String有不可变性。而数组的内容是可以修改的，通过形参修改堆空间中的数组中的内容，实参也会改变，因为形参和实参指向对空间中的同一个内容
String的常用方法及其测试
public void test1(){
String s1 = "HelloWorld";
System.out.println(s1.length());//10
System.out.println(s1.charAt(0));//H
System.out.println(s1.isEmpty());//false
String s2 = s1.toLowerCase();
System.out.println(s1);//HelloWorld//s1是不可变的，仍然为原来的字符串
System.out.println(s2);//helloworld//改成小写以后的字符串
String s3 = " he llo world ";
String s4 = s3.trim();
System.out.println("-----" + s3 + "-----");//----- he llo world -----
System.out.println("-----" + s4 + "-----");// -----he llo world-----
}
public void test2(){
String s1 = "HelloWorld";
String s2 = "helloworld";
System.out.println(s1.equals(s2));//false
System.out.println(s1.equalsIgnoreCase(s2));//true
String s3 = "abc";
String s4 = s3.concat("def");
System.out.println(s4);//abcdef
String s5 = "abc";
String s6 = new String("abe");
System.out.println(s5.compareTo(s6));//-2
String s7 = "开关电源适配器";
String s8 = s7.substring(2);
System.out.println(s7);//开关电源适配器
System.out.println(s8);//电源适配器
String s9 = s7.substring(2,5);
System.out.println(s9);//电源适
}
public void test3(){
String str1 = "helloworld";
boolean b1 = str1.endsWith("rld");
System.out.println(b1);//true
boolean b2 = str1.endsWith("He");
System.out.println(b2);//false
boolean b3 = str1.startsWith("ll",2);
System.out.println(b3);//true
String str2 = "wor";
System.out.println(str1.contains(str2));//true
System.out.println(str1.indexOf("lol"));//-1
System.out.println(str1.indexOf("lo",5));//-1
String str3 = "hellorworld";
System.out.println(str3.lastIndexOf("or"));//7
System.out.println(str3.lastIndexOf("or",6));//4
}
此方法测试详见另一篇博客：自动装箱与自动拆箱
与正则表达式有关的方法的测试
public void test4(){
String str1 = "北京尚硅谷教育北京";
String str2 = str1.replace("北","东");
System.out.println(str1);//北京尚硅谷教育北京
System.out.println(str2);// 东京尚硅谷教育东京
String str3 = str1.replace("北京","上海");
System.out.println(str3);//上海尚硅谷教育上海
String str = "12hello34world5java7891mysql456";
//把字符串中的数字替换成,，如果结果中开头和结尾有,的话去掉
String string = str.replaceAll("d+",",").replaceAll("^,|,$","");
System.out.println(string);//hello,world,java,mysql
str = "12345";
//判断str字符串中是否全部由数字组成，既由1-n个数字组成
boolean matches = str.matches("d+");
System.out.println(matches);//true
String tel = "0571-4534289";
//判断这是否是一个杭州的固定电话
boolean result = tel.matches("0571-d{7,8}");
System.out.println(result);//true
str = "hello|world|java";
String[] strs = str.split("|");
for(int i = 0;i < strs.length;i++){
System.out.print(strs[i]);//hello world java
}
}
/*
String 与 char[]之间的转换
String --> char[]:调用String的toCharArray()
char[] --> String:调用String的构造器
*/
@Test
public void test2(){
String str1 = "abc123";
char[] charArray = str1.toCharArray();
for(int i = 0;i < charArray.length;i++){
System.out.println(charArray[i]);
}
char[] arr = new char[]{"h","e","l","l","o"};
String str2 = new String(arr);
System.out.println(str2);
}
/*
String 与 byte[]之间的转换
编码：String --> byte[]:调用String的getBytes()
解码: byte[] --> String:调用String的构造器
编码：字符串 --> 字节(看得懂 --> 看不懂的二进制数据)
解码：编码的逆过程，字节 --> 字符串 (看不懂的二进制数据 --> 看的懂)
说明：解码时，要求解码使用的字符集必须与编码时使用的编码集一致，否则会出现乱码。
*/
@Test
public void test3() throws UnsupportedEncodingException {
String str1 = "abc123中国";
byte[] bytes = str1.getBytes();//使用默认的字符集，进行转换
System.out.println(Arrays.toString(bytes));//[97, 98, 99, 49, 50, 51, -28, -72, -83, -27, -101, -67]
byte[] gbks = str1.getBytes("gbk");//使用了gbk字符集进行编码
System.out.println(Arrays.toString(gbks));//[97, 98, 99, 49, 50, 51, -42, -48, -71, -6]
String str2 = new String(bytes);//使用默认的字符集，进行解码
System.out.println(str2);//abc123中国
String str3 = new String(gbks);//abc123�й�//乱码
System.out.println(str3);//出现乱码，原因：编码集和解码集不一致！
String str4 = new String(gbks,"gbk");
System.out.println(str4);//abc123中国
}
String、StringBuffer、StringBuilder三者的异同？
String:不可变的字符序列：底层使用char[]存储
StringBuffer:可变的字符序列：线程安全的，效率低；底层使用char[]存储
StringBuilder:可变的字符序列：JDK5.0新增的，线程不安全的，效率高；底层使用char[]存储
源码分析：
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的数组。
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),
传入预知的参数长度，可以避免扩容,如果没涉及到多线程，或者涉及到多线程，但String不是共享数据的时候，建议使用StringBuffer,因为效率高
public void test1(){
StringBuffer sb1 = new StringBuffer("abc");
sb1.setCharAt(0,"m");
System.out.println(sb1);//mbc
}
对比String、StringBuffer、StringBuilder三者的效率:
从高到低排列：StringBuilder > StringBuffer > String
到此这篇关于Java中关于String StringBuffer StringBuilder特性深度解析的文章就介绍到这了,更多相关Java String StringBuffer StringBuilder内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！
原文链接：https://blog.csdn.net/weixin_49329785/article/details/119485608