JavaSE基础-String字符串

匠心独具_GH

已于 2023-09-08 15:26:08 修改

阅读量57

点赞数

文章标签： java 开发语言

于 2023-09-08 15:24:40 首次发布

本文链接：https://blog.csdn.net/GH_JXDJ/article/details/132761124

版权

String字符串

String描述

String类是用final修饰的，表明它不能再被继承了。同时还实现了序列化(Serializable)、比较排序(Comparable)、字符序列(CharSequence)这三个接口，表明字符串可以被序列化、可以用于比较排序。

String特性

字符串不可变：字符串在创建后是不可变的，即不能被修改。当对字符串进行操作时，实际上是创建了一个新的字符串对象。这种不可变性使得字符串在多线程环境下是线程安全的。
字符串常量池：String对象创建之后，会在字符串常量池中进行缓存，下次创建同样的对象时，会直接返回缓存的引用。
String不能被继承：字符串String类型本身是final声明的，意味着我们不能继承String，也就意味着我们不能去重写他的方法。

String创建方式

 // 字符串常量，这种方式创建的字符串会自动地将新建的对象放入String常量池中。推荐方式
 String strA = "aaa";
 
 // 字符串对象,对象指向字符串常量池“aaa”的地址
 String strB = new String("aaa");
 
 
 //通过字符数组构造
 char chars[] = {'a', 'b', 'c','d','e'};     
 String str3 = new String(chars);
 String str4 = new String(chars,0,3);
 
 //通过字节数组构造
 byte bytes[] = {97, 98, 99 };     
 String str5 = new String(bytes);
 String str6 = new String(bytes,"GBK");

String创建过程

 String strA = "aaa";

创建对象的过程：首先检查常量池中是否存在内容为"aaa"的字符串，如果有，则不再创建对象，直接让strA变量指向该字符串的引用，如果没有则在常量池中创建"aaa"对象然后让strA引用该对象。

 String strB = new String("aaa");

创建实例的过程：首先在堆创建一个String的对象，并让strB引用指向该对象，然后再到常量池中查看是否存在内容为"aaa"字符串对象，如果存在，则将String对象中的value引用指向常量对象，将new出来的字符串对象与字符串常量池中的对象联系起来，如果不存在，则在字符串常量池中创建一个内容为"aaa"的字符串对象，并将堆中的String对象与之联系起来。

String拼接

字符串拼接：

常量与常量的拼接结果必定是常量，它们是在常量池中完成，因为常量在编译阶段就可以确定下来，在编译阶段就会自动拼接完成。
只要涉及到有变量的(非常量)，结果都是在堆内存中完成的，因为变量只有在运行阶段才可以确定。
直接赋值String str="a"与构造器new String("a")创建的字符串必定不会相等。
如果拼接后的结果调用了intern()方法，则返回值就是在常量池中。
字符串只有值传递，没有引用传递。

 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;
         String s8 = s7.intern();
 
         System.out.println("(1)" + (s3 == s4));
         System.out.println("(2)" + (s3 == s5));
         System.out.println("(3)" + (s3 == s6));
         System.out.println("(4)" + (s3 == s7));
         System.out.println("(5)" + (s3 == s8));
         System.out.println("(6)" + (s5 == s6));
         System.out.println("(7)" + (s5 == s7));
         System.out.println("(8)" + (s6 == s7));
 }
 
 结果:
 (1)true
 (2)false
 (3)false
 (4)false
 (5)true
 (6)false
 (7)false
 (8)false

 public static void main(String[] args) {
         String str1 = "1";
         String str2 = "2";
         String str3 = new String("1");
         final String str4 = "2";
         final String str5 = new String("2");
         String str6 = "12";
 
         String str7 = "1" + "2";
         String str8 = str1 + "2";
         String str9 = str1 + str2;
         String str10 = str3 + str4;
         String str11 = "1" + str4;
         String str12 = "1" + str5;
         String str13 = (str1 + str2).intern();
 
         System.out.println("(1)" + (str1 == str3));
         System.out.println("(2)" + (str2 == str4));
         System.out.println("(3)" + (str4 == str5));
         System.out.println("(4)" + (str6 == str7));
         System.out.println("(5)" + (str6 == str8));
         System.out.println("(6)" + (str6 == str9));
         System.out.println("(7)" + (str6 == str10));
         System.out.println("(8)" + (str6 == str11));
         System.out.println("(9)" + (str6 == str12));
         System.out.println("(10)" + (str6 == str13));
 }
 
 结果:
 (1)false
 (2)true
 (3)false
 (4)true
 (5)false
 (6)false
 (7)false
 (8)true
 (9)false
 (10)true

StringBuffer

字符串变量，可变字符序列，线程安全，效率低。可变字符串，线程安全，适用多线程下在字符缓冲区进行大量操作的情况。

StringBuilder

字符串变量，可变字符序列，线程不安全，效率高。可变字符串，线程不安全，适用于单线程下在字符缓冲区进行大量操作的情况。

     public static void main(String[] args) {
         String text = "";
         StringBuffer buffer = new StringBuffer("");
         StringBuilder builder = new StringBuilder("");
 
         //String
         Stopwatch startedStr = Stopwatch.createStarted();
         for (int i = 0; i < 50000; i++) {
             text = text + i;
         }
         log.info("String执行时间:{}", startedStr.elapsed(TimeUnit.MILLISECONDS));
 
         //StringBuffer
         Stopwatch startedBuffer = Stopwatch.createStarted();
         for (int i = 0; i < 50000; i++) {
             buffer.append(String.valueOf(i));
         }
         log.info("StringBuffer执行时间:{}", startedBuffer.elapsed(TimeUnit.MILLISECONDS));
 
         //StringBuilder
         Stopwatch startedBuilder= Stopwatch.createStarted();
         for (int i = 0; i < 50000; i++) {
             builder.append(String.valueOf(i));
         }
         log.info("StringBuffer执行时间:{}", startedBuilder.elapsed(TimeUnit.MILLISECONDS));
     }
     
     
 结果:
 09:30:54.354 [main] INFO com.base.javase.BaseJavaSEApplication - String执行时间:4392
 09:30:54.362 [main] INFO com.base.javase.BaseJavaSEApplication - StringBuffer执行时间:4
 09:30:54.364 [main] INFO com.base.javase.BaseJavaSEApplication - StringBuffer执行时间:2