String类（1）

❤️❤️前言~🥳🎉🎉🎉

hellohello~，大家好💕💕，这里是E绵绵呀✋✋ ，如果觉得这篇文章还不错的话还请点赞❤️❤️收藏💞 💞 关注💥💥，如果发现这篇文章有问题的话，欢迎各位评论留言指正，大家一起加油！一起chin up！👍👍

💥个人主页：E绵绵的博客**
💥所属专栏：JAVASE题目练习 JAVASE知识点专栏 c语言知识点专栏 c语言题目练习**
该篇讲String主要是讲如何去使用String，所以比较简单，对于牵涉到String本质的真正很难的那部分我们到了数据结构再讲。

那么开始出发吧👊👊

String类的认识

❤️❤️对于String这个类型，我们以前往往认为它是一个简单的基本类型，但我们错了，对于String，它是一个类，为引用类型。

而我们的String类位于java.lang包中，java.lang包是Java的核心包，会自动导入到每个Java程序中。因此，在使用String类时，无需显式导入。
❤️❤️对于String内部有两个要注意的成员变量，一个为value ，一个为hash。

之后很多关于String的使用都会牵扯到这两个变量的使用。

其中value为字符数组 。

hash为整形，默认为0 .

❤️❤️那因为字符串为引用变量，当我们的println打印，应该是打印出地址呀，为什么像如下图一样打印出的是asdjj。

那是因为String这个类有重写toString方法，在println中经过一系列复杂的操作导致其打印出的其实是字符串对象内部的value成员数组中的每个数组成员。如上打印出asdjj。

String对象的创建

❤️❤️ String对象的创建常见有以下三种：

public static void main(String[] args) {
     // 使用常量串构造
     String s1 = "hello bit";
     System.out.println(s1);
 
     // 直接newString对象
     String s2 = new String("hello bit");
     System.out.println(s1);
 
     // 使用字符数组进行构造
     char[] array = {'h','e','l','l','o','b','i','t'};
     String s3 = new String(array);
     System.out.println(s1);
}

所以我们现在来逐步分析下：

🎯🎯使用常量串构造

🎯🎯在Java中，如上，字符串可以直接赋值而不需要使用new关键字是因为Java为字符串提供了特殊的字符串常量池（String Pool）机制。当我们使用双引号括起来的字符串字面量赋值给一个字符串变量时，Java会首先检查字符串常量池中是否已经存在相同内容的字符串对象，如果存在，则直接返回常量池中的引用；如果不存在，则在常量池中创建一个新的字符串对象，并返回其引用。

这种机制的好处是可以节省内存空间，避免创建大量相同内容的字符串常量对象。因为字符串在Java中是不可变的（Immutable），所以可以共享使用相同内容的字符串常量对象，提高了性能和效率。

需要注意的是，使用new关键字创建的字符串对象会在堆内存中创建一个新的对象，而不会在字符串常量池中创建对象。因此，直接赋值和使用new关键字创建字符串对象是有区别的。

注意字符串常量池位于java堆内存的一块特殊区域中，因为是特殊区域，所以在堆区正常创建对象不会影响字符串常量池。
🎯🎯对于字符串常量，如"abcd","shdak" 实则都是字符串常量对象的引用，它们指向的字符串对象都在字符串常量池中创建出来。

而对于这些字符串常量对象中的value数组变量，编译器会将该字符串常量如"Hello"转换为一个包含字符如'H'、'e'、'l'、'l'、'o'的char数组，并将该数组的引用赋值给字符串常量对象value属性。
❤️❤️ 所以我们把这最重要的一点：字符串常量的细节给说完了，之后这些细节还会应用到后面的知识点中。

直接new string对象

❤️❤️ 该构造方法内部代码如下：

如上两个图，"hello bit"为字符串常量，所以为String引用类型，而后将字符串常量池中的"hello bit"所指向的对象的value和hash赋值到我们在堆中创建的字符串对象中的value和hash，这样我们的String类就创建好了。

使用字符数组进行构造

❤️❤️该构造方法内部代码如下

所以根据以上代码，就可以通过接收字符数组去创建字符串对象。这里就不多说了。

其他构造方法

当然除此之外还有一些其他的构造方法：

1.如new String（），这里用该构造方法创建完 字符串之后，该字符串内部的value指向空数组（java中数组的长度可以为0，可以存在空数组），从而打印该字符串后将只会换行，不会打印出任何一个数据

