【JAVA中String类的相关知识】

已于 2022-11-22 21:18:19 修改
阅读量410 收藏
点赞数 1
分类专栏： Java SE 文章标签： java
于 2022-11-12 15:46:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_64317046/article/details/127795813
版权

文章目录

一、创建字符串

常见的构造 String 的方式：

// 方式一
String str = “Hello TC”;
// 方式二
String str2 = new String(“Hello TC”);
// 方式三
char[] array = {‘a’, ‘b’, ‘c’};
String str3 = new String(array);

1.1创建字符串时的内存布局

注意事项:
“hello” 这样的字符串字面值常量, 类型也是 String.
String 也是引用类型. String str = “Hello”; 这样的代码内存布局如下：
在这里插入图片描述

String str1 = “Hello”;String str2 = str1;内存布局如下：
在这里插入图片描述
那么有同学可能会说, 是不是修改 str1 , str2 也会随之变化呢?

str1 = “world”;
System.out.println(str2);
// 执行结果
Hello

我们发现, “修改” str1 之后, str2 也没发生变化, 还是 hello?事实上, str1 = “world” 这样的代码并不算 “修改” 字符串, 而是让 str1 这个引用指向了一个新的 String 对象，内存布局如下：
在这里插入图片描述

二、字符串比较相等

String类对象上使用 == 比较字符串相等吗？

String str1 = “Hello”;
String str2 = “Hello”;
System.out.println(str1 == str2);
// 执行结果
true

结果为true，那我们换一种形式再来比较呢

String str1 = new String(“Hello”);
String str2 = new String(“Hello”);
System.out.println(str1 == str2);
// 执行结果
false

为什么两次的结果不一样呢？我们从内存布局来分析：

代码一：
在这里插入图片描述
我们发现, str1 和 str2 是指向同一个对象的. 此时如 “Hello” 这样的字符串常量是在 字符串常量池 中。关于字符串常量池，我们下面会讲解

代码二：
在这里插入图片描述
通过 String str1 = new String(“Hello”); 的方式创建的 String 对象相当于再堆上另外开辟了空间来存储"Hello" 的内容, 也就是内存中存在两份 “Hello”

2.1equals方法

注意事项：
String 使用 == 比较并不是在比较字符串内容, 而是比较两个引用是否是指向同一个对象，Java 中要想比较字符串的内容, 必须采用String类提供的equals方法！

代码如下：

String str = new String(“Hello”);
// 方式一
System.out.println(str.equals(“Hello”));
// 方式二
System.out.println(“Hello”.equals(str));

在上面的代码中, 哪种方式更好呢?
我们更推荐使用 “方式二”. 一旦 str 是 null, 方式一的代码会抛出异常, 而方式二不会

三、字符串常量池

本质上是哈希表

如 “Hello” 这样的字符串字面值常量, 也是需要一定的内存空间来存储的. 这样的常量具有一个特点, 就是不需要修改(常量嘛). 所以如果代码中有多个地方引用都需要使用 “Hello” 的话, 就直接引用到常量池的这个位置就行了, 而没必要把 “Hello” 在内存中存储两次.

3.1实例化操作的内存布局

在上面, String类的两种实例化操作, 直接赋值和 new 一个新的 String
a）直接赋值

String str1 = “hello” ;
String str2 = “hello” ;
System.out.println(str1 == str2); // true

我们从更详细的内存布局分析：
在这里插入图片描述
为什么现在并没有开辟新的堆内存空间呢？

String类的设计使用了共享设计模式
在JVM底层实际上会自动维护一个对象池（字符串常量池)，如果现在采用了直接赋值的模式进行String类的对象实例化操作，那么该实例化对象（字符串内容）将自动保存到这个对象池之中.如果下次继续使用直接赋值的模式声明String类对象，此时对象池之中如若有指定内容，将直接进行引用如若没有，则开辟新的字符串对象而后将其保存在对象池之中以供下次使用

b) 采用构造方法

String str2 = new String(“hello”) ;

同样，从内存布局分析：
在这里插入图片描述
由此可知构造方法又在堆中创建了一个内存，该内存指向了存储在字符串常量池中的"hello"

所以，以下代码会返回false！

String str2 = new String(“hello”) ;
String str1 = “hello” ;
System.out.println(str1 == str2);
// 执行结果
false

3.2intern手动入池

我们可以使用 intern 方法来手动把 String 对象加入到字符串常量池中

String str1 = new String(“hello”).intern() ;
String str2 = “hello” ;
System.out.println(str1 == str2);
// 执行结果
true

四、理解字符串不可变

字符串是一种不可变对象. 它的内容不可改变.

String 类的内部实现也是基于 char[] 来实现的, 但是 String 类并没有提供 set 方法之类的来修改内部的字符数组.

