【Java课堂】String类

🎈目录🎈

🥾前言

1.字符串构造

2.String 对象的比较 

3.字符串查找

4.转化

1. 数值、对象、布尔值转化为字符串

 2.大小写转化

 3.字符串转数组

4.格式化

5.字符串替换

6.字符串拆分

7.字符串截取

8.字符串常量池

1.创建对象的思考

 2.字符串常量池(StringTable)

3.深度讲解String对象创建

9.字符串的不可变性

10.字符串修改


前言

        对于刚学过C语言的小伙伴来说,String类可能比较陌生。在C语言中我们可以用指针来表示一串字符  如 char* p = "abcd" ,而在Java中我们可以用String类来直接表示 String p = "abcd"。

是不是方便许多,同时String类还具有很多实用的方法,现在让我们开始String类的学习吧!

1.字符串构造

String 类提供的构造方式非常多,常用的有以下三种

public static void main(String[] args) {
        //使用常量串构造
        String s1 = "你好!";
        
        //直接 newString 对象
        String s2 = new String("我是");

        //使用字符数组进行构造
        char[] array ={'S','t','r','i','n','g','类'};
        String s3 = new String(array);
        
        //打印
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
    }

如果想了解更多方法,可以参考Java在线文档 

 【注意】

① String是引用类型,内部并不存储字符串本身,这点我们可以从原码看出,其内部分为两部分 分别为 value 【存储数组】和 hash【默认为0】

public static void main(String[] args) {
        // s1 和 s2引用的是不同对象 s1 和 s3引用的是同一对象
        String s1 = new String("hello");
        String s2 = new String("world");
        String s3 = s1;
    }

 ② 在Java中 "" 引起来的也是String类型对象

// 打印"hello"字符串(String对象)的长度
System.out.println("hello".length());

2.String 对象的比较 

 字符串比较是常见的操作之一,比如:字符串排序。Java中总共提供4中方式:

 ==比较是否引用同一个对象  

注意:对于内置类型,==比较的是变量中的值;对于引用类型==比较的是引用中的地址

public static void main(String[] args) {
        //对于引用类型==比较的是引用中的地址
        String s1 = new String("hello");
        String s2 = new String("hello");
        String s3 = new String("world");
        String s4 =s1;
        System.out.println(s1 == s2);//false
        System.out.println(s2 == s3);//false
        System.out.println(s1 == s4);//true
    }

 ⅱ equals方法比较

equals是Object中的方法,但是String类中重写了该方法,用于比较String类中引用内容是否相同 用法如下

public static void main(String[] args) {
        //对于引用类型==比较的是引用中的地址
        String s1 = new String("hello");
        String s2 = new String("hello");
        String s3 = new String("world");
        
        //equals比较: String对象中的逐个字符
        //虽然s1和s2引用的不是同一个对象,但是两个对象中放置的内容相同,因此输出true
        //s2和s3引用的不是同一个对象,而且两个对象中内容也不相同,因此输出true
        System.out.println(s1.equals(s2));
        System.out.println(s2.equals(s3));
    }

 关于equals更多细节可以参考:equals() 方法详解

compareTo(String s) 方法:按照字典序进行比较

字典序:字符串大小的顺序

与equals不同的是,equals返回的是boolean类型,而compareTo返回的是int类型。具体比较方式:

  1. 先按照字典序大小比较,如果出现不等的字符,直接返回这连个字符的大小差值
  2. 如果前k个字符相等,返回两个字符串的差值
public static void main(String[] args) {
        String s1 = new String("abc");
        String s2 = new String("ac");
        String s3 = new String("abc");
        String s4 = new String("abcdefg");
        String s5 = new String("ABC");

        System.out.println(s1.compareTo(s2));//不同输出字符差值-1
        System.out.println(s1.compareTo(s3));//相同输出0
        System.out.println(s1.compareTo(s4));//前k个字符完全相同,输出长度差值-4
        System.out.println(s1.compareTo(s5));//大写和小写判定为两个字符串
    }

 ⅳ compareToIgnoreCase(String str) 方法:与 compareTo 方式相同,但是忽略大小写比较

