基础学习-String类认识

最新推荐文章于 2024-10-30 18:07:32 发布

飞翔的远方

最新推荐文章于 2024-10-30 18:07:32 发布

阅读量96

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/m0_73952669/article/details/132344595

版权

一、String类特点

1.1创建字符串

创建字符串两种方式
1.通过构造方法创建
不管参数是什么，都会在堆中new出一个新的对象

2.通过""方法创建
""方式创建的字符串常量，会在常量池中保存：
如果常量池已经存在该常量，直接引用。
如果常量池中没有该常量，直接创建并引用。
字符串常量池的对象，是共享的，唯一的。

只要采用双引号“”赋值字符串，那么在编译期将会放到方法区中的字符串的常量池里,如果是运行时，会对字符串相加或相减会放到堆中（放之前会先验证方法区中是否含有相同的字符串常量，如果存在，把地址返回，如果不存在，先将字符串常量放到池中，然后再返回该对象的地址）

1.2 字符串拼接

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

        String s1 = "ab";
        String s2 = s1 + "c"; //字符串变量的拼接，相当于new字符串的过程 new String(s1+"c")

        String s3 = "abc";
        String s4 = "ab" + "c"; //字符串常量拼接，底层会进行优化，编译后代码变成 String s4 = "abc";
        System.out.println(s2==s3); //false
        System.out.println(s4==s3); //true

    }
}

1.3 == 和 equals的区别

字符串的比较
使用 == 做比较
⚫ 基本类型：比较的是数据值是否相同
⚫ 引用类型：比较的是地址值是否相同
字符串是对象，它比较内容是否相同，是通过一个方法来实现的，这个方法叫： equals()
⚫ public boolean equals(Object anObject)：将此字符串与指定对象进行比较。由于我们比较的是字符串
对象，所以参数直接传递一个字符串

1. Java程序中, 所有双引号字符串, 都是String类的对象.

2. 字符串一旦被创建, 就 [不可改变]内容不可改变, 要想改变, 只能用新的对象做替换.

String s = "abc";
s = "def";	// 这里只是让s变量, 记录了新的字符串对象
// 原来 "abc", 内容根本没有改变
System.out.println(s);		// def

3. 字符串虽然不可改变, 但是可以被共享

字符串常量池:

当使用双引号创建字符串对象的时候.会检查该数据在常量池中是否存在
不存在: 创建新的
存在: 复用

4. 字符串和字符数组之间允许相互转换


char[] chs = {'a','b','c'};  ------->  String s = new String(chs);

String s = "itheima";  ------> char[] chs = s.toCharArray();

二、String类常用构造方法

1. public String() : 创建一个空白的字符串对象

2. public String(char[] chs) : 根据传入的字符数组, 来创建字符串对象

3. public String(String str) : 根据传入的字符串, 来创建字符串对象

       -> String s = new String("abc");
       -> 面试题: 这一句代码, 实际上创建了2个对象
                   1. new出来
                   2. "abc" 在常量池中

-----------------------------------------------------------

今后创建字符串对象的方式, 一般来说, 都是双引号直接创建

String s = "abc";

三、创建String对象的两种方式

双引号直接创建 : 字符串常量池中维护
构造方法new出来 : 堆内存中, 有自己独立的内存空间.

package com.itheima.test;

public class StringTest1 {
    /*
        看程序说结果
     */
    public static void main(String[] args) {

        String s1 = "abc";
        String s2 = "a" + "b" + "c";

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

    }

    private static void method3() {
        String s1 = "abc";
        String s2 = "ab";
        String s3 = s2 + "c";

        System.out.println(s1 == s3); //false
    }

    private static void method2() {
        String s1 = "abc";
        String s2 = new String("abc");

        System.out.println(s1 == s2); //false
    }

    private static void method1() {
        String s1 = "abc";
        String s2 = "abc";

        System.out.println(s1 == s2); //true
    }
}

四、String类的常用成员方法

public boolean equals(String anObject)	字符串之间做内容的比较, 返回true, false
public boolean equalsIgnoreCase(String anotherString)	字符串之间做内容的比较, 返回true, false (忽略大小写)
public char[] toCharArray()	将字符串拆分为字符数组并返回.
public char charAt(int index)	根据传入的索引, 获取对应的字符
public int length( )	返回此字符串的长度
public String substring(int beginIndex)	根据传入的索引截取字符串, 截取到字符串的末尾
public String substring(int beginIndex, int endIndex)	定义开始索引和接收索引来截取字符串
public String replace(String target, String replacement) :	替换
public String[] split(String regex)	切割
public boolean contains(CharSequence s)	判断是否包含某子串
endsWith(String suffix)	测试此字符串是否以指定的后缀结尾。

五、StringBuilder

StringBuilder概述

⚫ StringBuilder 是一个可变的字符串容器，我们可以把它看成是一个工具
⚫ 作用：提高字符串的操作效率

StringBuilder和String的区别

⚫ String ：内容是不可变的
⚫ StringBuilder：内容是可变的

