[java篇]一次性帮你搞懂String,StringBuffer,StringBuilder类

最新推荐文章于 2024-09-17 11:50:15 发布
最新推荐文章于 2024-09-17 11:50:15 发布
阅读量1.2k 收藏 50
点赞数 24
分类专栏： Java语法 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54883034/article/details/120602730
版权

前言：在我们学习String这个专题之前，让我们回忆一下，在我们之前学习的C语言中有没有String类型，答案是没有的，在C++和java中都引进了字符串类型，这样让我们在日常处理字符串时，增添了诸多便利。
前期文章：
[java篇]包，继承，组合
[java篇]多态，抽象类，接口
[java篇]图书管理系统，是你的期末大作业吗？

废话不多说，开干！！！

文章目录

1.认识String类

让我们先看看String类到底是个啥？
在我们学习java语法的时候，我们不可能把所有的java语法都记得非常清楚，所以我们就提供了一个专门查阅有关java学习的API文档。
在这里插入图片描述

1.String类型，在java.lang包下，在我们使用String类型的时候，不用手动导包，系统会自行导包。
2.String类型被final修饰，表示这个类型不可更改,这个类不能被继承，String类属于一个密封类。
3.String类型继承了Object类型
4.String类型实现了Comparator接口(在前期文章介绍过)，CharSxequence接口，Serializable接口。

当我们要学习一个类型的时候，首先要了解它的构造方法，这样我们在之后的学习中才会如鱼得水。
在这里插入图片描述
我了个去，这这这，怎么这么多呢？这要学到什么时候。
其实我们常用的一共就是用两种构造方法，上面的构造方法我们知道即可。

1.String str = "hello world";
2.String str1 = new String("hello world");

创建字符串

我们在创建字符串的时候一般有两种方法：

直接赋值，即String str = “hello world”;
另一种是利用构造方法：String str = new String(“abc”);在括号里面的字符串，被存储到new出的对象里面的value数组 。

字符串常量池

字符串常量池是利用哈希表实现的，所以在常量池中不允许出现相同的字符串，String类型，采用共享模式，如果两个变量所指向的字符串相等，那么在字符串常量池中只会保留一份字符串，让两个变量同时指向这个字符串。
其实在jvm中没有划分这个区域的。
来分析一下代码：

     public static void main(String[] args) {
        String str = "123";
        String str1 = "123";
        System.out.println(str == str1);
    }

这个应该很好判断吧，但是你是不是按这个思路想的呢？
请看内存图：
在这里插入图片描述
他们比较的是两个引用是否相等，str和str1的字符串内容都是hello 所以只能在字符串常量池中存储一份"hello",而String类型又具有共享模式，所以两个引用同时都指向一块内存空间。

构造方法下字符串在堆中的存储

String str = new String(abc);
str作为一个引用，它引用了一个对象，这个对象里面有一个value数组，这个数组指向的就是添加进来的字符串。
在这里插入图片描述
利用构造方法赋值的缺点：
在堆中必须要开辟两块内存空间，并且在有一份会成为垃圾空间。
同一个字符串可能被存放多次，浪费空间。

请简述String类型两种赋值的区别：
第一种：直接赋值：在堆中开辟了一块内存空间，并且传入的字符串会自动的保存在字符串常量池中。
第二种：利用构造方法进行赋值，在堆中会开辟两块内存空间，并且传入的字符串不会入池，必须通过intern()方法，手动入池。

案例分析：

请大家阅读以下代码，并回答true or false

案例一：
    public static void main1(String[] args) {
        String str1 = "hello world";
        String str2 = new String("hello world");
        System.out.println(str1 == str2);//false
    }

大家先根据题目做出解答哦，以下会具体分析

单眼一看，这有什么难得，不就是比较吧，这不两个字符串相等，不就是true嘛。
哈哈哈，上当了吧，答案是false，其实它们比较的是是两个字符串的引用，这个引用就相当于与我们在C语言阶段学习的指针一样，当时java里面没有指针哦，这个引用也没有C/C++里面的指针那么的灵活。
str1作为一个引用，在栈帧里面开辟空间，而赋予str的值，是在堆上存放的
str2作为一个引用，它引用了一个String类型的对象，而这个引用在栈上开辟空间，对象被存放在堆上。

看图说话：
分析：

  1. str1直接赋值，把"hello world"这个字符串传给了str1,在堆中，凡是被双引号引起来的常量，都会存放在字符串常量池中。
  2. str2是一个引用，他指向了一个对象，在对象里边存在一个value数组，这个数组又引用了对象里边存放的值，即对象里面的value数组引用了"hello world"这个字符串，又因为这个字符串要存放到字符串常量池中去，而在此之前池中已经有了"hello world"这个字符串并且在前文中说道字符串常量池是由哈希表构成的，所以这个对象就指向字符串常量池中已有的字符串常量。

在这里插入图片描述

案例二：