2.又如String（char value[],int offset,int count）这个构造方法,它是将一个数组的部分当作参数赋值到字符串对象的value中，所以打印出的是数组的一部分成员值。

这两个构造方法我们只要了解下就行，它并不像前面几个一样经常被使用

格式化创建String对象

❤️❤️我们可以通过String类的format方法去格式化创建一个String类对象。

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

打印结果如下：

由上可知，所以我们除了之前学的那些创建String对象的方法，还可以通过该方法去格式化创建String对象。

通过分析其format内部代码可知其内部含有new，那么以上代码一切都说得通了。

求字符串的长度

在String类中它含有自己的length方法，所以我们可以用该方法去求字符串长度。如下：

对于isEmpty这个方法我们就无需过多了解了，充分了解下Srting中的length就可以了。

String对象的比较

❤️❤️字符串的比较是常见操作之一，我们之前就提到过一嘴，现在再次说一下比如：字符串排序。Java中总共提供了4中方式：

1.用==号进行比较

❤️❤️之前就说过，注意：对于基本类型，==比较的是变量中的值；对于引用类型==比较的是引用中的地址。所以对于字符串比较切记不能用等号。

2.equals方法

❤️❤️之前就讲过，现在重新讲一遍，String类重写了父类Object中equals方法，Object中equals默认按照==比较，String重写equals方法后，按照如下规则进行比较：

public static void main(String[] args) {
    String s1 = new String("hello");
    String s2 = new String("hello");
    String s3 = new String("Hello");
 
    // s1、s2、s3引用的是三个不同对象，因此==比较结果全部为false
    System.out.println(s1 == s2);       // false
    System.out.println(s1 == s3);       // false
 
    // equals比较：String对象中的逐个字符
    // 虽然s1与s2引用的不是同一个对象，但是两个对象中放置的内容相同，因此输出true
    // s1与s3引用的不是同一个对象，而且两个对象中内容也不同，因此输出false
    System.out.println(s1.equals(s2));  // true
    System.out.println(s1.equals(s3));  // false
}

3.compareTo方法

❤️❤️该方法我们之前就讲过，其位于comparable接口中，而在String类中实施了该接口且重写了该方法。

❤️❤️所以由上可知其具体比较方式： s1.compareTo(s2）：

1. 先按照字典次序大小比较，如果出现不等的字符，直接返回这两个字符的大小差值

2. 如果前k个字符相等(k为两个字符长度最小值)，返回值为两个字符串长度差值

总之s1字符串如果大于s2字符串，返回值就大于0；s1小于s2字符串，返回值小于0；相同则返回0.

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("abcdef");
    System.out.println(s1.compareTo(s2));   // 不同输出字符差值-1
    System.out.println(s1.compareTo(s3));   // 相同输出 0
    System.out.println(s1.compareTo(s4));   // 前k个字符完全相同，输出长度差值 -3
}

4. compareToIgnoreCase

❤️❤️与compareTo方式相同，但是它忽略大小写比较， compare考虑大小写比较。

​
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("abcdef");
    System.out.println(s1.compareToIgnoreCase(s2));   
       // 不同输出字符差值-1
    System.out.println(s1.compareToIgnoreCase(s3)); 
      // 相同输出 0
    System.out.println(s1.compareToIgnoreCase(s4));
     // 前k个字符完全相同，输出长度差值 -3
}

​

字符串查找

❤️❤️字符串查找也是字符串中非常常见的操作，String类提供的常用查找的方法：

注意其返回和输入的int值我们可以认为是String中的value数组下标。

public static void main(String[] args) {
    String s = "aaabbbcccaaabbbccc";
    System.out.println(s.charAt(3));                             // 'b'
    System.out.println(s.indexOf('c'));                          // 6
    System.out.println(s.indexOf('c', 10));                      // 15
    System.out.println(s.indexOf("bbb"));                        // 3
    System.out.println(s.indexOf("bbb", 10));                    // 12
    System.out.println(s.lastIndexOf('c'));                      // 17
    System.out.println(s.lastIndexOf('c', 10));                  // 8
    System.out.println(s.lastIndexOf("bbb"));                    // 12
    System.out.println(s.lastIndexOf("bbb", 10));                // 3

字符串转化

1. 数值和字符串转化

❤️❤️当我们将基本类型转换为字符串时，我们能用String类中的valueof去转换：

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

        String s1 = String.valueOf(1234);
   String s2 = String.valueOf(12.34);
     String s3 = String.valueOf(true);
        System.out.println(s1);//输出1234
        System.out.println(s2);//输出12.34
        System.out.println(s3);//输出true
    }
}