StringBuilder构造方法

方法名	说明
public StringBuilder()	创建一个空白可变字符串对象，不含有任何内容
public StringBuilder(String str)	根据字符串的内容，来创建可变字符串对象

StringBuilder常用方法

public StringBuilder append (任意类型)	添加数据，并返回对象本身
public StringBuilder reverse()	返回相反的字符序列
public int length()	返回长度 ( 字符出现的个数)
public String toString()	通过toString()就可以实现把StringBuilder转换为String

append()的特点：

append()的返回值：

/*
    StringBuilder的构造方法
        StringBuilder() ：创建一个空的字符串容器
        StringBuilder(String str)：根据指定的字符串内容，创建字符串容器

    StringBuilder的常用方法：
        append(数据);  //（把数据拼接成字符串，存到容器中）
        toString(); //获取容器中拼接好的字符串
 */
public class Demo2 {
    public static void main(String[] args) {
        //创建容器对象
        StringBuilder sb1 = new StringBuilder();
        //往容器中添加数据，添加进去的任何数据都会拼接成字符串
        sb1.append("hello");
        sb1.append("java");
        sb1.append(666);
        sb1.append('A');
        sb1.append(true);

        //可以使用toString方法，将拼接完成的字符串拿出来
        String s = sb1.toString();
        System.out.println(s);
//--------------------------------------------------------------

        StringBuilder sb2 = new StringBuilder();
        //append方法的返回值是调用者，返回调用者对象本身，
        // 此处返回的是sb2本身，运行后可以理解为 StringBuilder sb3 = sb2
        StringBuilder sb3 = sb2.append("java");

        System.out.println("sb2 = " + sb2); //java
        System.out.println("sb3 = " + sb3); //java
        System.out.println(sb2==sb3); //地址一样 true
//--------------------------------------------------------------

        //append方法，返回对象本身，好处是可以使用链式编程，简化代码
        StringBuilder sb = new StringBuilder();
        //sb.append(11);
        //sb.append(22);
        //sb.append(33);
        //sb.append("java");
        //String ss = sb.toString();

        //链式编程
        String ss = sb.append(11).append(22).append(33).append("java").toString();
        System.out.println(ss);
        
        
    }
}

------------------------------------------------
 /*

    StringBuilder的常用方法：
        append(数据);  //（把数据拼接成字符串，存到容器中）
        toString(); //获取容器中拼接好的字符串
        length(); //获取容器中字符串的长度
        reverse(); //将容器中的字符串内容反转
 */
public class Demo3 {
    public static void main(String[] args) {

        StringBuilder sb = new StringBuilder();
        System.out.println(sb.length()); //0

        sb.append("hello");
        sb.append(3.14);
        System.out.println(sb.length()); //9
        System.out.println("反转前："+sb); //hello3.14

        //反转
        sb.reverse();
        System.out.println("反转后："+sb); //41.3olleh
    }
}

StringBuilder和String相互转化

1. StringBuilder 转换为 String
public String toString()：通过 toString() 就可以实现把 StringBuilder 转换为 String

2. String 转换为 StringBuilder
public StringBuilder(String s)：通过构造方法就可以实现把 String 转换为 StringBuilder

/*
需求：键盘接受一个字符串，定义方法判断出该字符串是否是对称字符串，是返回true，不是返回false
	对称字符串：123321、111
	非对称字符串：123123
 */
public class Demo4 {
    public static void main(String[] args) {
        //键盘接受一个字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String s = sc.next();

        //调用方法，判断字符串是否对称
        boolean result = check(s);

        if(result){
            System.out.println(s + "是对称字符串");
        }else {
            System.out.println(s + "不是对称字符串");
        }

    }

    /*
        定义方法判断出该字符串是否是对称字符串，是返回true，不是返回false。
        参数：String s
        返回值：boolean
     */
    public static boolean check(String s){
        //将字符串存入容器，并反转
        StringBuilder sb = new StringBuilder(s);
        sb.reverse();
        //获取反转后的字符串
        String ss = sb.toString();
        //比较字符串内容，返回结果
        boolean result = s.equals(ss);
        return result;

        //链式编程 简化写法
        //return new StringBuilder(s).reverse().toString().equals(s);
    }


}

StringBuilder和StringBuffer

注意：

StringBuffer的用法与StringBuilder是一模一样的

但 StringBuilder是线程不安全的 StringBuffer是线程安全的

六、StringJoiner

JDK8开始才有的，跟StringBuilder一样，也是用来操作字符串的，也可以看成是一个容器，创建之后里面的内容是可变的。

好处：不仅能提高字符串的操作效率，并且在有些场景下使用它操作字符串，代码会更简洁

构造器

public StringJoiner (间隔符号)

public StringJoiner (间隔符号，开始符号，结束符号)

方法	说明
public StringJoiner add (添加的内容)	添加数据，并返回对象本身
public int length()	返回长度 ( 字符出现的个数)
public String toString()	返回一个字符串（该字符串就是拼接之后的结果）