请看下一段代码：

 public static void main(String[] args) {
        String str1 = "hello world";
        String str2 = "hello " + "world";
        System.out.println(str1 == str2);
    }

答案是 true
为什么呢？
因为字符串常量在编译阶段就已经实现了连接，即"hello " + “world” 变成了"hello world",又因为在执行str2这段代码时，在堆中的字符常量池中已经有了"hello world"这个字符串，当str2指向的这个已经连接好的字符串将要存放到池中的时候，先要检查池中是否已经有了将要存放的字符串，如果有的话，str2就指向这个已有的字符串。
不信的话，那么我们就反编译一下，看是否在编译的时候已经实现了拼接。
在这里插入图片描述
看图说话：
常量在编译的过程中，就已经被运算了。
在这里插入图片描述

案例三：

请阅读一下代码：

 public static void main(String[] args) {
        String str1 = "hello world";
        String str2 = "hello " + new String("world");
        System.out.println(str1 == str2);
    }

答案是false
为什么呢？

因为当str2这段代码执行的过程中引用了一个String对象，这个对象指向存放在字符串常量池中放入字符串"world",而这个被String对象所引用的字符串"world"要和在池中的"hello"实现拼接，形成了一个新的对象，至于拼接的过程这就牵连到了StringBuffer/StringBuilder知识点，我们在文章后半段介绍，而这个str3指向了这个新的对象，自然和str1所指向的"hello world"所在的地址不相同。

看图说话：
在这里插入图片描述

案例四：

请阅读以下代码：

 public static void main(String[] args) {
        String str1 = "hello world";
        String str2 = "hello ";
        String str3 = str2 + "world";
        System.out.println(str1 == str3);
    }

答案是：false
为什么呢？

因为当我们执行到了str3这句代码时，str2变成了变量，那么让我们回忆一下，变量的概念是什么，所谓变量就是在编译的时候不知道变量里边是什么值，只有在运行的时候才知道里面是什么值。在字符串拼接的过程中，会形成一个新的对象，str3就指向这个对象,str1指向的是一个字符串，显然他们指向的不是同一块地址，所以是false.

看图说话：
在这里插入图片描述

案例五：

请阅读一下代码：

 public static void main(String[] args) {
        String str1 = "hello world";
        String str2 = new String("hello ") + new String("world");
        System.out.println(str1 == str2);
    }

当大家做到这个题的时候，就很容以判断出，答案肯定是false,因为str1和str2所指向的不是同一块地址。

看图说话：
在这里插入图片描述

案例六：

请阅读一下代码：

  public static void main(String[] args) {
        String str1 = "hello world";
        String str2 = new String("hello world");
        str2.intern();
        System.out.println(str1 == str2);
    }

答案是：false

在这里就不得不介绍 intern()方法 了，这个方法的作用是把一个字符串手动填入字符串常量池。
我们已知str2作为一个引用，它引用了一个String对象，在这个对象里面有一个value数组，这个value数组又引用了一个字符串，这个字符串"hello world"已经在字符串常量池中已经有了，即使手动的填入这个已有的字符串也是不行的，就是也为字符串常量池是由哈希表实现的，在哈希表中，不允许有重复的值出现。所以str2.intern(),这段代码，存不存在代码的结果都是一样的，等于它啥也没干。

看图说话：
它的内存图和案例一一样，在这里就不过多赘述。

案例七：

请阅读一下代码：

     public static void main(String[] args) {
        String str1 = new String("1") + new String("1");
        str1.intern();
        String str2 = "11";
        System.out.println(str1 == str2);
    }

答案是:true
为什么呢？

分析：
两个对象所指向的字符串都是"1"，当两个字符串拼接之后形成了新的字符串"11",然后手动的添加到字符串常量池中，当代码执行到str2这句代码时，它所指向的字符串"11"，在池中已经有了，所以无需添加，这时候str2指向被拼接好的字符串"11",假设这时候字符串"11"的地址为0x123，那么指向它的对象这时候的地址也是0x123,所以str1和 str2的的地址相同

看图说话：
在这里插入图片描述

案例八：

请阅读一下代码：

     public static void main(String[] args) {
        String str1 = new String("1") + new String("1");
        String str2 = "11";
        str1.intern();
        System.out.println(str1 == str2);
    }

答案是：false
为什么呢？

因为两个对象拼接好的字符串"11"，然后str2指向字符串"11"，而现在的字符串常量池中里的字符串"11"是str2这个引用指向的，现在手动的把拼接好的字符串手动添加到字符串常量池中，但是已经有了这个字符，所以手动添加不了
str1指向的是一个字符串，str2指向了一个被引用的对象，他们的引用不相同，所以是false.

在这里插入图片描述

案例九：

请看一下代码：

  public static void func(String str) {
        str = "bit";
    }
    public static void main(String[] args) {
        String str = "gaobo";
        func(str);
        System.out.println(str);
    }

答案是: gaobo
为什么呢？

