常用类学习(String类和StringBuffer类详解)

发布时间:2022-08-19 14:15

✅作者简介:大家好我是@每天都要敲代码,一位材料转码农的选手,希望一起努力,一起进步!
个人主页:@每天都要敲代码的个人主页
在我们学习的过程中,肯定需要刷题,巩固所学知识点;给大家推荐一款模拟面试、刷题神器,从基础到大厂面试题点击跳转刷题网站

目录

String类

❤️String字符串的存储原理

❤️String类的常用构造方法

❤️String类的常用方法

StringBuffer类

❤️使用''+"进行字符串拼接带来的问题   

❤️使用StringBuffer进行字符串拼接

❤️使用StringBuilder进行字符串拼接

❤️String类和StringBuffer类对比(重点)


String类

❤️String字符串的存储原理

关于Java JDK中内置的一个类:java.lang.String
    1、String表示字符串类型,属于引用数据类型,不属于基本数据类型。
    2、在java中随便使用双引号括起来的都是String对象。例如:"abc","def","hello world!",这是3个String对象。
    3、java中规定,双引号括起来的字符串,是不可变的,也就是说"abc"自出生到最终死亡,不可变,不能变成"abcd",也不能变成"ab"
    4、在JDK当中双引号括起来的字符串,例如:"abc" "def"都是直接存储在“方法区”的“字符串常量池”当中的。
    5、为什么SUN公司把字符串存储在一个“字符串常量池”当中呢?因为字符串在实际的开发中使用太频繁。为了执行效率,所以把字符串放到了方法区的字符串常量池当中。

⭐️例1:

package com.bjpowernode.javase;

public class StringTest01 {
    public static void main(String[] args) {
        //1、这两行代码表示底层创建了3个字符串对象,都在"字符串常量"池当中。
        //2、实际上s1指向"abcdef";第二次发现有"abcdef"不会在重新创建,
        //而是直接从“方法区”的“字符串常量池”当中直接拿取
        //3、并没有什么指向 "xy";
        //4、s2指向的是"abcdefxy"
        String s1 = "abcdef";
        String s2 = "abcdef" + "xy";

        // 分析:这是使用new的方式创建的字符串对象。这个代码中的"xy"是从哪里来的?
        // 凡是双引号括起来的都在字符串常量池中有一份。
        // new对象的时候一定在堆内存当中开辟空间。
        String s3 = new String("xy");
    }
}

只有s1和s2内存图

常用类学习(String类和StringBuffer类详解)_第1张图片

 s1、s2、s3内存图

常用类学习(String类和StringBuffer类详解)_第2张图片

⭐️例2:对于String类型,存储的都是内存地址

package com.bjpowernode.javase;

public class User {
    private int id;
    private String name;
    //入口
    public static void main(String[] args) {
        User user = new User(110,"张三");
    }
    //构造方法
    public User() {
    }
    public User(int id, String name) {
        this.id = id;
        this.name = name;
    }

    //setter and getter
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

}

重画一下以前理解的内存图

常用类学习(String类和StringBuffer类详解)_第3张图片

⭐️例3:

package com.bjpowernode.javase;

public class StringTest02 {
    public static void main(String[] args) {
        //"hello"是存储在方法区的字符串常量池当中,所以"hello"不会新建
        String s1 = "hello";
        String s2 = "hello";
        //双等号比较的是变量中保存的地址,s1和s2保存的地址是相同的
        System.out.println(s1==s2); //true

        String x = new String("xyz");
        String y = new String("xyz");
        System.out.println(x==y); //false

        //通过这两个例题,我们知道对象之间的比较不能用"=="
        //"=="不保险,应该使用String类中的equals方法进行比较
        // String类已经重写了equals方法,以下的equals方法调用的是String重写之后的equals方法。
        System.out.println(x.equals(y)); //true

        //深度理解
        String k = new String("abcd");
        System.out.println(k.equals("abcd")); //true
        //也可以把字符串写在前面,避免空指针异常
        System.out.println("abcd".equals(k)); //true

        //当k为空指针
        k = null;
        System.out.println("abcd".equals(k)); //false
        System.out.println(k.equals("abcd")); //空指针异常

        //重新强调一下重点     
        int i = 100; 
       // i变量中保存的是100这个值。
        String s = "abc"; 
        // s变量中保存的是字符串对象的内存地址。
        // s引用中保存的不是"abc",是0x1111
        // 而0x1111是"abc"字符串对象在“字符串常量池”当中的内存地址。

    }
}

