Java中的String,这一篇就够了

1.String的重要性

在C语言中已经涉及到字符串了,但是在C语言中要表示字符串只能使用字符数组或者字符指针,可以使用标准库提供的字符串系列函数完成大部分操作,但是这种将数据和操作数据方法分离开的方式不符合面相对象的思想,而字符串应用又非常广泛,因此Java语言专门提供了String类。

2.常用语法

2.1字符串构造

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

public class Test1 {
          
   
    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);
}
}
String类中提供的构造方法:

❗️ 【注意】:

    String是引用类型,内部并不存储字符串本身,在String类的实现源码中,String类实例变量如下: 在JDK1.8中,字符串实际保存在char 类型的数组中 通过对2.1中的那段代码调试我们也能看到字符串实际保存在char 类型的数组中:
public static void main(String[] args) {
          
   
      // 使用常量串构造
    String s1 = "hello ";
    System.out.println(s1);
      // 直接newString对象
    String s2 = new String("world");
    System.out.println(s1);
    System.out.println(s2);
}

上面这段代码在内存中存储的形式(简易图,这里并没有将字符常量池展示出来,后面会详细画出)

    在Java中“ ”引起来的也是String类型对象。

2.2 String对象的比较

    1.== 比较是否引用同一个对象 对于内置类型,比较的是变量中的值;对于引用类型比较的是引用中的地址。
public static void main(String[] args) {
          
   
        int a = 10;
        int b = 20;
        int c = 10;
      // 对于基本类型变量,==比较两个变量中存储的值是否相同
        System.out.println(a == b); // false
        System.out.println(a == c); // true
        // 对于引用类型变量,==比较两个引用变量引用的是否为同一个对象
        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方法比较字符串的内容是否相同 String类重写了父类Object中equals方法,Object中equals默认按照==比较,String重写equals方法后,按照 如下规则进行比较,比如: s1.equals(s2)
public boolean equals(Object anObject) {
          
   
// 1. 先检测this 和 anObject 是否为同一个对象比较,如果是返回true
        if (this == anObject) {
          
   
            return true;
        }
// 2. 检测anObject是否为String类型的对象,如果是继续比较,否则返回false
        if (anObject instanceof String) {
          
   
// 将anObject向下转型为String类型对象
            String anotherString = (String)anObject;
            int n = value.length;
// 3. this和anObject两个字符串的长度是否相同,是继续比较,否则返回false
            if (n == anotherString.value.length) {
          
   
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
// 4. 按照字典序(字符大小的顺序),从前往后逐个字符进行比较
                while (n-- != 0) {
          
   
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
       
        return false;
    }

具体使用:

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方法
与equals不同的是,equals返回的是boolean类型,而compareTo返回的是int类型。具体比较方式: 先按照字典次序大小比较,如果出现不等的字符,直接返回这两个字符的大小差值 如果前k个字符相等(k为两个字符长度最小值),返回值两个字符串长度差值

String 类中的compareTo方法源码:

public int compareTo(String anotherString) {
          
   
        int len1 = value.length;
        int len2 = anotherString.value.length;
        int lim = Math.min(len1, len2);
        char v1[] = value;
        char v2[] = anotherString.value;

        int k = 0;
        while (k < lim) {
          
   
            char c1 = v1[k];
            char c2 = v2[k];
            if (c1 != c2) {
          
   
                return c1 - c2;
            }
            k++;
        }
        return len1 - len2;
    }

具体使用:

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方式相同,但是忽略大小写比较
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
}
    5.equalsIgnoreCase,忽略大小写的比较

2.3 字符串查找

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

使用:

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
    }

【注意】: Java的方法中参数带有fromIndex和lastIndex的几乎都是左闭右开

这些函数之间构成了重载,在使用是我们只需要记住一个函数名就可以了

2.4 转化

    1.数值和字符串转化
public static void main(String[] args) {
          
   

// 数字转字符串
            String s1 = String.valueOf(1234);
            String s2 = String.valueOf(12.34);
            String s3 = String.valueOf(true);
          //  String s4 = String.valueOf(new Student("Hanmeimei", 18));

            System.out.println(s1);
            System.out.println(s2);
            System.out.println(s3);
            //System.out.println(s4);
            System.out.println("=================================");
// 字符串转数字
// 注意:Integer、Double等是Java中的包装类型,这个后面会讲到
         int data1 = Integer.parseInt("1234");
            double data2 = Double.parseDouble("12.34");
            int data3=Integer.parseInt("12",8);
           System.out.println(data1);
            System.out.println(data2);
        System.out.println(data3);
        }
//执行结果
1234
12.34
true
=================================
1234
12.34
10

Process finished with exit code 0

将可以理解为双引号里的12是个八进制的数

    2.大小写转换
public static void main(String[] args) {
          
   
        String s1 = "hello";
        String s2 = "HELLO";
// 小写转大写
        System.out.println(s1.toUpperCase());
// 大写转小写
        System.out.println(s2.toLowerCase());
    }
//执行结果
HELLO
hello
    3.字符串转数组
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]);
        }
    }
    //执行结果
    hello
    4.格式化