因为我们这里的main方法中的str指向的是一个被存放到堆区中的字符串常量池中的字符串，而我们向func方法中传去的是一个str引用，起初func方法中的str引用和main方法中的str引用同时指向同一块地址，但是在func方法中str这个引用指向了一个新的地址(即在堆区的字符串常量池中的"bit"的地址)，所以两个不是指向的是一块地址，所以他们不相同。依据上述的代码我们可以知道最后打印的结果为"gaobo".

看图说话：
在这里插入图片描述

案例十：

请看一下代码：

public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = str1;
        str1 = "world";
        System.out.println(str1 == str2);
    }

答案是：false
为什么呢？

这个思路和上一个题的思路基本一致，str1是一个引用，这个引用指向堆区中的字符串常量池中的"Hello"，str2引用了str1所引用的对象(即字符串"Hello")所以起初两个引用指向同一块地址，但是str1这个引用又指向了一块新的地址(即"world"所在的地址空间)，所以在比较两个引用的时候肯定不相等。

看图说话：
在这里插入图片描述

正确理解==和equal的区别

  1. 双等于比较的是两个字符串引用是否相等，即他们所指向的地址是否相等
  2. equal是比较两个字符串中的内容是否相同。

equal方法的使用：

     public static void main(String[] args) {
        String str1 = "hello world";
        String str2 = "hello world";
        System.out.println(str1.equals(str2));
    }

两个字符串内容相同，返回true,否则返回false.但是如果有一个字符串为空，那也只能这样写了。

   public static void main(String[] args) {
        String str1 = null;
        String str2 = "hello world";
        System.out.println(str2.equals(str1));
        //System.out.println("hello world".equal(str1));最好写成这样
    }

因为如果把str1放到了equal()方法之前比较,就会发生空指针异常
在这里插入图片描述

理解字符串不可变：

我们在文章前面也看到可String.java的源码，知道了String这个类(被final修饰)是一个密封类，不能被继承，同时String所引用的对象也不能被修改。
字符串是一种不可变的对象，它的内容不可修改
让我们看一下下面的代码：

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

表面上看去，就直接在把要加的字符串添加到原来的字符串后面就好了，但是不是那样的。

请详细看他的内存图：
在这里插入图片描述
在字符串常量池中的字符串，在拼接时，每拼接一次就会产生一个新的对象，当代码执行到str = str + "world"时，str相当于一个变量，变量和字符串拼接需要在堆中重新开辟一块新的内存空间，而这个内存空间中的value数组就会指向拼接好的字符串"hello world"，在拼接"!!!“的时候也是一样的，还需要开辟一个新的内存空间，在新的内存空间中的value数组就会指向拼接好的"hello world!!!”,在这是str这个引用指向拼接好的字符串。
大家可以想一想，如果不断地这样两个是不是就会造成空间浪费。只为得到最后一个拼接好的字符串，那么为了拼接好的这个字符串，那么在这个拼接好的字符串后面是不是有着许许多多的字符串为了拼接所开辟的内空间，使堆区的闲余空间减少，当我们介绍到了StringBuffer/StringBuilder的时候就不用这样拼接一次开辟一次空间了，就直接在原字符串的末尾拼接。
这样也体现出了字符串的不可变，不能在同一个字符串上修改。

那么如果我们实在要对字符串进行修改呢？
详细请看一下代码：

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

在这里就先介绍一下substring()方法，它的作用是对字符串进行截取，根据下标，截取这个下标，这个下标之后所对应字符串中的所用元素。
在上述代码中就是截取了"hello",1下标之后的所有字符串(“ello”),然后与字符串"h"进行拼接，但是这样也不是在字符串"h"之后直接拼接的，还是需要在堆中重新开辟一块空间，这个空间中的value数组又指向了拼接好的"hello"字符串。

那么我们真的想在原字符串中，做出修改呢，那就必须简单的介绍一下反射了(这里是简单介绍)

反射是面向对象编程的一种重要特性，在有些语言中被称为"自省"
反射的特性：反射是在程序运行的过程中，获取修改某个对象的具体信息(成员属性，成员方法)，相当于让对象更好的认识自己。

那我们现在就利用反射的特性对字符串做出修改。
在这里插入图片描述
我们可以从String类的源码中看到String所引用的字段，是不可被修改的，并且这个字段在类中是私有属性。

      String str = "hello world";
     // 获取字节码对象
        Class c = String.class;
        //获取String类中的value字段
        Field field = c.getDeclaredField("value");
       //修改字符串的权限，使其权限变为true
        field.setAccessible(true);
       //获取str中的val
        char[] vals = (char[]) field.get(str);
       //对字符串进行修改
        vals[0] = 'H';
        System.out.println(vals);

运行结果：Hello world
并且是在原有的字符串上进行修改，没有重新开辟新的空间。

2.字符，字节，字符串

字符和字符串

一.字符与字符串
字符串内部包含一个和字符串一样的char[]数组，字符串可以和字符进行相互转化。