内存图

常用类学习(String类和StringBuffer类详解)_第4张图片

⭐️例4:分析以下程序创建了几个对象

package com.bjpowernode.javase;
//分析以下程序创建了几个对象
public class StringTest03 {
    public static void main(String[] args) {
        //一共创建三个对象:方法区字符串常量池中有1个"hello";堆内存中有2个String对象
        String s1 = new String("hello");
        String s2 = new String("hello");
    }
}

❤️String类的常用构造方法

第一个:String s = new String("abc");
第二个:String s = "abc"; 最常用
第三个:String s = new String(char数组);
第四个:String s = new String(char数组,起始下标,长度);
第五个:String s = new String(byte数组);
第六个:String s = new String(byte数组,起始下标,长度)

package com.bjpowernode.javase;
//String类中常用的构造方法
public class StringTest04 {
    public static void main(String[] args) {
        //1. 创建字符串对象最常用的一种方法
        String s1 = "hello world";
        String s = new String("world");
        System.out.println(s1); //hello world,String类重写了toString方法
        System.out.println(s); //world

        //2.String里面传byte数组
        byte[] b = {97,98,99}; // a b c
        String s2 = new String(b);
        //输出一个引用的时候,会自动调用toString方法,会自动输出对象的内存地址
        //现在输出结果是abc,得出结论:String类那个重写了toString()方法
        //所以这里输出字符串对象的话,输出的不是对象的内存地址,而是字符串本身
        System.out.println(s2); //abc
        System.out.println(s2.toString()); //abc

        //3.String(字节数组,数组元素下标的起始地址,长度)
        //将byte数组中的一部分转换成字符串
        String s3 = new String(b,1,2); //偏移量也就是下标、长度
        System.out.println(s3); //bc

        //4.将char数组全部转换成字符串
        char[] c= {'a','b','c','d'};
        String s4 = new String(c);
        System.out.println(s4); //abcd
        //5.将char数组的一部分转换成字符串
        String s5 = new String(c,2,2);
        System.out.println(s5); //cd
        
    }

}

❤️String类的常用方法

1.(掌握)char charAt(int index)返回指定索引的char值
2.(了解)int compareTo(String anotherString)比较两个字符串的大小
3.(掌握)boolean contains(CharSequence s)看后面字符串是不是前面字符串的子串
4.(掌握)boolean endsWith(String suffix)判断当前字符串是否以某个“字符串”结尾
5.(掌握)boolean    startsWith(String prefix)判断当前字符串是否以某个“字符串”开始
6.(掌握)boolean equals(Object anObject)判断两个字符串是否相等
注意:equals只能看出是否相等;compareTo方法不仅可以看出是否相等,还可以看出谁大谁小
7.(掌握)boolean  equalsIgnoreCase(String anotherString)判断两个字符串是否相等,忽略大小写
8.(掌握)byte[] getBytes()将字符串对象转换成字节数组
9.(掌握)int  indexOf(String str)判断某个字符串在当前字符串中第一次出现处的索引(下标);返回对应的下标。和contains方法一块记忆
10.(掌握) int   lastIndexOf(String str)判断某个字符串在当前字符串中最后一次出现的索引(下标);contains方法一块记忆
11.(掌握)boolean    isEmpty()判断某个字符串是否为“空字符串”,底层源代码调用的应该是字符串的length()方法;而不是空指针
12.(掌握)int   length()求字符串的长度,是length()方法;和数组length属性区分开
13.补充面试题:判断数组长度和判断字符串长度不一样
       判断数组长度是length属性,判断字符串长度是length()方法