public static void main(String[] args) {
        String s1 = new String("abc");
        String s2 = new String("aBc");
        String s3 = new String("ABc");
        String s4 = new String("abcdefg");
        String s5 = new String("ABC");

        System.out.println(s1.compareToIgnoreCase(s2));
        System.out.println(s1.compareToIgnoreCase(s3));
        System.out.println(s1.compareToIgnoreCase(s4));
        System.out.println(s1.compareToIgnoreCase(s5));
    }

3.字符串查找

字符串查找也是字符串中常见的操作,String类提供了常用查找方法:

方法功能
char charAt(int index)【用到次数很多】返回index位置上的字符,如果index为负数或者越界,则会抛出IndexOutOfBoundsException异常
int indexOf(int ch)返回ch第一次出现的位置,没有返回-1
int indexOf(int ch , int fromindex)从fromIndex位置开始找ch第一次出现的位置,没有返回-1
int indexOf(String str)返回str第一次出现的位置,没有返回-1
int indexOf(String str, int fromindex)从fromIndex位置开始找str第一次出现的位置,没有返回-1
int lastIndexOf(int ch)从后往前找,返回ch第一次出现的位置,没有返回-1
int lastIndexOf(int ch, int fromindex)从fromIndex位置开始找,从后往前找ch第一次出现的位置,没有返回-1
int lastIndexOf(String str)从后往前找,返回str第一次出现的位置,没有返回-1
int lastIndexOf(String str,int fromIndex)从fromIndex位置开始找,从后往前找str第一次出现的位置,没有返回-1
public static void main(String[] args) {
        String str = "abc abc abc defg abc cba";

        System.out.println(str.length());//24
        System.out.println(str.charAt(2));//c

        System.out.println(str.indexOf('e'));//13
        System.out.println(str.indexOf('a',7));//8
        System.out.println(str.indexOf("abc"));//返回首字母a位置的值 0
        System.out.println(str.indexOf("abc",3));//4

        System.out.println(str.lastIndexOf('c'));//21
        System.out.println(str.lastIndexOf('c',20));//17
        System.out.println(str.lastIndexOf("abc"));//返回首字母a位置的值 17
        System.out.println(str.lastIndexOf("abc",16));//8
    }

注意:上述方法都是实例方法

4.转化

1. 数值、对象、布尔值转化为字符串

一般情况下数值、对象或布尔值是不行转化成字符串的,但是String类提供了一个valueOf方法可以把这些转化成字符串

 具体操作如下

public static void main(String[] args) {
        String str1 = String.valueOf(123);
        String str2 = String.valueOf(6.6);
        String str3 = String.valueOf(true);
        System.out.println(str1);
        System.out.println(str2);
        System.out.println(str3);
    }

 而对象转化成字符串有点复杂,如果该对象类型没有重写toString方法的话,valueOf就会调用Object类中的toString方法,最后字符串中存放的是该对象的hash值

public static void main(String[] args) {
        String str = String.valueOf(new Student(10));
        System.out.println(str);
    }

如果该类重写了toString方法,那就存放是toString方法中的内容

class Student{
    int age;

    public Student(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                '}';
    }
}
public class Test {
    public static void main(String[] args) {
        String str = String.valueOf(new Student(10));
        System.out.println(str);
    }
}

 

 2.大小写转化

String类中也提供了大小写转换的方法

小写转大写:toUpperCase()

大写转小写:toLowerCAse()

当上述两个方法只会对英文转换,对中文无效,同时改变大小写,并不是把当前字符串的值改变,而是产生新的字符串!

public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "HELLO";
        //小写转大写
        String ret = s1.toUpperCase();
        System.out.println(ret+" s1->"+s1);
        //大写转小写
        ret = s2.toLowerCase();
        System.out.println(ret+" s2->"+s2);
    }

 3.字符串转数组