No方法名称类型描述
1public String(char[]chars)构造方法将字符转换成为字符串
2public String(char[] chars,int offest,int count)构造方法offest表示偏移位置，count表示偏移量，把字符数组中从offest之后偏移count个字符转变为字符串
3public charAt(int index)普通方法index表示下标，在字符串中找到对应下标的字符
4public toCharArray(String str)普通方法将字符串转变为字符数组

方法一：
将字符转换成为字符串

     public static void main(String[] args) {
        char[] array = {'a', 'b', 'c', 'd'};
        String str = new String(array);
        System.out.println(str);
    }
    //运行结果：abcd

方法二：
从偏移点出发，把偏移量个字符转变成为字符串

 public static void main(String[] args) {
        char[] chars = {'a','b','c','d','e','f'};
        String str = new String(chars,2,3);
        System.out.println(str);
    }
    //运行结果:cd

方法三：
在字符串中找到下标为i的字符

 public static void main(String[] args) {
        String str = "abcdefg";
        char ch = str.charAt(5);
        System.out.println(ch);
    }
    //找到下标为5的字符
    //运行结果为:f

方法四：
将字符串转换成为字符数组

  public static void main(String[] args) {
        String str = "abcdef";
        char []chars = str.toCharArray();
        System.out.println(Arrays.toString(chars));
    }
    //运行结果：[a,b,c,d,e,f]

方法小练：
判断一个字符串中是不是全是数字？
已知字符串为"158946a9";

   public static boolean isNUmber(String str){
        if(str.length() == 0){ //判断传来的字符串是不是长度为0
            return false;
        }
        if(str == null){ //判断传来的字符串是不是为null
         return false;
        }
        for(int i = 0;i<str.length();i++){
            if(str.charAt(i)>'9' || str.charAt(i) < '0'){
                return false;
            }
        }
        return true;
    }
    public static void main(String[] args) {
        String str = "158946a9";
        System.out.println(isNUmber(str));
    }
    //运行结果false

字节与字符串：

字节常用于数据传输和编码转化，String也可以和字节之间进行相互转化

NO方法名称类型描述
1public String(Byte[] byte)构造方法将字节数组转换成为字符串
2pubic String(Byte[] byte,int offest,int count)构造方法从字节数组的offest的偏移点到count个字节元素转换成为字符串
3public byte[] getBytes(String str)普通方法将字符串中的所有字符转换成为字节数组
4public byte[] getBytes(String CharsetName)trows unspportedEncodingException普通方法编码处理

方法一：
将字节数组转换成为字符串

    public static void main(String[] args) {
        byte []bytes = {97,98,99,100};
        String str = new String(bytes);
        System.out.println(str);
    }
    //运行结果：abcd

方法二：
从字节数组的offest的偏移点到count个字节元素转换成为字符串

  public static void main(String[] args) {
        byte[]bytes = {97,98,99,100,101,102};
        String str = new String(bytes,1,3);
        System.out.println(str);
    }
    //运行结果：bcd

方法三：
将字符串中的所有字符转换成为字节数组

     public static void main(String[] args) {
        String str = "abcdef";
        byte[]bytes = str.getBytes();
        System.out.println(Arrays.toString(bytes));
    }
    //运行结果：[977,98,99,100,101,102]

方法四：
编码处理
1.UTF-8编码：

     public static void main(String[] args) java.io.UnsupportedEncodingException{
        String str = "abcde高";
        byte[]bytes = str.getBytes("UTF-8");
        System.out.println(Arrays.toString(bytes));
    }
    //运行结果：[97, 98, 99, 100, 101, -23, -85, -104]
    //在这里是UTF-8编码，我们不知道他把汉字编译成了什么

2.GBK编码：

     public static void main(String[] args)throws java.io.UnsupportedEncodingException {
        String str = "abcde高";
        byte[]bytes = str.getBytes("GBK");
        System.out.println(Arrays.toString(bytes));
    }
    //运行结果:[97, 98, 99, 100, 101, -72, -33]

所以在UTF-8编码和GBK编码之后字符数组的结果不同。

分析在什么的情况下使用字符数组，在那种场合使用字节数组

  1. byte[] 是把 String 按照一个字节一个字节的方式处理, 这种适合在网络输, 数据存储这样的场景下使用. 更适合针对二进制数据来操作.
  2. char[] 是吧 String 按照一个字符一个字符的方式处理, 更适合针对文本数据来操作, 尤其是包含中文的时候

3.字符串常见操作：

字符串比较：

我们在之前介绍的是字符串比较函数equal(),它区分字符的大小写，在这里我们将具体的介绍有关字符串比较的方法

NO方法介绍类型作用
1public boolean equal(String str)普通方法比较字符串(区分大小写)
2public boolean equalIgnoreCase(String str)普通方法比较字符串是否相等(不区分大小写)
3public int compareTo(String str)普通方法比较字符串大小如果一个字符串比另一个字符串大就返回正数，否则返回负数，相等的时候返回0