14.(掌握)String    replace(CharSequence target, CharSequence replacement)替换字符串,例如:  String str = "abcdexyx".replace("dex","xyz");结果就是:abcxyzyx      
15.(掌握)String[]    split(String regex)拆分字符串,把字符串拆分成一个字符串数组
16.(掌握)String    substring(int beginIndex)截取字符串,从当前下标到结束    
             String    substring(int beginIndex, int endIndex),定义截取的范围,左闭右开
17.(掌握)char[]    toCharArray()将此字符串转换为一个字符数组
18.(掌握)String    toLowerCase()大写转小写
19.(掌握)String    toUpperCase()小写转大写
20.(掌握)String    trim()去除字符串前后空白
21.(掌握) String中只有valueOf方法是静态的,不需要new对象
         String s1 = String.valueOf(true);作用:将"非字符串"转换成"字符串"   
         这个静态的valueof()方法,参数是一个对象的时候,也会调用toString方法
         没有重写toString方法,结果是对象内存地址
22.研究一下print()方法,都会调用valueOf方法valueOf方法会调用toString方法
本质上System.out.println()这个方法在输出任何类型数据的时候,都是先转换成字符串在输出到控制台上

package com.bjpowernode.javase;

public class StringTest05 {
    public static void main(String[] args) {
        //1.(掌握)char charAt(int index)
        // 返回指定索引的char值
        char c = "abcd".charAt(2);
        System.out.println(c); // c

        //2.(了解)int compareTo(String anotherString)
        // 比较两个字符串的大小。一个字符一个字符进行比较
        int i = "abc".compareTo("abf");
        System.out.println(i); //-3
        int j = "abc".compareTo("abc");
        System.out.println(j); //0
        int k = "abc".compareTo("abac");
        System.out.println(k); //2

        //3.(掌握)boolean contains(CharSequence s)
        //看后面字符串是不是前面字符串的子串,contains包含的意思
        boolean b = "abcdef".contains("bcd");
        System.out.println(b); //true

        //4.(掌握)boolean endsWith(String suffix)
        //判断当前字符串是否以某个“字符串”结尾
        boolean b1 = "xyyz.txt".endsWith(".txt");
        System.out.println(b1); //true

        //5.(掌握)boolean	startsWith(String prefix)
        //判断当前字符串是否以某个“字符串”开始
        boolean bb1 = "xyyz.txt".startsWith("xyy");
        System.out.println(bb1);

        //6.(掌握)boolean equals(Object anObject)
        //判断两个字符串是否相等,用equals方法
        //equals只能看出是否相等;compareTo方法不仅可以看出是否相等,还可以看出谁大谁小
        System.out.println("abc".equals("abc"));// true

        //7.(掌握)boolean  equalsIgnoreCase(String anotherString)
        //判断两个字符串是否相等,忽略大小写
        boolean b2 = "aXybbC".equalsIgnoreCase("axybbc");
        System.out.println(b2);// true

        //8.(掌握)byte[] getBytes()
        //将字符串对象转换成字节数组
        byte[] arr = "abcd".getBytes();
        for (int ii = 0; ii < arr.length; ii++) {
            System.out.print(arr[ii]+" "); //97 98 99 100
        }

        //9.(掌握)int  indexOf(String str)
        //判断某个字符串在当前字符串中第一次出现处的索引(下标)。返回对应的下标
        int start = "abcdef".indexOf("de");
        System.out.println(start); // 3

        //10.(掌握) int	lastIndexOf(String str)
        //判断某个字符串在当前字符串中最后一次出现的索引(下标)
        int end = "abcdefdebdeccc".lastIndexOf("de");
        System.out.println(end); // 9

        //11.(掌握)boolean	isEmpty()
        //判断某个字符串是否为“空字符串”,底层源代码调用的应该是字符串的length()方法;而不是空指针
        boolean b4 = "".isEmpty();
        System.out.println(b4);//true,为空为true

        //12.(掌握)int   length()
        int len = "abc".length();
        System.out.println(len); //3
        System.out.println("".length()); //0,也能说明是不是空串

        //13.补充面试题:判断数组长度和判断字符串长度不一样
        // 判断数组长度是length属性,判断字符串长度是length()方法

        //14.(掌握)String	replace(CharSequence target, CharSequence replacement)
        //String的父接口就是:CharSequence
        String str = "abcdexyx".replace("dex","xyz");
        System.out.println(str); //abcxyzyx

        //15.(掌握)String[]	split(String regex)
        //拆分字符串
        String[] str1 = "2022-6-27".split("-");
        for (int l = 0; l < str1.length; l++) {
            System.out.println(str1[l]);
        }

        //16.(掌握)String	substring(int beginIndex)
        //截取字符串
        String str2 = "abcdxyz".substring(4);
        System.out.println(str2); //xyz
        //String	substring(int beginIndex, int endIndex)
        //beginIndex起始位置包括;endIndex终止位置不包括
        System.out.println("abcdxyz".substring(4,6)); //xy,左闭右开,只包含4、5的值

        //17.(掌握)char[]	toCharArray()
        //将此字符串转换为一个新的字符数组
        char[] chars= "abcde".toCharArray();
        for (int l = 0; l < chars.length; l++) {
            System.out.println(chars[l]);// a b c d e
        }

        //18.(掌握)String	toLowerCase()
        //大写转小写
        String str3 = "AaBbCcDD".toLowerCase();
        System.out.println(str3); //aabbccdd

        //19.(掌握)String	toUpperCase()
        //小写转大写
        String str4 = "AaBbCcDD".toUpperCase();
        System.out.println(str4); //AABBCCDD

        //20.(掌握)String	trim()
        //去除字符串前后空白
        String str5 = "   Hello World   ".trim();
        System.out.println(str5);

        //21.(掌握) String中只有valueOf方法是静态的,不需要new对象
        //作用:将"非字符串"转换成"字符串"
        String s1 = String.valueOf(true);
        System.out.println(s1); //字符串"true"
        String s2 = String.valueOf(123);
        System.out.println(s2); //字符串"123"

        //这个静态的valueof()方法,参数是一个对象的时候,也会调用toString方法
        String s3 = String.valueOf(new Customer());
        System.out.println(s3);//com.bjpowernode.javase.Customer@4554617c
        //没有重写toString方法,结果是对象内存地址

        //22.研究一下print()方法,都会调用valueOf方法,valueOf方法又会调用toString方法
        System.out.println(100);
        System.out.println(3.14);
        System.out.println(true);
        Object obj = new Object();
        System.out.println(obj);// java.lang.Object@74a14482

        //本质上System.out.println()这个方法在输出任何类型数据的时候,
        // 都是先转换成字符串在输出到控制台上
    }

}