String类中还提供了一个toCharArray方法,可以把字符串有引用的数据提取出来转换为数组

public static void main(String[] args) {
        String s = "hello";
        //字符串数组
        char[] ch = s.toCharArray();
        for (int i = 0; i < ch.length; i++) {
            System.out.println(ch[i]);
        }
        System.out.println();
        //数组转字符串
        String s2 = new String(ch);
        System.out.println(s2);
    }

 

4.格式化

public static void main(String[] args) {
     String s = String.format("%d-%d-%d", 2019, 9,14);
     System.out.println(s);
}

5.字符串替换

使用一个指定的新的字符串替换掉已有的字符串数据,可用的方法如下:

方法功能
String replaceAll(String regex, String replacement)
替换所有指定内容
String replaceFirst(String regex, String replacement)
替换首个指定内容

regex: 要替换字符串内容        replacement:替换成字符串内容

public static void main(String[] args) {
        String s="我不想学习,我不想内卷,我不想打代码";
        System.out.println(s.replaceAll("不想","想"));
        System.out.println(s.replaceFirst("我不想学习", "麻木了"));
    }

 注意事项: 由于字符串是不可变对象, 替换不修改当前字符串, 而是产生一个新的字符串。

6.字符串拆分

可以将一个完整的字符串安装指定的分隔符划分为若干个子类,可用方法如下:

方法功能
String[] split(String regex)
将字符串全部拆分
String[] split(String regex, int limit)
将字符串以指定的格式,拆分为limit组

我想大家一个都做个这个题,将字符串按照空格拆分

public static void main(String[] args) {
        String str = "hello world welcom to study Java";
        String[] ret = str.split(" ");
        for (String s:ret) {
            System.out.println(s);
        }
    }

 我们还可以在split方法中添加参数,表明拆分几组

String[] ret = str.split(" ",3);

 拆分是特别常用的操作. 一定要重点掌握. 另外有些特殊字符作为分割符可能无法正确切分, 需要加上转义。

例如:拆分IP地址

public static void main(String[] args) {
        String str = "192.168.1.1";
        String[] ret = str.split("\\.");
        for (String s:ret) {
            System.out.println(s);
        }
    }

注意事项:

  1.  字符"|","*","+"都得加上转义字符,前面加上 "\\" 。
  2. 而如果是 "\" ,那么就得写成 "\\\\" 。
  3. 如果一个字符串中有多个分隔符,可以用"|"作为连字符。

7.字符串截取

从一个完整的字符串之中截取部分内容,可用方法如下:

方法功能
String substring(int beginIndex)
从指定索引截取到结尾
String substring(int beginIndex, int endIndex)
截取部分内容

 beginIndex:起始位置      endIndex:结束位置

public static void main(String[] args) {
        String s = "helloworld";
        System.out.println(s.substring(5));
        System.out.println(s.substring(0,5));
    }

 注意事项:

  1. 索引从0开始。
  2. 注意左闭右开, substring(0, 5) 表示包含 0 号下标的字符, 不包含 5 号下标[ 0, 5 )。

8.字符串常量池

1.创建对象的思考

我们知道对于引用类型==比较的是引用的对象是否相同,我们来看下面代码

public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "hello";
        String s3 = new String("hello");
        String s4 = new String("hello");
        System.out.println(s1 == s2);
        System.out.println(s1 == s3);
        System.out.println(s3 == s4);
    }

 上述程序创建方式类似,那为什么s1和s2引用的是同一个对象,而s3和s4不是呢?

在Java程序中,类似于:1 、2、3.14、" hello " 等字面类型的常量经常频繁使用,为了使程序的运行速度更快、更节省内存,Java为8种基本数据类型和String类都提供了常量池。

“池”是编程中的一种常见的,重要的提升效率的方式,我们会在未来的学习中遇到各种“内存池”,“线程池”,“数据库连接池”....