方法一：
比较字符串(区分大小写)

    public static void main(String[] args) {
        String str = "hello";
        String str1 = "Hello";
        System.out.println(str.equals(str1));
    }
    //运行结果：false

方法二：
比较字符串是否相等(不区分大小写)

     public static void main(String[] args) {
        String str = "hello";
        String str1 = "Hello";
        System.out.println(str.equalsIgnoreCase(str1));
    }
    //返回true

方法三：
比较字符串大小如果一个字符串比另一个字符串大就返回正数，否则返回负数，相等的时候返回0

 public static void main12(String[] args) {
        String str = "hello";
        String str1 = "Hello";
        System.out.println(str.compareTo(str1));
    }
    //运行结果 32

   public static void main(String[] args) {
        String str = "abcdef";
        String str1 = "abc";
        System.out.println(str.compareTo(str1));
    }
    //运行结果 3

不知道大家发现了没有，如果字符串的长度相等，compareTo()方法返回的是字符的ASII码的差值，当字符串长度不相等时它返回的是他们的长度之差。
那么让我们看一下compareTo()方法的源码
在这里插入图片描述

字符串拆分：

可以根据一个字符串，以特定的字符进行分割。成为若干份子字符串。

No方法名称类型作用
1public String split(String regex)普通分割字符串
2public String split(String regex,int limit)普通分割字符串，limit表示分割组数的极限值

方法一：
分割字符串

     public static void main(String[] args) {
        String str = "a b c d e f";
        String str1 = " ";
        String[]strings = str.split(str1);
        for (String s:strings) {
            System.out.println(s);
        }
    }
    //运行结果
    //a
    //b
    //c
    //d
    //e
    //f

方法二：
分割字符串，limit表示分割组数的极限值

     public static void main(String[] args) {
        String str = "a b c d e f";
        String str1 = " ";
        String[]strings = str.split(2);
        for (String s:strings) {
            System.out.println(s);
        }
    }
    //运行结果：
    //a
    //b c d e f

那当我们要对一个IP地址进行分割，还能和上边的一样吗？
都这样问了肯定是不会的啦！！！

 public static void main(String[] args) {
        String str = "19.15.5.4";
        String []strings = str.split("\\.");//如果不添加转义字符，打印的结果有误
        for (String s:strings) {
            System.out.println(s);
        }
    }
    //运行结果为：
    //19
    //15
    //5
    //4

注意事项：
当分割符为**"+","*","|“都要在前面加上转移字符”/";**
如果是""，就在前面加上"//";
如果有多个分割符就要用"|"分开。

字符串中有多个分割符

     public static void main(String[] args) {
        String str = "19&18%14#13";
        String []strings = str.split("&|%|#");
        for (String s:strings) {
            System.out.println(s);
        }
    }

实现多组分割：

   public static void main(String[] args) {
        String str = "18#15#16&11&100";
        String []strings = str.split("#");
        for(String s1 : strings){
            String []s =  s1.split("&");
             for(String ss: s){
                 System.out.println(ss);
             }
        }
    }
    //运行结果：
    //18
    //15
    //16
    //11
    //100

字符串替换：

使用一个特定新的字符串来替换里一个字符串。

No方法名称类型作用
1public String replace(String regex,String replacement)普通替换字符串
2public String replaceAll( String regex,String replacement)普通替换字符串中的所用特定的字符串
3public String replaceFirst(String regex,String replacement)普通替换首个内容

方法一：
替换字符串

     public static void main(String[] args) {
        String str = "a b c d ";
        String str1 = str.replace(" ","1");
        System.out.println(str1);
    }
    //运行结果a1b1c1d1

方法二：

     public static void main(String[] args) {
        String str = "a b c d ";
        String str1 = str.replaceAll(" ","1");
        System.out.println(str1);
    }
    //方法一和方法二执行的结果相同

方法三：
替换首个内容

     public static void main(String[] args) {
        String str = "a b c d e";
        String str1 = str.replaceFirst(" ","1");
        System.out.println(str1);
    }
    //运行结果:a1b c d e

字符串查找：

从一个完整的字符串当中，判断指定内容是否存在。

No方法名称类型作用
1public boolean contains( CharSequence str)普通方法在一个字符串中查找另一个字符串
2public int indexOf(String str)普通方法在一个字符串中查找一个字符串，找到了就返回它的下标，如果没有找到就返回-1
3public int indexOf(String str,int fromIndex)普通方法从指定位置开始查找字符串，找到返回索引，找不到返回-1
4public int lastIndexOf(String str)普通方法从后向前查找指定字符串
5public int lastIndexOf(String str,int formIndex)普通方法从指定位置从后向前查找字符串
6public boolean startsWith(String prefix)普通方法看是否已指定字符串开头
7public boolean startWith(String prefix,int formIndex)普通方法从指定的位置开始判断是否已特定的字符串开头
8public boolean endsWith(String suffix)普通方法看是否以特定的字符串结尾

