• Java_String


    整理一下java中关于String的内容。Spring应该是java中使用最频繁的类了,那么今天我们仔细研究下关于Spring的内容。

    定义:

      String类是一个字符串类型的类,使用"   "定义的内容都是字符串。 

    实例化:

      (1)直接赋值实例化:String str ="Hello World!";

      (2)使用构造方法实例化:String str = new String("Hello World!");

    注意:

    1)单独使用""引号创建的字符串都是常量,编译期就已经确定存储到String Pool中;

    2)使用new String("")创建的对象会存储到堆中,是运行期创建的;

    new创建字符串时首先查看String Pool中是否有相同的字符串,如果有,则拷贝一份到堆中,然后返回堆中的地址;如果池中没有,则在堆中创建一份,然后返回堆中的地址(注意,此时不需要从堆中复制一份到池中,否则,将使得堆中的字符串永远是池中的子集,浪费池的空间);

    3)使用只包含常量的字符串连接符如"aa"+"bb"创建的也是常量,编译期就能确定,存储在String Pool中;

    4)使用包含变量的字符串连接符如s1+"aa"创建的对象是运行期才创建的,存储在heap中。

    字符串的比较:

      如果我们想知道两个int类型变量是否相等,可以使用 == 进行验证,那么String中使用 == 是否可以验证呢,来看一个栗子:

      

    package javaEE;
    /** 
     * @author 047493 
     * @version 2018年8月31日 
     * 类说明 
     */
    public class Test12 {
        public static void main(String[] args) {
            
            String str1 = "Hello";
            String str2 = new String("Hello");
            String str3 = str2;
            
            System.out.println(str1 == str2);
            System.out.println(str2 == str3);
            System.out.println(str1 == str3);
            
        }
    }

    运行结果:

    false
    true
    false

    造成此原因的内存关系图如下:

    通过上图分析可知,== 比较的不是字符串对象包含的内容,而是两个对象所在的内存对象的数值。即 == 属于数值比较,比较的是内存地址。

    如果想比较字符串的内容,可以使用equals()。栗子如下:

    package javaEE;
    /** 
     * @author 047493 
     * @version 2018年8月31日 
     * 类说明 
     */
    public class Test12 {
        public static void main(String[] args) {
            
            String str1 = "Hello";
            String str2 = new String("Hello");
            String str3 = str2;
            
            System.out.println(str1.equals(str2));
            System.out.println(str2.equals(str3));
            System.out.println(str1.equals(str3));
            
        }
    }

    运行结果如下:

    true
    true
    true

    字符串常量是匿名对象:
    一个栗子,验证如下:

    package javaEE;
    /** 
     * @author 047493 
     * @version 2018年8月31日 
     * 类说明 
     */
    public class Test12 {
        public static void main(String[] args) {
            
            String str1 = "Hello";
            System.out.println("Hello".equals(str1));
        }
    }

    运行结果如下:

    true

    匿名对象可以调用类中的方法和属性,而以上字符串调用了String类的equals(),所以它一定是一个对象。

    String类对象两种实例化方式的区别:

    (1)直接赋值的实例化方式:String str ="Hello";

    内存关系图如下:

    举个栗子:

    package javaEE;
    /** 
     * @author 047493 
     * @version 2018年8月31日 
     * 类说明 
     */
    public class Test12 {
        public static void main(String[] args) {
            
            String str1 = "Hello";
            String str2 = "Hello";
            String str3 = "Hello";
            
            System.out.println(str1 == str2);
            System.out.println(str2 == str3);
            System.out.println(str3 == str1);
    
        }
    }

    运行结果如下:

    true
    true
    true


    我们发现以上所有直接赋值的String类对象的内存地址完全相同,内存分配图如下:

    在设计String类的时候采用了一种共享设计模式的概念。在运行的JVM底层存在一个字符串的对象池(object pool),如果用户才用了直接赋值的方式,会将字符串的内容放入池保存,如果以后其他字符串对象继续使用直接赋值方式实例化,且设置了同样的内容,那么将不会分配新的堆内存空间,而是使用已有对象的引用进行分配继续使用。如果新声明的字符串内容不在对象池中,则会分配一个新的,然后继续放到池中以供下次使用。由于String对象的不可变性,我们可以十分肯定字符串常量池中一定不存在两个相同的字符串。

    (2)构造方法实例化方式:String str = new String("Hello");

    构造方法实例化使用new关键字,而一旦使用new关键字就表示要分配新的内存空间。

    内存分配图如下:

    首先产生匿名对象"Hello",然后new关键字再次产生"Hello",并且str指向该字符串,原来的匿名对象变成垃圾,由GC回收。

    可以发现,分配了两块内存空间,其中一块是垃圾。这样除了内存的浪费外,使用构造方法定义的String对象,其内容不会保存在对象中(因为重新分配了一块堆内存)。

    现在希望使用构造方法定义的String类对象,其内容要保存在对象中,改怎么办?我们可以使用intern(),手工入池。

    举个栗子:

    package javaEE;
    /** 
     * @author 047493 
     * @version 2018年8月31日 
     * 类说明 
     */
    public class Test12 {
        public static void main(String[] args) {
            
            String str1 = new String("Hello").intern();
            String str2 = "Hello";
            String str3 = "Hello";
            
            System.out.println(str1 == str2);
            System.out.println(str2 == str3);
            System.out.println(str3 == str1);
        }
    }

    运行结果如下:

    true
    true
    true

    注意:在实际开发中我们不会采用构造方法进行字符串的实例化。

    两种实例化方式的区别:

      (1)直接赋值方式:只会分配一块堆内存空间,并且对象内容自动入池,以供重复使用;

      (2)构造方法方式:会分配两块堆内存空间,其中有一块是垃圾,并且不会自动入池,可以调用intern()自动入池。

     

    字符串的内容一旦定义则不可改变:

    一个栗子:

    package javaEE;
    /** 
     * @author 047493 
     * @version 2018年8月31日 
     * 类说明 
     */
    public class Test12 {
        public static void main(String[] args) {
            
            String str = "Hello ";
            str +="World ";
            str +="!!!";
            System.out.println(str);
        }
    }

    运行结果如下:

    Hello World !!!

    内存分析图如下:

    通过内存分析图得知,字符串内容的改变,实际上改变的是字符串对象的引用过程,并且会伴随着大量的内存垃圾出现,在实际开发中应该避免。

    那,如果我们要改变字符串的长度,应该怎么做呢?

    可以使用可变字符串StringBuilder或StringBuffer。

    StringBuilder和StringBuffer构建可变字符串对象都是通过new操作符调用构造方法,两者的区别在于StringBuilder应用于单线程环境,而StringBuffer应用于多线程环境。

    StringBuilder的主要方法:

    package javaEE;
    /** 
     * @author 047493 
     * @version 2018年8月31日 
     * 类说明 
     */
    public class Test12 {
        public static void main(String[] args) {
            
            StringBuilder sb = new StringBuilder();
            sb.append("String is changed");
            System.out.println(sb);
            sb.insert(0, 123);  //在字符串下标0处插入123
            System.out.println(sb);
            sb.delete(0, 3);  //删除前3位字符串
            //sb.delete(sb.length()-3, sb.length());  //删除sb字符串后面的3位字符
            System.out.println(sb);
            sb.replace(0, 3, "!!!");  //替换前3位字符串
            System.out.println(sb);
            sb.reverse();  //字符串翻转
            System.out.println(sb);
            sb.setCharAt(0, 'A');  //设置某个小标的字符内容
            System.out.println(sb);
        }
    }

    运行结果如下:

    String is changed
    123String is changed
    String is changed
    !!!ing is changed
    degnahc si gni!!!
    Aegnahc si gni!!!

    即,凡是需要大量拼接字符串的地方都应该尽量使用可变字符串来完成,效率高且不占内存空间。

    关于String类,面试中所常遇到的问题?

    1)String str = new String("Hello"); "Hello"在内存中是怎么分配的?程序创建了几个对象?

    这个题考察的是java中字符串常量池和JVM运行时数据区的相关概念。

    内存分布可以参考下图:

    那么创建了几个对象呢?答案是2个。

    首先,出现了字面量“Hello”,那么先要在String Pool中查找是否存在相同的字符串,因为程序就这一行代码所以肯定没有,那么就在堆内存中用字面量“Hello”首先创建一个Hello对象;

    接着,new String("Hello"),关键字new又在堆中创建了一个对象,然后调用接收String参数的构造器进行了初始化,最后str引用这个String对象。

    2)String,StringBuffer,StringBuilder区别?

    首先我们知道String是不可变的,当我们对操作String时,总会创建新的字符串,很耗费资源,所以java提供了两个工具类来操作String,StringBuffer,StringBuilder。

    StringBuffer与StringBuilder都是可变类,功能相似。唯一不同的是StringBuffer是线程安全的,而StringBuilder是线程不安全的。所以在多线程对同一个字符串进行操作的时候,我们应该选择StringBuffer。但如果是单线程的情况下,StringBuilder的效率要高于StringBuffer。

    关于字符串在各种情况下的比较,可以参考博主平凡希的文章,写的很详细:https://www.cnblogs.com/xiaoxi/p/6036701.html

    参考资料:

    https://blog.csdn.net/wei_zhi/article/details/52761081

    https://www.cnblogs.com/fwnboke/p/8529453.html

  • 相关阅读:
    jquery+easy ui 实现表格列头筛选
    javascript 未结束的字符串常量
    C# 中带@字符串中的转义符号
    .net 和java JSON 模板
    百度下载google 浏览器安装失败
    无法在web服务器上启动调试,此项目在使用一个被配置为使用特定IP地址的网站。请在项目URL中指定计算机名称。
    无法在web服务器上启动调试,服务器不支持对ASP.NET 或ATL Server应用程序进行调试。
    CSS Select 标签取选中文本值
    CSS 文章段落样式
    第二个冲刺周期第一天
  • 原文地址:https://www.cnblogs.com/Rain1203/p/9494665.html
Copyright © 2020-2023  润新知