public static void main(String[] args) {
          
   
        String s = String.format("%d-%d-%d", 2022, 4,19);
        System.out.println(s);
    }
//执行结果
2022-4-19

【注意】: String类中定义的对字符串操作的方法,都会返回一个新的字符串,而不是在原有的字符串上修改

2.5字符串替换

可以使用的方法:

public static void main(String[] args) {
          
   
        String str1="ababababcdbfad";
        String str2=str1.replace(a,z);
        System.out.println(str2);
        System.out.println(str1.replace("ab", "cc"));
        System.out.println(str1.replaceFirst("ab", "dd"));
        System.out.println(str1.replaceAll("a", "n"));
    }
//执行结果:
zbzbzbzbcdbfzd
cccccccccdbfad
ddabababcdbfad
nbnbnbnbcdbfnd

2.6字符串拆分

可以将一个完整的字符串按照指定的分隔符划分为若干个子字符串。

可用的方法:

示例1: 实现字符串的拆分处理

☀️

public static void main(String[] args) {
          
   
        String str = "hello world hello bit" ;
        String[] result = str.split(" ") ; // 按照空格拆分
        for(String s: result) {
          
   
            System.out.println(s);
        }
    }
    //执行结果:
    hello
    world
    hello
    bit

Process finished with exit code 0

示例2:字符串的部分拆分

❄️

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

    }
//执行结果:
hello
world hello bit

示例3:拆分IP地址

⛄️

public static void main(String[] args) {
          
   
        String str="123.456.678";
        String[] ret=str.split("\.");
        for (String s:ret) {
          
   
            System.out.println(s);
        }
    }
    //执行结果:
    123
    456
    678

示例5:用多个分隔符拆分字符串

🌀

public static void main(String[] args) {
          
   
        String str="asdf&sdf#adsf";
        String[] ret=str.split("[&#]");
        for (String s:ret) {
          
   
            System.out.println(s);
        }
    }
    //执行结果:
    asdf
    sdf
    adsf

示例5:多次拆分

⚡️

public static void main(String[] args) {
          
   
        String str = "name=zhangsan&age=18" ;
        String[] ret=str.split("&");
        for (String value : ret) {
          
   
            String[] tmp = value.split("=");
            for (String s : tmp) {
          
   
                System.out.println(s);
            }
        }
    }

2.7字符串截取

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

🌁

public static void main(String[] args) {
          
   
        String str="helloworld";
        System.out.println(str.substring(1));
        System.out.println(str.substring(0,3));
        System.out.println(str.subSequence(0,2));
    }
    //执行结果:
elloworld
hel
he

【注意】:

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

2.8 其他操作方法

代码示例1:trim()方法使用

🐻

public static void main(String[] args) {
          
   
        String str="  very happy   ";
        System.out.println(str.trim());
    }
//执行结果:
very happy

trim 会去掉字符串开头和结尾的空白字符(空格, 换行, 制表符等).

代码示例2:大小写转换

🐷

public static void main(String[] args) {
          
   
        String str = " hello%$$%@#$%WORLD哈哈哈 " ;
        System.out.println(str.toUpperCase());
        System.out.println(str.toLowerCase());
    }
  //执行结果:
   HELLO%$$%@#$%WORLD 哈哈哈 
  hello%$$%@#$%world 哈哈哈

