【Java初阶（八）】String类

❣博主主页: 33的博客❣
▶文章专栏分类: Java从入门到精通◀
🚚我的代码仓库: 33的代码仓库🚚

1.前言

在C语言中已经涉及到字符串了，但是在C语言中要表示字符串只能使用字符数组或者字符指针，可以使用标准库提供的字符串系列函数完成大部分操作，但是这种将数据和操作数据方法分离开的方式不符合面相对象的思想，而字符串应用又非常广泛，因此Java语言专门提供了String类，接下来我们通过本篇文章一起进行学习吧！

本章重点

认识String类，了解String类的基本用法，熟练掌握String类的常见操作，认识StringBuffer和StringBuilder，String类的练习。

2.常用方法

2.1字符串构造

//使用常量串构造
String s1 = "Hello World";
//new一个String对象
String s2=new String("Hello World");
//使用字符串数组构造
char[] arr={'h','e','l','l','o','W','o','r','l','d'}

注意
String是引用类型，内部并不存储字符串本身，String类内部有两个成员变量，分别为char[] value和 int hash，字符串实际是保存在char类型的数组中。

String s1=new String("H");
String s2=new String("M");
String s3=S1;

2.2 String对象的比较

1.用==比较是否引用同一个对象
对于基本类型= =比较的是变量中的值；对于引用类型= =是比比较地址是否相等

    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

2.equals方法
String类重写了父类Object方法，equals默认按照==比较，String重写后按照内容比较

 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;
}
 	String s1 = new String("hello");
    String s2 = new String("hello");
    String s3 = new String("Hello")
    System.out.println(s1.equals(s2));  // true
    System.out.println(s1.equals(s3));  // false

2.3转换

大小写转换：

String s1 = "hello";
String s2 = "HELLO";
// 小写转大写
System.out.println(s1.toUpperCase());
// 大写转小写
System.out.println(s2.toLowerCase());

字符串转换：

char[] ch = s.toCharArray();
String s2 = new String(ch);

字符串替换：
产生了新的对象

String str = "helloworld" ; 
System.out.println(str.replaceAll("l", "_"));
System.out.println(str.replaceFirst("l", "_"));

2.4字符串拆分

字符串拆分，可以将一个完整的字符串按照指定的分隔符划分为若干个子字符串。
格式如下：

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

例如：

 String str = "hello world hello bit" ; 
 String[] result1 = str.split(" ") ; // 按照空格拆分
 String[] result2 = str.split(" ",2) ;//按照空格拆分为2组 
 for(String s: result) {
    System.out.println(s);
 }

2.5字符串截取

从一个完整的字符串之中截取出部分内容。
格式如下：

String substring(int beginIndex);//从指定索引截取到结尾
String substring(int beginIndex, int endIndex);//截取部分内容

例如

 String str = "helloworld" ; 
 System.out.println(str.substring(5));//从5位置开始
 System.out.println(str.substring(0, 5));//截取位置为【0，5）

3.字符串的不可变性

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

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

String类被final修饰，表明该类不能被继承。value 的值被final修饰表示value本身的值不可改变，所有涉及字符串内容修改的都是创建了一个新的对象。

3.1字符串修改

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

 
但是这种方式不推荐使用，因为其效率非常低，中间创建了好多临时对象。
 
public static void main(String[] args) {
    String s = "hello";
    s += " world";
    System.out.println(s);  // 输出：hello world
 }

这种方式在中途，创建了好多临时对象，效率非常低，因此；要尽量避免对String的直接使用，如果要修改尽量使用StringBuffer或者StringBuilder。

3.2 StringBuilder和StringBuffer

由于String的不可更改特性，为了方便字符串的修改，Java中又提供StringBuilder和StringBuffer类。

StringBuider append(String str)
//在尾部追加，相当于Sring的+=
StringBuilder sb1 = new StringBuilder("hello");
sb1.append(world);//hello world
sb1.setCharAt(0,'H');//把0位置设置为H，Hello world

String和StringBuilder最大的区别在于String的内容无法修改，而StringBuilder的内容可以修改，频繁修改字符串的情况考虑使用StringBuilder。
面试题：
1.String、StringBuffer、StringBuilder的区别

String的内容不可修改，StringBuffer与StringBuilder的内容可以修改。
StringBuffer与StringBuilder大部分功能是相似的。
StringBuffer采用同步处理，属于线程安全操作；而StringBuilder未采用同步处理，属于线程不安全操作。

2.以下总共创建了几个对象【前提不考虑常量池之前是否存在】

 String str = new String("ab");   // 会创建2个对象："常量池的ab"和new的
String str = new String("a") + new String("b");  // 会创建6个："常量池的a"、"常量池的b"，new String，new String，StringBuilder，to String中new一个类。

4.String类应用

例1：第一个只出现一次的字符：

    public int firstUniqChar(String s) {
        int[] count= new int[125];//a为97，有26个字母
        for(int i=0;i<s.length();i++){
        count[s.charAt(i)]++;
        }
        for(int i=0;i<s.length();i++){
            if(count[s.charAt(i)]==1){
                return i;
            }
        }
    return -1;
    }

例2：最后一个单词的长度

public class Main {
        public static void main(String[] args) {
            Scanner in = new Scanner(System.in);
            while (in.hasNextLine()) { 
                String s=in.nextLine();
                String[] sp=s.split(" ");//以空格分割
                String result=sp [sp.length-1];
                System.out.println(result.length());
            }
        }
    }

例3：字符串是否回文

public boolean isPalindrome(String s) {
        s=s.toLowerCase();
        int l=0;
        int r=s.length()-1;
        while(l<r){
            while( l<r&&!isCharacterNumber(s.charAt(l))){
                l++;
            }
            while(l<r&&!isCharacterNumber(s.charAt(r))){
                r--;
            }
            if (s.charAt(l)==s.charAt(r)){
                l++;
                r--;
            }else {
                return false;
            }
        }
        return true;
    }
    //判断是否为数字或者字母
    public Boolean isCharacterNumber(char ch){
        if(ch>='a'&&ch<='z'||ch>='0'&&ch<='9'){
            return true;
        }
        return false;
    }
}

4.总结

本篇文章主要介绍了String类，了解String类的基本用法，熟练掌握String类的常见操作，认识StringBuffer和StringBuilder，String类的练习，感兴趣的同学可以再找一些题进行练习。

下期预告：初识数据结构

原文链接：https://blog.csdn.net/weixin_69049913/article/details/137110670