运维开发网
广告位招商联系QQ:123077622
 
广告位招商联系QQ:123077622

面试官:你连string、stringbuffer和stringbuilder都不会,我招你干什么?

运维开发网 https://www.qedev.com 2020-07-28 09:03 出处:51CTO 作者:程序员麦冬
1、String类的特性public final class String    implements java.io.Serializable, Comparable<String>, CharSequence {    private final char value[];String是被final修饰的类,不能被继承;String实现了Serializable和Comparabl

1、String类的特性

public final class String

   implements java.io.Serializable, Comparable<String>, CharSequence {

   private final char value[];

  1. String是被final修饰的类,不能被继承;

  2. String实现了Serializable和Comparable接口,表示String支持序列化和可以比较大小;

  3. String底层是通过char类型的数据实现的,并且被final修饰,所以字符串的值创建之后就不可以被修改,具有不可变性。

2、深入理解String的不可变性

通过字面量方式为字符串赋值时,此时的字符串存储在方法区的字符串常量池中,并且在字符串常量池中不会存储相同内容的字符串。

String s1="hi";

String s2="hi";

s1="hello";

刚开始字符串s1和s2内容相等,都指向字符串常量池中的同一个地址,如下图所示:

面试官:你连string、stringbuffer和stringbuilder都不会,我招你干什么?

当s1值的改变之后,此时s2的值不变还是指向原来的内存地址,但是s1会重新分配内存地址进行赋值,如下图所示:

面试官:你连string、stringbuffer和stringbuilder都不会,我招你干什么?

总结1:String字符串具有不可变性,当字符串重新赋值时,不会在原来的内存地址进行修改,而是重新分配新的内存地址进行赋值。

String s3="abc";

String s4=s3+"def";

System.out.println(s3); //abc

总结2:当字符串进行拼接时,也不会在原来的内存地址进行修改,而是重新分配新的内存地址进行赋值。

String s5="abcd";

String s6=s5.replace("d","g");

System.out.println(s5);

此时的内存结构如下图所示:

面试官:你连string、stringbuffer和stringbuilder都不会,我招你干什么?

总结3:当调用String的replace方法修改指定的字符或字符串时,也不会在原来的内存地址进行修改,也是重新分配新的内存地址进行赋值。

3、String实例化的两种方式

方式一:通过字面量方式实例化

String str = "abc";

方式二:通过new+构造器的方式实例化

String str=new String("abc");

4、String两种实例化方式的对比

通过字面量方式为字符串赋值时,此时的字符串存储在方法区的字符串常量池中;通过new+构造器方式实例化字符串时,字符串对象存储在堆中,但是字符串的值仍然存储在方法区的常量池中。如下图所示:

面试官:你连string、stringbuffer和stringbuilder都不会,我招你干什么?

public class Person {

   public String name;

   public int age;

   Person(){}

   Person(String name,int age){

       this.name=name;

       this.age=age;

   }

}

public static void main(String[] args) {

   Person p1 = new Person("Tom",18);

   Person p2 = new Person("Tom",18);

   System.out.println(p1.name==p2.name); //true

}

public class Person {

   public String name;

   public int age;

   Person(){}

   Person(String name,int age){

       this.name=name;

       this.age=age;

   }

}

public static void main(String[] args) {

   Person p1 = new Person("Tom",18);

   Person p2 = new Person("Tom",18);

   System.out.println(p1.name==p2.name); //true

}

此时的内存结构如下图所示:

面试官:你连string、stringbuffer和stringbuilder都不会,我招你干什么?

如果p2中name值进行了修改,那么就会在字符串常量池中新生成一个修改后的值,然后改变堆中name指向的地址值,内存结构就会变成如下图所示:

面试官:你连string、stringbuffer和stringbuilder都不会,我招你干什么?

面试题:使用String str=new String(“hello”)方式创建对象,一共创建了几个对象?一共会创建两个对象,一个是使用new创建的对象,存储在堆中;另一个是常量对象"hello",存储在字符串常量池中。

5、String不同拼接方式的对比

public static void main(String[] args) {

   

       String s1="Hello";

       String s2="World";

       String s3="HelloWorld";

       String s4="Hello"+"World";

       String s5=s1+"World";

       String s6="Hello"+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();

       System.out.println(s3==s8); //true

   }

(1)Java中有常量优化机制,“Hello"和"World"本身就是字符串常量,所以在编译时,会直接把"Hello"和"World"合并成"HelloWorld"字符串,又因为在执行s3的时候已经在常量池中创建了"HelloWorld”,所以s3==s4。

(2)当变量与字面量或变量与变量进行拼接时,会在堆中创建一个StringBuilde对象,然后使用StringBuilder的append()方法将变量与字面量或变量与变量进行拼接,最后调用toString()方法转成String对象。所以s5、s6、s7指向的都是堆内存中String对象的地址值。

(3)使用intern()这个方法时,首先会检查字符串常量池中是否有对应的字符串,如果存在则返回这个字符串的引用;否则会先将字符串添加到字符串常量池中,然后再返回这个字符串的引用。所以s3==s8。

易错的笔试题

public static void main(String[] args) {

   final String s1="Hello";

   String s2="HelloWorld";

   String s3=s1+"World";

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

}

此时的s1用final进行修饰,表示的是一个常量,所以此时s1+“World"就相当于"Hello”+“World”,结果仍然是一个常量,所以s2==s3。

6、String的常用方法

int length():返回字符串的长度

char charAt(int index):返回指定索引处的字符

boolean isEmpty():判断字符串是否为空

String toLowerCase():将字符串中的所有字符转换为小写

String toUpperCase():将字符串中的所有字符转换为大写

String trim():返回字符串的副本,去掉前导空白和尾部空白,中间的空白不会被去掉

boolean equals(Object obj):比较字符串的内容是否相同

boolean equalsIgnoreCase(String anotherString):忽略大小写,比较字符串的内容是否相同

String concat(String str):将指定字符串连接到此字符串的结尾,等价于用“+”

int compareTo(String anotherString):比较两个字符串的大小

String substring(int beginIndex):返回从beginIndex到末尾的子字符串

String substring(int beginIndex, int endIndex):返回从beginIndex到endIndex前一位的子字符串,不包括endIndex

boolean endsWith(String suffix): 判断字符串是否以指定的后缀结束

boolean startsWith(String prefix):判断字符串是否以指定的前缀开始

boolean startsWith(String prefix, int toffset):判断字符串在指定索引开始的子字符串是否以指定前缀开始

boolean contains(CharSequence s):判断当前字符串中是否包含指定的字符串

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):替换当前字符串中指定的子字符串

String[] split(String regex):根据指定的符号拆分当前字符串,然后返回一个String数组

7、String与char[]之间相互装换

String ——> char[] : 调用String的toCharArray方法

String s1="ABCD";

char[] chars = s1.toCharArray();

char[] ——> String : 调用String的构造器

char[] chars=new char[]{'A','B','C','D'};

String s = new String(chars);

System.out.println(s); //ABCD

8、String与byte[]之间相互装换

String ——> byte[] : 调用String的getBytes方法

String str="ABCD";

byte[] bytes = str.getBytes(); //也可以使用指定的字符编码

byte[] ——> String : 调用String的构造器

byte[] bytes=new byte[]{'A','B','1','2'};

String str = new String(bytes); //也可以使用指定的字符编码

System.out.println(str); //AB12

9、深入理解StringBuffer和StringBuilder

StringBuffer、StringBuilder和String类似,底层也是用一个数组来存储字符串的值,并且数组的默认长度为16,即一个空的StringBuffer对象数组长度为16。实例化一个StringBuffer对象即创建了一个大小为16个字符的字符串缓冲区。但是当我们调用有参构造函数创建一个StringBuffer对象时,数组长度就不再是16了,而是根据当前对象的值来决定数组的长度,数组的长度为“当前对象的值的长+16”。所以一个 StringBuffer 创建完成之后,有16个字符的空间可以对其值进行修改。如果修改的值范围超出了16个字符,会先检查StringBuffer对象的原char数组的容量能不能装下新的字符串,如果装不下则会对 char 数组进行扩容。

那StringBuffer是怎样进行扩容的呢?

扩容的逻辑就是创建一个新的 char 数组,将现有容量扩大一倍再加上2,如果还是不够大则直接等于需要的容量大小。扩容完成之后,将原数组的内容复制到新数组,最后将指针指向新的 char 数组。

StringBuffer和StringBuilder中常用的方法:

StringBuffer append(xxx):拼接字符串

StringBuffer delete(int start,int end):删除指定范围的内容,左开右闭

StringBuffer replace(int start, int end, String str):替换指定范围的内容

StringBuffer insert(int offset, 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) : 设置指定索引处的字符

  • 面试题:String、StringBuffer和StringBuilder的异同?

  • 相同点:底层都是通过char数组实现的

  • 不同点:

  1. String对象一旦创建,其值是不能修改的,如果要修改,会重新开辟内存空间来存储修改之后的对象;而StringBuffer和StringBuilder对象的值是可以被修改的;

  2. StringBuffer几乎所有的方法都使用synchronized实现了同步,线程比较安全,在多线程系统中可以保证数据同步,但是效率比较低;而StringBuilder 没有实现同步,线程不安全,在多线程系统中不能使用 StringBuilder,但是效率比较高。

  3. 如果我们在实际开发过程中需要对字符串进行频繁的修改,不要使用String,否则会造成内存空间的浪费;当需要考虑线程安全的场景下使用 StringBuffer,如果不需要考虑线程安全,追求效率的场景下可以使用 StringBuilder。

扫码领视频副本.gif

0

精彩评论

暂无评论...
验证码 换一张
取 消