toUpperCase和toLowerCase函数只转换字母,其他字符不变

2.9字符串常量池

2.9.1 创建对象的思考

下面两种创建String对象的方式相同吗? 🐮

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); // true
            System.out.println(s1 == s3); // false
            System.out.println(s3 == s4); // false
    }

易错代码示例

🌱

public static void main(String[] args) {
          
   
        String str1="hello";
        String str2="hel"+"lo";//对于常量来说,在编译的时候就变成了hello	
        String str3="hel";
        String str4="lo";
        String str5=str3+str4;//str3和str4时变量,在编译的时候还不知道里面是谁
        System.out.println(str1==str2);
        System.out.println(str1==str5);
    }
    //执行结果:
    true
    false

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

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

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

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

2.9.1字符串常量池(StringTable)

字符串常量池在JVM中是StringTable类,实际是一个固定大小的HashTable(一种高效用来进行查找的数据结构,后序给大家详细介绍),JDK1.8字符串常量池处在堆中

【注意】:

  1. 在JVM中字符串常量池只有一份,是全局共享的
  2. 刚开始字符串常量池是空的,随着程序不断运行,字符串常量池中元素会越来越多
  3. 当类加载时,字节码文件中的常量池也被加载到JVM中,称为运行时常量池,同时会将其中的字符串常量保存在字符串常量池中
  4. 字符串常量池中的内容:一部分来自运行时常量池,一部分来自程序动态添加
  5. 字符串常量池实际上是一个哈希表
  6. 只要用在“ ”中的内容全部放在常量池中,并且只有一份,在存放的时候先去常量池中检查是否存在这个变量

2.9.3 String对象创建

    1.直接使用字符串常量进行赋值 🐴
public static void main(String[] args) {
          
   

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

s1和s2在内存中的存储:

    2.通过new创建String类对象 🐼
public static void main(String[] args) {
          
   
        String s1="hello";
        String s2="hello";
        String s3=new String("world");
        String s4=new String("world");
        System.out.println(s2==s3); //false
        System.out.println(s3==s4);//false
    }

s1,s2,s3,s4在内存中的存储: 【结论】:

1.只要是new的对象,都是唯一的。 2.使用常量串创建String类型对象的效率更高,而且更节省空间。用户也可以将创建的字符串对象通过 intern 方式添加进字符串常量池中。
    3.intern方法 🌴
public static void main(String[] args) {
          
   
        char[] ch=new char[]{
          
   a,b,c};
        String str1=new String(ch);
        String str2="abc";
        System.out.println(str1==str2);
    }
//执行结果
false

内存图: 【说明】:

对于str1调用的是参数为字符数组的构造方法 此构造方法的源码是,将数组拷贝一份,使str1引用的对象中的value引用拷贝后的数组 这两行代码执行完,字符串常量池中还没有内容,因为还没有出现 “ ”

调用intern方法后的变化: 🌞

public static void main(String[] args) {
          
   
        char[] ch = new char[]{
          
   a, b, c};
        String s1 = new String(ch); // s1对象并不在常量池中
        s1.intern(); // s1.intern();调用之后,会将s1对象的引用放入到常量池中
        String s2 = "abc"; // "abc" 在常量池中存在了,s2创建时直接用常量池中"abc"的引用
        System.out.println(s1 == s2);
    }

执行结果:
true

2.10字符串的不可变性

String是一种不可变对象. 字符串中的内容是不可改变。字符串不可被修改,是因为:

2.10.1 String类在设计时就是不可改变的,String类实现描述中已经说明了

String类中的字符实际保存在内部维护的value字符数组中,改图还可以看出: 1.String类被final修饰,表示该类不能被继承 2.value被final修饰,表明value自身的值不能改变,即不能引用其他字符数组,但是其引用空间中的内容可以修改

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

【注意】:

字符串不可变是因为其内部保存字符的数组被final修饰了,因此不能改变。 这种说法是错误的,不是因为String类自身,或者其内部value被final修饰而不能被修改 final修饰类表明该类不想被继承,final修饰引用类型表明该引用变量不能引用其他对象,但是其引用对象中的内容是可以修改的。

字符串不能被修改的真正原因:

value被private修饰,而且String类中没有提供关于value的get和set方法

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

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

2.11 字符串修改

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

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

    }