4.1+=操作的内存变化

感受下形如这样的代码:

String str = “hello” ;
str = str + " world" ;
str += “!!!” ;
System.out.println(str);
// 执行结果
hello world!!!

形如 += 这样的操作, 表面上好像是修改了字符串, 其实不是. 内存变化如下:
在这里插入图片描述
+= 之后 str 打印的结果却是变了, 但是不是 String 对象本身发生改变, 而是 str 引用到了其他的对象.

注意: 如下代码不应在你的开发中出, 会产生大量的临时对象, 效率比较低

String str = “hello” ;
for(int x = 0; x < 1000; x++) {
str += x ;
}
System.out.println(str);

回顾引用:
引用相当于一个指针, 里面存的内容是一个地址. 我们要区分清楚当前修改到底是修改了地址对应内存的内容发生改变了, 还是引用中存的地址改变了

那么如果实在需要修改字符串, 例如, 现有字符串 str = “Hello” , 想改成 str = “hello” , 该怎么办?

4.2修改字符串

a) 常见办法: 借助原字符串, 创建新的字符串

String str = “Hello”;
str = “h” + str.substring(1);
System.out.println(str);
// 执行结果
hello
String str = “Hello”;

b) 特殊办法(选学): 使用 “反射” 这样的操作可以破坏封装, 访问一个类内部的 private 成员

关于反射:
反射是面向对象编程的一种重要特性, 有些编程语言也称为 “自省”.指的是程序运行过程中, 获取/修改某个对象的详细信息(类型信息, 属性信息等), 相当于让一个对象更好的 “认清自己” .Java 中使用反射比较麻烦一些. 我们后面的课程中会详细介绍反射的具体用法

4.3为什么 String 要不可变?

为什么 String 要不可变?(不可变对象的好处是什么?) (选学)

  1. 方便实现字符串对象池. 如果 String 可变, 那么对象池就需要考虑何时深拷贝字符串的问题了.
  2. 不可变对象是线程安全的.
  3. 不可变对象更方便缓存 hash code, 作为 key 时可以更高效的保存到 HashMap 中

五、字符串相关操作

具体代码如下（内容较长，供自己复习）：

 public static void main1(String[] args) {
        //将一个字符串数组转换成了字符串
        char[] chars = {'a', 'b', 'c'};
        String str2 = new String(chars);
        System.out.println(str2);
    }
    public static void main5(String[] args) {
        //数组的整体赋值只有一次机会 就是在定义的时候    字符串的不可变
        final int[] array = {1, 2, 3, 4, 5};
        // array = new int[]{4,5,6};
    }
    public static void main6(String[] args) {
        //整个数组变成字符串
        /*char[] value = {'a','b','c','d'};
        String str = new String(value);
        System.out.println(str);*/

        //数组部分变成字符串
        char[] value = {'a', 'b', 'c', 'd'};
        String str = new String(value, 1, 3);
        System.out.println(str);

        //取出字符串的某个字符
        String str1 = "hello";
        char ch = str1.charAt(2);
        System.out.println(ch);

        //整个字符串变成数组
        char[] vc = str1.toCharArray();
        System.out.println(Arrays.toString(vc));//打印数组
    }
    public static void main8(String[] args) {
        //将字节转换成字符串
        byte[] bytes = {97, 98, 99, 100};
        String str = new String(bytes);
        System.out.println(str);

        //将字符串变成字节
        String str1 = "bit";
        byte[] bytes1 = str1.getBytes();
        System.out.println(Arrays.toString(bytes1));
    }
    //字符串的比较
    public static void main9(String[] args) {
        String str1 = "asdfgh";
        String str2 = "zxcvbn";
        System.out.println(str1.equals(str2));//比较

        String str3 = "asdfgh";
        String str4 = "ASDFGH";
        System.out.println(str3.equalsIgnoreCase(str4));//比较大小，忽略字母大小写
        String str5 = "abc";
        String str6 = "ABC";
        int ret = str5.compareTo(str6);//通过相减得正负判断大小
        System.out.println(ret);

        String str7 = "abacabcd";
        String str8 = "abc";
        boolean flg = str7.contains(str8);//是否包含
        System.out.println(flg);

        String str9 = "abacabcd";
        String str10 = "abc";          //fromindex:从哪个位置找
        int index = str9.indexOf(str10, 2);//在主串当中找到字串出现的位置 类似于C得struct->KMP算法
        System.out.println(index);      //lastindexof:从后往前找
        System.out.println(str9.startsWith("a"));//判断是否是以它开头
        //endsWith 以什么结尾的
    }
    //替换replace
    public static void main10(String[] args) {
        String str = "addadadadfffsw";
        String ret = str.replace('d', 'b');//将d替换为b  也可以选择其他替换模式
        System.out.println(ret);
    }
    //分割
    public static void main11(String[] args) {
        /*String str = "name=zhangsan&age=19";
        String[] strings = str.split("&");
        for (String s:strings){
            System.out.println(s);
        }*/

        //特殊情况
        String str = "192.168.1.0";
        String[] strings = str.split("\\.", 2);//特殊情况，需要加上转义字符   给2分两组
        for (String s : strings) {
            System.out.println(s);
            System.out.println("=======================================");

            String str1 = "java20 69&125#hello";
            String[] strings1 = str1.split(" |&|#");//从每一个分隔符
            for (String s1 : strings1) {
                System.out.println(s1);
            }
        }
    }
    
    //字符串的截取
    public static void main12(String[] args) {
        String str = "asdcfv";
        //String ret = str.substring(2);//从下标为2处提取
        String ret = str.substring(2, 4);//左闭右开
        System.out.println(ret);
    }
    public static void main13(String[] args) {
        String str = "     abc     def    ";
        String ret = str.trim();
        System.out.println(ret);//去除两边的空格，中间不会
    }
    public static void main14(String[] args) {
        String str = "abcdefBFGH";
        String ret = str.toUpperCase(Locale.ROOT);//转大写，也有转小写
        System.out.println(ret);
    }
    public static void main15(String[] args) {
        String str = "adfdsa";
        String ret = str.concat("bitt");//拼接    拼接的结果不会入池
        System.out.println(ret);
    }