我来举一个池化技术的示例

比如我们学习编程要看关于编程的书籍

        1. 当我们学习数据库时,我们就要去书柜找关于数据库的书,看完就要放回去。如果接下来我们遇到关于数据库的问题,那我们还要再去书柜找关于数据库的书,这样效率低,速度慢。

        2.我们在书桌上放一个书架,将我们想要学习编程相关书籍放到书架里面,随拿随用,效率高,速度快。

对于池化技术来说,方式2就是池化技术的一种实例,书放书架上,随去随用,效率非常高。

 为了节省存储空间以及程序的运行效率,Java中引入了:

  1. Class文件常量池:每个.java源文件编译后生成.Class文件中会保存当前类中的字面常量以及符号信息
  2. 运行时常量池:在.Class文件被加载时,.Class文件中的常量池被加载到内存中称为运行时常量池,运行时常量池每个类都有一份。
  3. 字符串常量池

 2.字符串常量池(StringTable)

字符串常量在JVM中是StringTable类,实际上是一个固定大小的HashTable,在不同JDK版本下字符串常量池的位置以及默认大小是不同的:

JDK版本字符串常量池位置大小设置
Java6(方法区)永久代固定大小:1009
Java7堆中可设置,没有大小限制,默认大小:60013
Java8堆中可设置,有范围限制,最小是1009

3.深度讲解String对象创建

由于不同JDK版本对字符串常量池的处理方式不同,此处在Java8 HotSpot上分析

1.直接使用字符串常量进行赋值

public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "hello";
        System.out.println(s1 == s2);//true
    
    }

接下我来展示一下,上述代码在内存中的情况。

在内存中,我们可以分为虚拟机栈和堆区,而s1 和 s2 变量在虚拟机中存储,而StringTable哈希表在堆中存储。

对于没有学过哈希表的读者,我们可以把它理解为一个数组,而数组中的每个元素是一个链表。而链表中每个结点又都包含一个hash值和一个String对象。而我们代码中的常量字符串“hello”,就存在String对象所引用的数组存储。是不是有点绕,我们来看下图

 如图,在字节码加载时,“hello”常量串就已经创建好了,并保存在字符串常量池中。当时用String s1 = "hello";创建对象时,先在字符串常量池中找,找到了,就将该字符串引用赋值给s1。同理,对s2的操作也是如此。

2.通过new创建String类对象

public static void main(String[] args) {
        String s3 = new String("hello");
        String s4 = new String("hello");
        System.out.println(s3 == s4);//false
    }

s3和s4都是new了一个对象,也就是在堆上开辟String对象大小的空间,且这两个对象在堆中的存储地址不同, 然后常量池把“hello”添加上,然后把“hello”的值分别存储在s3、s4引用对象的value数组中。

也就是为什么s3==s4为false的原因。

 总结来说:只要是new的对象,都是唯一的。

通过上面例子可以看出:使用常量字符串创建String类型对象的效率更高,而且更节省空间。同时用户也可以将创建的字符串对象通过 intern 方式添加进常量池中。

 3.intern 方法

intern 是一个native方法(native 方法指:底层使用C++实现的,看不到其实现的源代码),该方法的作用是手动将创建的String对象添加到常量池中。

我们看下面两个例子会发现,就是因为少写一句 s1.intern() 结果就变的不一样,这是为什么呢?

 我们一步一步来分析,上述代码中 s1 先在堆区创建一个对象,因为 s1 引用对象存储的 “abc” 是字符数组 ch 拷贝过去的,所以 abc 并没有存入字符串内存池中。而当 执行 String s2 = "abc" 时,内存池变会检测内否存有 “abc”,没有内存池便会把 “abc” 收入其中,同时把在内存池中存储 “abc” 的对象赋值给 s2 。

 

 而当添加 s1.intern() 之后,内存池变会检测“abc”是否在其中存储,如果没有,这会把s1引用的String对象添加到内存池中,如下。当 执行 String s2 = "abc" 时,内存池中检测到“abc”,变会把“abc”的对象赋值给s2。

  同样,如果 s1.intern()  之后,内存池检测到 “abc”,那就不会把 s1 引用String对象添加到内存池中。

 注意:在Java6 和 Java7、8中intern的实现会有些许差别。