但是这种方式不推荐使用,因为其效率非常低,中间创建了好多临时对象。 可以看出在对String类进行修改时,效率是非常慢的,因此:尽量避免对String的直接修改,如果要修改建议尽量使用StringBuffer或者StringBuilder。

3.StringBuffer和StringBuilder

3.1StringBulider的介绍

由于String的不可更改特性,为了方便字符串的修改,Java中又提供StringBuilder和StringBuffer类。这两个类大部分功能是相同的,这里介绍 StringBuilder常用的一些方法,其它需要用到了大家可参阅

🌼

public static void main(String[] args) {
          
   
        StringBuilder sb1 = new StringBuilder("hello");
        StringBuilder sb2 = sb1;
// 追加:即尾插-->字符、字符串、整形数字
        sb1.append( ); // hello
        sb1.append("world"); // hello world
        sb1.append(123); // hello world123
        System.out.println(sb1); // hello world123
        System.out.println(sb1 == sb2); // true
        System.out.println(sb1.charAt(0)); // 获取0号位上的字符 h
        System.out.println(sb1.length()); // 获取字符串的有效长度14
        System.out.println(sb1.capacity()); // 获取底层数组的总大小
        sb1.setCharAt(0, H); // 设置任意位置的字符 Hello world123
        sb1.insert(0, "Hello world!!!"); // Hello world!!!Hello world123
        System.out.println(sb1);
        System.out.println(sb1.indexOf("Hello")); // 获取Hello第一次出现的位置
        System.out.println(sb1.lastIndexOf("hello")); // 获取hello最后一次出现的位置
        sb1.deleteCharAt(0); // 删除首字符
        sb1.delete(0,5); // 删除[0, 5)范围内的字符
        String str = sb1.substring(0, 5); // 截取[0, 5)区间中的字符以String的方式返回
        System.out.println(str);
        sb1.reverse(); // 字符串逆转
        str = sb1.toString(); // 将StringBuffer以String的方式返回
        System.out.println(str);
    }

从上述例子可以看出:String和StringBuilder最大的区别在于String的内容无法修改,而StringBuilder的内容可以修改。频繁修改字符串的情况考虑使用StringBuilder。

【注意】String和StringBuilder类不能直接转换。如果要想互相转换,可以采用如下原则:

    String变为StringBuilder: 利用StringBuilder的构造方法或append()方法 StringBuilder变为String: 调用toString()方法。

3.2 关于StringBuilder和StringBuffer的面试题

  1. String、StringBuffer、StringBuilder的区别
    String的内容不可修改,StringBuffer与StringBuilder的内容可以修改. StringBuffer与StringBuilder大部分功能是相似的 StringBuffer采用同步处理,属于线程安全操作;而StringBuilder未采用同步处理,属于线程不安全操作

StringBuilder相对于String的好处 🌜

public static void main(String[] args) {
          
   
        String str="abc";
        for (int i = 0; i < 10; i++) {
          
   
            str+=i;
        }
        System.out.println(str);
    }
    //执行结果:
    abc0123456789

观察这段代码对应的反汇编指令: 这样做浪费了很多的空间,同时效率也会很低

使用StringBuilder实现: 🌙

public static void main(String[] args) {
          
   
        String str="abc";
        StringBuilder sb=new StringBuilder(str);
        for (int i = 0; i < 10; i++) {
          
   
         sb.append(i);
        }
        System.out.println(sb.toString());
    }
//执行结果:
abc0123456789

对应的反汇编代码: 不会浪费额外空间,同时效率也提高 2.以下总共创建了多少个String对象【前提不考虑常量池之前是否存在】 🌏

String str = new String("ab"); // 会创建多少个对象 2个

String str = new String("a") + new String("b"); // 会创建多少个对象  6个

简易图 (String str = new String(“a”) + new String(“b”);)

经验分享 程序员 微信小程序 职场和发展