六、StringBuffer 和 StringBuilder

首先来回顾下String类的特点：

任何的字符串常量都是String对象，而且String的常量一旦声明不可改变，如果改变对象内容，改变的是其引用的指向而已。通常来讲String的操作比较简单，但是由于String的不可更改特性，为了方便字符串的修改，提供StringBuffer和StringBuilder类。StringBuffer 和 StringBuilder 大部分功能是相同的，我们主要介绍 StringBuffer在String中使用"+"来进行字符串连接，但是这个操作在StringBuffer类中需要更改为append()方法：

public synchronized StringBuffer append(各种数据类型 b)

范例：观察StringBuffer使用

public class Test {
        public static void main(String[] args) {
            StringBuffer sb = new StringBuffer();
            sb.append("Hello").append("World");
            fun(sb);
            System.out.println(sb);
        }

        public static void fun(StringBuffer temp) {
            temp.append("\n").append("www.baidu.com.cn");
        }
    }

String和StringBuffer最大的区别在于：String的内容无法修改，而StringBuffer的内容可以修改。频繁修改字符串，考虑使用StingBuffer。

6.1从继承结构理解

为了更好理解String和StringBuffer，我们来看这两个类的继承结构:
在这里插入图片描述

可以发现两个类都是"CharSequence"接口的子类。这个接口描述的是一系列的字符集。所以字符串是字符集的子类，如果看见CharSequence，最简单的联想就是字符串。

注意：String和StringBuffer类不能直接转换。如果要想互相转换，可以采用如下原则:
1、String变为StringBuffer:利用StringBuffer的构造方法或append()方法
2、StringBuffer变为String:调用toString()方法。

6.2StringBuffer相关方法

除了append()方法外，StringBuffer也有一些String类没有的方法，如下

字符串反转：
public synchronized StringBuffer reverse()
代码示例: 字符串反转
StringBuffer sb = new StringBuffer(“helloworld”);
System.out.println(sb.reverse());

删除指定范围的数据:
public synchronized StringBuffer delete(int start, int end)
代码示例: 观察删除操作
StringBuffer sb = new StringBuffer(“helloworld”);
System.out.println(sb.delete(5, 10));

插入数据
public synchronized StringBuffer insert(int offset, 各种数据类型 b)
代码示例: 观察插入操作
StringBuffer sb = new StringBuffer(“helloworld”);
System.out.println(sb.delete(5, 10).insert(0, “你好”));

6.3String、StringBuffer、StringBuilder的区别

面试题：请解释String、StringBuffer、StringBuilder的区别:
1、String的内容不可修改，StringBuffer与StringBuilder的内容可以修改.
2、StringBuffer与StringBuilder大部分功能是相似的
3、StringBuffer采用同步处理，属于线程安全操作；而StringBuilder未采用同步处理，属于线程不安全操作

总结

字符串操作是我们以后工作中非常常用的操作. 使用起来都非常简单方便, 一定要使用熟练.

值得注意的点:

  1. 字符串的比较, ==, equals, compareTo 之间的区别.
  2. 了解字符串常量池, 体会 “池” 的思想.
  3. 理解字符串不可变
  4. split 的应用场景
  5. StringBuffer 和 StringBuilder 的功能
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值