方法一：
在一个字符串中查找另一个字符串

  public static void main(String[] args) {
        String str = "abcdef";
        String str1 = "ab";
        System.out.println(str.contains(str1));
    }
   //运行结果：true

方法二：
在一个字符串中查找一个字符串，找到了就返回它的下标，如果没有找到就返回-1

     public static void main(String[] args) {
        String str = "ancdef";
        String srr1 = "cd";
        System.out.println(str.indexOf(srr1));
    }
    //运行结果：2

方法三：
从指定位置开始查找字符串，找到返回索引，找不到返回-1

     public static void main(String[] args) {
        String str = "decfgh";
        String str1 = "de";
        System.out.println(str.indexOf(str1,2));
    }
    //运行结果：-1

方法四：
从后向前查找指定字符串

     public static void main(String[] args) {
        String str = "abndefg";
        String str1 = "nd";
        System.out.println(str.lastIndexOf(str1));
    }
    //运行结果：2

方法五：
从指定位置从后向前查找字符串

     public static void main(String[] args) {
        String str = "ababrag";
        String str1 = "ab";
        System.out.println(str.lastIndexOf(str1,2));
    }
    //运行结果：2

方法六：
看是否已指定字符串开头

     public static void main(String[] args) {
        String str = "abcdefgt";
        String str1 = "abc";
        System.out.println(str.startsWith(str1));
    }
    //运行结果：true

方法七：
从指定的位置开始判断是否已特定的字符串开头

     public static void main(String[] args) {
        String str = "abcdef";
        String str1 = "a";
        System.out.println(str.startsWith(str1,1));
    }
    //运行结果：false

方法八：
看是否以特定的字符串结尾

     public static void main(String[] args) {
        String str = "abcde";
        String str1 = "de";
        System.out.println(str.endsWith(str1));
    }
    //运行结果：true

字符串截取：

截取字符串中的一部分。

No方法名称类型作用
1public String subString(int index)普通从index处截取字符串
2public String subString(int index,int count)普通截取index和count之间的字符串，注意前闭后开区间

方法一：
从index处截取字符串

 public static void main(String[] args) {
        String str = "abcdef";
        String str1 = str.substring(2);
        System.out.println(str1);
    }
    //运行结果cdef

方法二：
截取index和count之间的字符串

     public static void main(String[] args) {
        String str = "abcdef";
        String str1 = str.substring(2,5);
        System.out.println(str1);
    }
    //运行结果：cde注意是[2,5)

其他操作方法：

No方法名称类型作用
1public String trim()普通去除字符串的左右空格，中间空格不变
2public String toUpperCase()普通把字符串中的字符全部变为大写
3public String toLowerCase()普通把字符串中的字符全部变为小写
4public native iterm()普通把字符串入池
5public String concat(String str)普通字符串连接，类似于"+"
6public int length()普通计算字符串的长度
7public boolean IsEmpty()普通判断当前字符串是否为空

**这下方法博主就不一一介绍了，大家自己在idea上独自完成。每个方法的具体功能已经说得很清楚。**在我们之后写代码的过程中也会时常用到。

4.String，StringBuilder和StringBuffer之间的区别：

我们知道了String 是用来描述字符串的，并且String 类型的变量指向的内容是不能修改的，虽然这样会使程序变得安全，但是为我们在平时利用字符串解题时带来了诸多不便，在这是就衍生出了两个StringBuilder和StringBuffer关键字，这两个关键字所修饰的是可以字符串改变的.并且StringBuilder和StringBuffer的方法基本相同。
我们知道String类型定义变量的方法有两种，一种是直接赋值即(String str = “abc”),另一种是new一个对象，这个对象中的value数组指向要添加进来的字符串即(String str = new String(“abc”));但是在StringBuffer和StringBuilder中就只有一种赋值方法，就是进行构造。

StringBuffer sb = new StringBuffer("abc");
我们知道在String中连接字符串的时候会在堆上产生一个新的对象，这个对象中的value数组指向拼接好的字符串。然而在被StringBuffer和StringBuilder所修饰的时候，如果要拼接字符串，那么直接就在一个字符串的末尾直接添加。不会产生新的对象，这样就不会利用更多的空间去申请对象，耗费空间。
在StringBuffer和StringBuider中用来拼接字符串的方法时append()方法
这里就利用StringBuffer介绍一下，为什么被他修饰字符串就可以改变呢？
我们一起康康它的源码：
在这里插入图片描述
我们可以看到在append()方法所对应的源码中，最后返回的是this.即当前的对象，所以我们就不用在对上重复的申请空间了。

请看一下代码

     public static void main(String[] args) {
        String str = new String("abc");
        for(int i = 0;i<10;i++){
            str += i;
        }
        System.out.println(str);
    }

请看源码：
在这里插入图片描述
虽然StringBuilder在这里实现了优化，但是我们每次循环，都要new一个对象，所以我们以后千万不要这样写代码。
String和StringBuilder,StringBuffer之间的相互转化