❤️❤️而我们反过来将字符串反过来转换为基本类型时，我们就要用包装类型里的方法去转换了。

（包装类型是类，并且这些包装类型是单独针对于一个基本类型进行操作的，如Interger，Double都是包装类型）

public class Main {
    public static void main(String[] args) {
     int  s1=Integer.parseInt("1414");
     double s2=Double.parseDouble("12.24");
     boolean s3=Boolean.parseBoolean("false");
        System.out.println(s1);//输出1414
        System.out.println(s2);//输出12.24
        System.out.println(s3);//输出false

这些就是我们用包装类型的方法将字符串转换为相应的类型，除了这三种方式之外还存在其他的转换方法，这里就不多展示了，你们可以自己去探究一下。

还要说一点如果我们想把该字符串转换为整形，而字符串内部却是浮点型如"13.14"，那么会直接报错。所以字符串内部只能存在其想转换的类型的值，如果是其他类型的值则会报错。

2.大小写转换

❤️❤️大写转换用String类中的toUpperCase， 小写转换用String类中的toLowerCase

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

注意其两个方法返回值都是String类型，所以意味着实施该方法后会新创建一个字符串对象，并不会改变原本的字符串对象。

3.字符串转数组

❤️❤️****我们可以通过String类中的tocharArray方法将字符串转换为字符数组。

而对于字符数组转化为字符串，之前我们提的String类的第三个创建方法就是字符数组转化为字符串。

使用方法如下：

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

字符串替换

❤️❤️****关于字符串替换，我们在这说两个主要方法：

String replaceAll(String regex, String replacement) ： 替换所有的指定内容

String replaceFirst(String regex, String replacement)： 替换首个指定内容

使用如下：

String str = "helloworld" ; 
System.out.println(str.replaceAll("l", "_"));
//输出he__owor_d
System.out.println(str.replaceFirst("l", "_"));
//输出he_loworld

此外还有一些其他的字符串替换方法如replace，它有两个重载方法你们可以自行去了解一下，这里我不多说了。

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

字符串拆分

❤️❤️****可以将一个完整的字符串按照指定的分隔符划分为若干个子字符串。 可用方法如下：

String[] split(String regex) 将字符串全部拆分

String[] split(String regex, int limit) 将字符串以指定的格式，拆分为limit组

使用如下：

public class Main {
    public static void main(String[] args) {
        String str = "hello world hello bit" ;
        String[] result1 = str.split(" ") ;
        String[]  result2=str.split(" ",2);
        for(String s: result1) {
       System.out.println(s);
        }
        System.out.println("=================");
        for(String s: result2) {
         System.out.println(s);
        }
    }
}

打印结果如下：

❤️❤️****拆分是特别常用的操作. 一定要重点掌握. 另外有些特殊字符作为分割符可能无法正确切分, 需要加上转义. （其实对于特殊字符，我们无论是用它拆分还是干别的事情，都要注意以下事项）

注意事项:

1. 字符"|", "*" , "+" 都得加上转义字符，前面加上 "\\" .

2. 而如果是 "\\" ，(之所以在字符串里不是\而是\\，是因为\会跟后面字符形成转义字符，所以为了表示真正的\，我们的\\才是真正的\)，那么就得写成 "\\\\" .

我们直接看实例：

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

        String str0 = "192.168.1.1";
        String str1 = "192*168*1*1";
        String str2 = "192+168+1+1";
        String str3 = "192\\168\\1\\1";


        String[] result1 = str0.split("\\.");
        for (String s : result1) {
            System.out.print(s);
            System.out.print("  ");

        }
        System.out.println();
        System.out.println("=============");
        String[] result2 = str1.split("\\*");
        for (String s : result2) {
            System.out.print(s );
            System.out.print("  ");

        }
        System.out.println();
        System.out.println("=============");
        String[] result3 = str2.split("\\+");
        for (String s : result3) {
            System.out.print(s );
            System.out.print("  ");
        }
        System.out.println();
        System.out.println("=============");
        String[] result4 = str3.split("\\\\");
        for (String s : result4) {
            System.out.print(s );
        }
    }
}