class Customer{

}

StringBuffer类

❤️使用''+"进行字符串拼接带来的问题   

思考:我们在实际的开发中,如果需要进行字符串的频繁拼接,会有什么问题?

        因为java中的字符串是不可变的,每一次拼接都会产生新字符串。

        这样会占用大量的方法区内存。造成内存空间的浪费。      

  例如:String s = "abc";
        s += "hello";
        就以上两行代码,就导致在方法区字符串常量池当中创建了3个对象:
         "abc"
         "hello"
         "abchello"
package com.bjpowernode.javase;

public class StringBufferTest01 {
    public static void main(String[] args) {
        String s = " ";
        // 这样做会给java的方法区字符串常量池带来很大的压力。
        for (int i = 0; i < 10; i++) {
            //并不是在原来的基础上拼接,而是不断重新创建
            s += i;
            System.out.println(s);
        }

    }
}

❤️使用StringBuffer进行字符串拼接

1、如果以后需要进行大量字符串的拼接操作,建议使用JDK中自带的:   

     

 java.lang.StringBuffer
 java.lang.StringBuilder

2、如何优化StringBuffer的性能?

     在创建StringBuffer的时候尽可能给定一个初始化容量

     最好减少底层数组的扩容次数。预估计一下,给一个大一些初始化容量。

     关键点:给一个合适的初始化容量。可以提高程序的执行效率。