Stringhe StringBuilder,Stringbuffer之间不能进行直接转化，
String变为StringBuffer:利用StringBuffer的构造方法或append()方法
StringBuffer变为String:调用toString()方法。

 public static void main(String[] args) {
        //String变成StringBuffer
        String str = "hello";
        StringBuffer stringBuffer = new StringBuffer(str);
        //StringBuffer stringBuffer = new StringBuffer();
        //String str1 = stringBuffer.append(str);
        System.out.println(stringBuffer);
        System.out.println(str1);
        //运行结果为hello
    }

     public static void main(String[] args) {
        //StringBuffer变为String
        StringBuffer stringBuffer = new StringBuffer("abc");
        String str = stringBuffer.toString();
        System.out.println(str);
    }

除了append()方法外，StringBuffer也有一些String没有的方法，比如字符串翻转`。

     public static void main(String[] args) {
        StringBuffer stringBuffer = new StringBuffer();
        StringBuffer str = stringBuffer.append("abcdef");
        StringBuffer str1 = str.reverse();
        System.out.println(str1);
        //运行结果为fedcba
    }

规定字符串删除

     public static void main(String[] args) {
        StringBuffer stringBuffer = new StringBuffer();
        StringBuffer str = stringBuffer.append("abcdef");
        //删除规定字符串
        StringBuffer str1 = str.delete(2,4);
        System.out.println(str1);
    }
    //运行结果aef

向字符串中插入字符

 public static void main(String[] args) {
        StringBuffer stringBuffer = new StringBuffer();
        StringBuffer str = stringBuffer.append("abcd");
        StringBuffer str1 = str.insert(2,"dd");
        System.out.println(str1);
    }
    //运行结果为abddcd

快接近尾声了，那今天就利用一道经典的面试题来结束今天的博客吧！！

面试题：String,StringBuffer,StringBuilder之间的差别
String修饰的字符串，不能被修改，而被StringBuffer和StringBuilder修饰的符串是可以进行修改的。
StringBuffer和StringBuilder之间的比较：StringBuffer采用同步处理，属于线程安全操作；而StringBuilder未采用同步处理，属于线程不安全操作
StringBuffer和StringBuilder所利用的大部分方法基本相同。
让我们分别看一下StringBuffer和StringBuilder的源码！！
StringBuffer的源码：在这里插入图片描述
StringBuilder的源码：
在这里插入图片描述
我们可以从StringBuffer和StringBuilder的源码比较可以看出，关于StringBuffer的方法，都被synchronized所修饰
那么我们就知道了synchronized的作用是什么了，他就是保证线程的安全。
StringBuffer一般用于多线程，StringBuilder一般用于单线程。
那有些童鞋就会问什么是线程安全，什么又是线程不安全呢？
博主在这里举一个尴尬但是有助于理解的例子。

如果你在上厕所，厕所门外面有着一群人都等着你，大家都要上厕所，如果你没有一把锁把门锁住，大家蜂拥的挤向厕所，正在如厕的你，不是就尴尬了吗，而这个锁就是synchronized

在这里插入图片描述

小周学编程~~~
关注
专栏目录
Java中高级面试题总览(一)
击水三千里的专栏
03-29 2万+
高频面试题深入剖析
学习Java语法糖这一篇就够了（详细版）
m0_54850825的博客
05-20 1033
不知道有多少人针对于java语法是死记硬背的，读完这一篇，让你真正的去理解每一个语法，理解完之后会发现你的技术层次又提高了一个等级。 文章当中泛型、自动装箱拆箱、字符串相加 这三个相对来说写的内容比较多，原因是我写这篇文章的时候，不仅仅想的是 要知道语言背后的转换，而且还想要知道为什么这么做。其次文章当中很多内容都是面试经常会问的。 本篇当中一共记录了十五个Java语法糖，相对来说比较全了，欢迎大家点赞收藏！ 目录 一、语法糖是什么？ 二、jad反编译工具 三、变长参数 四、枚举 五、泛型 5
Java常用类：7000字一次性帮你总结好啦！
磊哥聊Java
05-26 166
来源：cnblogs.com/lwtyyds/p/15678152.html常用类概述内部类内部类的分类：1.成员内部类（非静态内部类）2.局部内部类4.匿名内部类Object类Object类常用方法：1.equals方法2.hashCode方法3.toString方法4.finzlize方法包装类「1.基本数据类型以及对应的包装类：」「2.包装类的意义：」3.包装类常用...
Java常用类：7000+字一次性帮你总结好啦
MCO_CTO的博客
08-01 116
万变不离其宗，Java的其他类和功能，都离不开这些基础。牢记基础，成长的更稳！
Java常用类：7000+字一次性帮你总结好啦！
m0_73493267的博客
09-05 73
内部类Object类包装类数学类时间类字符串String Builder和StringBuffer。
Java常用类，7000+字一次性帮你总结好啦！
欢迎关注公众号：【码农突围】，回复9999，可以获取一份LeetCode刷题笔记
05-23 106
点击上方“码农突围”，马上关注这里是码农充电第一站，回复“666”，获取一份专属大礼包 真爱，请设置“星标”或点个“在看”来源：cnblogs.com/lwtyyds/p/15678152.html常用类概述内部类内部类的分类：1.成员内部类（非静态内部类）2.局部内部类4.匿名内部类Object类Object类常用方法：1.equals方法2.hashCode方法3.t...
30个要点帮你完成java代码优化
m0_67659981的博客
03-31 1823
通过java代码规范来优化程序，优化内存使用情况，防止内存泄露 可供程序利用的资源（内存、CPU时间、网络带宽等）是有限的，优化的目的就是让程序用尽可能少的资源完成预定的任务。优化通常包含两方面的内容：减小代码的体积，提高代码的运行效率。本文讨论的主要是如何提高代码的效率。 在Java程序中，性能问题的大部分原因并不在于Java语言，而是在于程序本身。养成好的代码编写习惯非常重要，比如正确地、巧妙地运用java.lang.String类和java.util.Vector类，它能够显著地提高程序的性能。下面
Java面试题汇总（一）
m0_67322837的博客
03-14 727
本文分为十九个模块，分别是：Java 基础、容器、多线程、反射、对象拷贝、Java Web 、异常、网络、设计模式、Spring/Spring MVC、Spring Boot/Spring Cloud、Hibernate、MyBatis、RabbitMQ、Kafka、Zookeeper、MySQL、Redis、JVM，如下图所示： 共包含 208 道面试题，本文的宗旨是为读者朋友们整理一份详实而又权威的面试清单，下面一起进入主题吧。 Java 基础 1. JDK 和 JRE 有什么区...
java面试题-基础篇(万字总结，带答案，面试官问烂，跳槽必备)
m0_67393342的博客
06-24 694
序号内容链接地址1Java基础篇（点击跳转）java面试宝典-基础篇2Java集合框架篇（点击跳转）java面试宝典-集合框架篇3Java多线程篇（点击跳转）java面试宝典- 多线程篇4JVM篇待分享5Spring篇待分享6Mybatis篇待分享7SpringcCloud篇待分享8Redis篇待分享9Mysql篇待分享10dubbo篇待分享11zookeeper篇待分享12kafka篇待分享13RocketMq篇待分享14Nacos篇待分享优点： 性能比面向对象高，因为类调用时需要实例化，开销比较大，比较
Java-网络
2301_81543552的博客
09-14 705
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
Android Studio 2024与2022 解决Read timed out和connect timed out的问题
2301_80035882的博客
09-14 626
如果在新建Android项目时报错：Read timed out或者connect timed out。
自动生成不重复的订单id
ClaireCheney的博客
09-13 286
【代码】自动生成不重复的订单id。
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1148
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Java项目: 基于SpringBoot+mybatis+maven课程答疑系统(含源码+数据库+毕业论文)
weixin_43860634的博客
09-14 725
Java项目: 基于SpringBoot+mybatis+maven课程答疑系统(含源码+数据库+毕业论文)
记录开发一个英语听力训练网站
业余程序员Blue的博客
09-14 657
目前只导入了雅思历年真题的听力音频，作为我日常练习英语听力的素材足够了。网站的主要功能其实就是英语句子精听，核心目的就是反复听每一句话，直到听懂为止，我觉得听力训练也没有太多技巧可言，就是老老实实地坚持去听，所谓网上经常说的“磨耳朵”吧。基于此，听力页面主要功能有：播放/暂停、上一句/下一句、播放次数选择、播放倍速选择、字体大小选择、是否显示原文、是否显示译文、是否自动播放下一句。而这些功能，基本上都是页面js操作。
Gradle
xiaocaij_icai的博客
09-15 195
");
Java8的Optional简介
最新发布
duke_ding2的博客
09-17 529
Java8的Optional简介
Java wrapperr打包springboot项目到linux和Windows
欢迎查阅
09-14 976
测试启动就是点击App.bat 就会有信息的输出 installApp就是注册为一个windows上的一个服务。上图文件复制的地方 全部复制过去 保留自己需要的 然后去掉后缀.in。下载：linux的目前免费的 windows 64位的好像收费的。前提： 一定要有Java环境（我使用的是jdk1.8）解压的目录，然后我们新建自己的项目目录java-jsw。前面是你解压的原文件 后边是你自己建的目录路径。步骤和上面的一样 不过复制的文件不一样。下载一个社区版本的应该就够用了。需要注意的点 有Java环境。
Java中String、StringBuffer、StringBuilder性能对比分析
"Java中的String、StringBuffer和StringBuilder类在创建和操作字符串对象时具有不同的性能表现。String是不可变的，适合字符串不常变的场景；StringBuffer是线程安全的可变字符串，适用于多线程环境；StringBuilder...
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小周学编程~~~

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

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

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

打赏作者

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

抵扣说明：

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

余额充值