我们来看三道面试题,巩固一下

解释String类中两种对象实例化的区别:

 1. String str = "hello";

   只会开辟一块堆内存空间,保存在字符串常量池中,然后 str 共享常量池中的 String 对象。

2. String str = new String("hello");

  会开辟两块堆内存空间,字符串"hello"保存在字符串常量池中,然后用常量池中的 String 对象给新开辟的 String 对象赋值。

3. String str = new String(new char[]{'h','e','l','l','o'})

  现在堆上创建一个 String 对象,然后利用 copyof 将重新开辟数组空间,将参数字符串数组中内容拷贝到 String 对象中。

9.字符串的不可变性

String 是一种不可变对象,字符串中的内容时不可改变的。字符串不可被修改,是因为其中存储字符串的value数组被private修饰,如下图

 对于 value[] 不可修改,是因为有private修饰在类外不能拿取value的值,而不是因为被 final 修饰的原因。

final 修饰类表面该类不想被继承,final修饰内置类型表明该变量不能修改其值。

 而对于引用类型来说,final 修饰引用类型表明该引用变量不能引用其他对象,但是其引用对象中的内容是可以修改的。

 所以,String类不能修改不是其内部value被final修饰的原因。

同时,我们还肯被一下代码所骗,认为String类可以被修改

public static void main(String[] args) {
        String s = "hello";
        s += " world";
        System.out.println(s);// 输出:hello world
    }

这是为什么呢?这串代码并不是代表String类可以修改,当s += " world" 执行后,s引用的就是一个全新的对象,而不是在原理hello这个内存上拼接的。

而且所有涉及到可能修改字符串内容的操作都是创建一个新对象,改变的是新对象

例如 repalce 方法:

 为什么 String 要设计成不可变的呢?

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

那如果想要修改字符串中内容呢?我们接着往下看

10.字符串修改

我们知道,真正修改字符串的内容是很难的,如果我们要修改的话就是要new一个新的对象。

借用上述举的例子

public static void main(String[] args) {
        String s = "hello";
        s += " world";
        System.out.println(s);// 输出:hello world
    }

注意:我们应尽量避免直接对String类型对象进行修改,因为String类是不能修改的,所有的修改都会创建对象,效率会非常低下。

如果要修改的话,建议尽量使用StringBuffer或者StringBuilder,这样效率会高一点

 我们来比较一下 +=  、StringBuffer、 StringBuilder这三种方法修改对象的耗时

public static void main(String[] args) {
        long start = System.currentTimeMillis();
        String s1 = "";
        for(int i = 0; i < 10000; ++i){
            s1 += i;
        } long end = System.currentTimeMillis();
        System.out.println(end - start);

        start = System.currentTimeMillis();
        StringBuffer s2 = new StringBuffer("");
        for(int i = 0; i < 10000; ++i){
            s2.append(i);
        } end = System.currentTimeMillis();
        System.out.println(end - start);

        start = System.currentTimeMillis();
        StringBuilder s3 = new StringBuilder();
        for(int i = 0; i < 10000; ++i){
            s3.append(i);
        } end = System.currentTimeMillis();
        System.out.println(end - start);
    }

可以看出StringBuffer、 StringBuilder方法比用 += 修改效率更高。

因此能不修改就不修改,实在不行尽量使用StringBuffer或者StringBuilder。

到此,String类基本上是讲完了,有错误的地方希望大家能批评指正,别忘了点赞👍+收藏⭐️哦 

      😜  关注我!带来等多精彩🎉🎉

  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

爱躺平的威威

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值