3、StringBuffer()

     构造一个没有字符的字符串缓冲区,默认初始容量为16个字符

     StringBuffer(int capacity)

     构造一个没有字符的字符串缓冲区,并构造指定的初始容量。

4、StringBuffer底层实际上是一个byte[]数组,往StringBuffer中放字符串,实际上是放到byte数组当中了;StringBuffer的初始化容量是16

5、StringBuffer怎样扩容的?

     利用append()方法进行追加扩容

package com.bjpowernode.javase;

public class StringBufferTest02 {
    public static void main(String[] args) {
        // 调用无参创建一个初始化容量为16个byte[] 数组。(字符串缓冲区对象)
        StringBuffer stringBuffer = new StringBuffer();
        // 拼接字符串,以后拼接字符串统一调用 append()方法。append是追加的意思。
        stringBuffer.append("a");
        stringBuffer.append("bc");
        stringBuffer.append(3.14);
        stringBuffer.append(true);
        // append方法底层在进行追加的时候,如果byte数组满了,会自动扩容。
        stringBuffer.append(100L);
        //输出,默认会调用toString()方法
        System.out.println(stringBuffer); //abc3.14true100

        
         //--------------------------指定初始化容量
        // 指定初始化容量的StringBuffer对象(字符串缓冲区对象)
        StringBuffer sb = new StringBuffer(100); //初始化容量是100
        sb.append("hello");
        sb.append("world");
        sb.append("hello");
        sb.append("kitty");
        //输出,默认会调用toString()方法
        System.out.println(sb);


    }
}

❤️使用StringBuilder进行字符串拼接

StringBuffer和StringBuilder的区别?        

(1)StringBuffer中的方法都synchronized(同步的)关键字修饰。表示StringBuffer在多线程环境下运行是安全的。

(2)StringBuilder中的方法都没有synchronized关键字修饰,表示StringBuilder在多线程环境下运行是不安全的。

(3)效果和用法都是相同的;不过StringBuffer是线程安全的,StringBuilder是非线程安全的

package com.bjpowernode.javase;

public class StringBuilderTest01 {
    public static void main(String[] args) {

        // 使用StringBuilder也是可以完成字符串的拼接。
        StringBuilder sb = new StringBuilder();
        sb.append(100);
        sb.append(true);
        sb.append("hello");
        sb.append("kitty");
        System.out.println(sb);
    }
}

❤️String类和StringBuffer类对比(重点)

1、String为什么是不可变的?

    String类中内部是一个byte[]数组,这个byte[]数组采用了final修饰,因为数组一旦创建长度不可变。并且被final修饰的引用一旦指向某个对象之后,不可再指向其它对象所以String是不可变的!所以"abc" 无法变成 "abcd"

2、StringBuilder/StringBuffer为什么是可变的呢?

    StringBuffer/StringBuilder内部实际上也是一个byte[]数组,这个byte[]数组没有被final修饰,StringBuffer/StringBuilder的初始化容量是16,当存满之后会进行自动扩容,底层调用了数组拷贝的方法System.arraycopy()方法进行扩容所以StringBuilder/StringBuffer 适合于使用字符串的频繁拼接操作。

public class StringBufferTest03 {
    public static void main(String[] args) {

        // 字符串不可变是什么意思?
        // 是说双引号里面的字符串对象一旦创建不可变。
        String s = "abc"; //"abc"放到了字符串常量池当中。"abc"不可变。

        // s变量没有被final修饰,是可以指向其它对象的。
        // 字符串不可变不是说变量s不可变。说的是"abc"这个对象不可变。
        s = "xyz";//"xyz"放到了字符串常量池当中。"xyz"不可变。

    }
}

ItVuer - 免责声明 - 关于我们 - 联系我们

本网站信息来源于互联网,如有侵权请联系:561261067@qq.com

桂ICP备16001015号