​

打印结果如下：

❤️❤️****3. 如果一个字符串中有多个分隔符，可以用"|"作为连字符.

实例如下

​
public class Main {
    public static void main(String[] args) {
        String str = "name=zha.ng san&age=18" ;
        String[] result = str.split("&|=| |\\.");
        //意味着如果出现&或=或逗号或空格就会发生切割
        for (int i = 0; i < result.length; i++) {
      System.out.println(result[i]);
        }}}

​

所以这就是 |的 作用，用起来很方便。

当然也有其他方法，不过较麻烦，比如多次拆分。但肯定没有连字符"|"好用。

public  class Main {
    public static void main(String[] args) {
        String str = "name=zhangsan&age=18" ;
        String[] result = str.split("&") ;
        for (int i = 0; i < result.length; i++) {
  String[] temp = result[i].split("=") ;
  System.out.print(temp[0]+"  "+temp[1]+"  ");
        }

    }
}

字符串截取

❤️❤️****从一个完整的字符串之中截取出部分内容。可用方法如下：

String substring(int beginIndex) 从指定索引截取到结尾

String substring(int beginIndex, int endIndex) 截取部分内容

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

    }
}

注意事项:

1. 注意前闭后开区间的写法, substring(0, 5) 表示包含0 号下标的字符, 不包含5号下标。

2.而substring（5）表示其包含的是从5号下标的字符到最后的字符。

其他字符串的操作方法

❤️❤️String trim() 去掉字符串中的左右空格,保留中间空格

public class Main {
    public static void main(String[] args) {
        String str = "  hello world  " ;
        System.out.println("["+str+"]");
        System.out.println("["+str.trim()+"]");
    }
}

所以验证了trim会去掉字符串开头和结尾的空白字符

🎯🎯字符串的不可变性

🎯🎯String对象是一种不可变对象. 字符串对象中的内容是不可改变。所以字符串对象不可被修改。（当然字符串类所创建的引用能修改）

String类在设计时就是不可改变的，String类实现描述中已经说明了，如下：

该图可以看出：

1.String类中的字符实际保存在内部维护的value字符数组中

2. String类被final修饰，表明该类不能被继承

3. value被final修饰，表明value自身的值不能改变，即不能引用其它字符数组，但是其引用空间中的内容可以修改，而虽然其引用空间中的内容可以修改，可value是用private修饰的，而内部又不存在得到value或者修改value的方法，所以在外部使用不了value，也就意味着你虽然可以有修改其内部内容的能力，但没有机会可以修改内部内容。

所以我们的String对象不能被修改其内容。

除此之外，我们还需切记所有涉及到可能修改字符串内容的操作都是创建一个新对象，改变的是新对象，没修改其原本字符串对象的内容。
🎯🎯**【纠正】**

网上有些人说：字符串不可变是因为其内部保存字符的数组被final修饰了，因此不能改变。

这种说法是错误的，不是因为String类自身，或者其内部value被final修饰而不能被修改。final修饰类表明该类不想被继承，final修饰引用类型表明该引用变量不能引用其他对象，但是其引用对象中的内容是可以修改的。究其原因是因为我们用的是private修饰value，而内部不存在与其相关的方法，所以导致字符串内部不可变 。

❤️❤️ 为什么 String 要设计成不可变的?(不可变对象的好处是什么?)

1. 方便实现字符串对象池. 如果 String 可变, 那么对象池就需要考虑写时拷贝的问题了.

2. 不可变对象是线程安全的.

3. 不可变对象更方便缓存 hash code, 作为 key 时可以更高效的保存到 HashMap 中.

（上述这些知识要等我们深入学习后才能了解，现在还是看不懂的）

那如果想要修改字符串中内容，该如何操作呢？

这个疑问我们就留到下篇文章string类（2）去讲了，因为所涉及的知识点有点过多。那么我们这篇文章就先这样结束吧，写的已经很多了。之后下篇文章将会给大家讲解如何修改字符串中内容。

总结

好的铁汁们，所以我们的String类（1）就讲完了，之后将在String（2）中介绍如何修改字符串。这篇文章写了一万字了，还希望各位大佬们能给个三连，点点关注，点点赞，发发评论呀，感谢各位大佬~❤️❤️💕💕🥳🎉🎉🎉！