Java语法学习八之认识String类

String类的重要性

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

在开发和校招笔试中，字符串也是常客，比如：

字符串相加

而且在面试中也频繁被问到，比如：String、StringBuff和StringBulider之间的区别等。

常用方法

字符串构造

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

public class Test {
    public static void main(String[] args) {
       //直接赋值的方法 定义字符串-使用常量串构造
        String str="adcdef";

        //直接newString对象
        String str2=new String("hello");

        //用字符数组 来构造字符串
        char[] array={'a','b','c','d'};
        String str3=new String(array);

        System.out.println(str);
        System.out.println(str2);
        System.out.println(str3);
    }
}

注意：

1. String是引用类型，内部并不存储字符串本身，在String类的实现源码中，String类实例变量如下：

public class Test {
    public static void main(String[] args) {
        String str="abcdef";
        System.out.println(str.length());

        String str2=null;
        System.out.println(str2);
    }
}

public class Test {
    public static void main(String[] args) {
        String str="abcdef";
        System.out.println(str.length());

        String str2=null;
        System.out.println(str2);

        //空指针异常
        System.out.println(str2.length());
    }
}

public class Test {
    public static void main(String[] args) {
        String str="abcdef";
        System.out.println(str.length());//获取字符串长度
        System.out.println(str.isEmpty());//false

        String str2=null;
        System.out.println(str2);

        //空指针异常
        //System.out.println(str2.length());

        String str3="";
        System.out.println(str3.length());//0
        System.out.println(str3.isEmpty());//true 如果字符串长度为0，返回true，否则返回false
    }
}

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

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

String对象的比较

字符串的比较是常见操作之一，Java中总共提供了4中方式：
1. ==比较是否引用同一个对象

注意：对于内置类型，==比较的是变量中的值；对于引用类型==比较的是引用中的地址。

public class Test {
    public static void main(String[] args) {
        String str1="abcdef";
        String str2="abcdef";
        System.out.println(str1==str2);//true

        String str3=new String("hello");
        String str4=new String("hello");
        System.out.println(str3==str4);//false

    }
}

2. boolean equals(Object anObject) 方法：按照字典序比较

public class Test {
    public static void main(String[] args) {
        String str1="abcdef";
        String str2="abcdef";
        //System.out.println(str1==str2);//true

        System.out.println(str1.equals(str2));

        String str3=new String("hello");
        String str4=new String("hello");
        //System.out.println(str3==str4);//false

        System.out.println(str3.equals(str4));

    }
}

字典序：字符大小的顺序
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. int compareTo(String s) 方法: 按照字典序进行比较
与equals不同的是，equals返回的是boolean类型，而compareTo返回的是int类型。具体比较方式：
1. 先按照字典次序大小比较，如果出现不等的字符，直接返回这两个字符的大小差值
2. 如果前k个字符相等(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("abcdef");
System.out.println(s1.compareTo(s2)); // 不同输出字符差值-1
System.out.println(s1.compareTo(s3)); // 相同输出 0
System.out.println(s1.compareTo(s4)); // 前k个字符完全相同，输出长度差值 -3
}

4. int compareToIgnoreCase(String str) 方法：与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
}

字符串查找

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

public class Test {
    public static void main(String[] args) {
        String str1="abcd";

        char ch=str1.charAt(1);
        System.out.println(ch);

        int index=str1.indexOf('d');
        System.out.println(index);

        int index1=str1.indexOf('a',2);
        System.out.println(index1);

        int index2=str1.indexOf("bc");
        System.out.println(index2);

        String str2="ababcabcd";
        //从后往前找'a'
        int index3=str2.lastIndexOf('a');
        System.out.println(index3);

        //从指定位置从后往前找'a'
        int index4=str2.lastIndexOf('a',4);
        System.out.println(index4);
    }
}

转化

1. 数值和字符串转化

public class Test {
    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);//1234
        System.out.println(s2);//12.34
        System.out.println(s3);//true
        System.out.println(s4);
        System.out.println("=================================");
        // 字符串转数字
        // 注意：Integer、Double等是Java中的包装类型，这个后面会讲到
        int data1 = Integer.parseInt("1234");
        double data2 = Double.parseDouble("12.34");
        System.out.println(data1);//1234
        System.out.println(data2);//12.34
    }
}

2. 大小写转换

public class Test {
    public static void main(String[] args) {
        //大写转换
        String str="ABCD";
        String str3=str.toLowerCase();
        System.out.println(str3);
        System.out.println(str);//并非在原字符本身上做修改

        //小写转换
        String str1="abcd";
        System.out.println(str1.toUpperCase());

    }
}

3. 字符串转数组

public class Test {
    public static void main(String[] args) {
        String str="abcd";
        //把字符串转为数组
        char[] array=str.toCharArray();
        System.out.println(Arrays.toString(array));

        //数组转字符串
        String s=new String(array);
        System.out.println(s);
    }
}

4.格式化

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

字符串替换
 

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

public class Test {
    public static void main(String[] args) {
        String str="ababc";
        //字符的整体替换
        String ret=str.replace('a','l');
        System.out.println(ret);

        //字符串的整体替换
        String ret2=str.replace("ab","kkk");
        System.out.println(ret2);

        //替换字符串的第一个
        String ret3=str.replaceFirst("ab","kkkk");
        System.out.println(ret3);

        //字符串的整体替换
        String ret4=str.replaceAll("a","ppp");
        System.out.println(ret4);
    }
}

 

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

字符串拆分
 

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

public class Test {
    public static void main(String[] args) {
        String str="abc&def&hij";
        String[] strings=str.split("&");
        for(String s:strings){
            System.out.println(s);
        }
    }
}

public class Test {
    public static void main(String[] args) {
        String str="abc&def&hij";
        //最多分为几组
        String[] strings=str.split("&",2);
        for(String s:strings){
            System.out.println(s);
        }
    }
}

public class Test {
    public static void main(String[] args) {
        String str="abc.def.hij";
        //最多分为几组
        String[] strings=str.split(".",2);
        for(String s:strings){
            System.out.println(s);
        }
    }
}

public class Test {
    public static void main(String[] args) {
        String str="abc&def=hij";
        String[] strings=str.split("&|=");
        for(String s:strings){
            System.out.println(s);
        }
    }
}

 

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

注意事项:

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

多次拆分

public class Test {
    public static void main(String[] args) {
        String str="name=zhangsan&name=list";
        String[] strings=str.split("&");
        for(String s:strings){
            System.out.println(s);
            String[] ss=s.split("=");
            for(String x:ss){
                System.out.println(x);
            }
        }
    }
}

字符串截取

public class Test {
    public static void main(String[] args) {
        String str1="abcdef";
        //从指定下标开始进行截取
        String str2=str1.substring(1);
        System.out.println(str2);

        //从指定下标开始进行截取 截取到指定位置
        String str3=str1.substring(1,3);//[1,3)左闭右开
        System.out.println(str3);
    }
}

其他操作方法

public class Test {
    public static void main(String[] args) {
        String str1="      abc d eff   ";
        System.out.println(str1);
        String str2=str1.trim();
        System.out.println(str2);
    }
}

字符串的不可变性
 

String是一种不可变对象. 字符串中的内容是不可改变。字符串不可被修改，是因为：
1. String类在设计时就是不可改变的，String类实现描述中已经说明了
以下来自JDK1.8中String类的部分实现：

JDK17

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

2. 所有涉及到可能修改字符串内容的操作都是创建一个新对象，改变的是新对象
比如 replace 方法：

【纠正】网上有些人说：字符串不可变是因为其内部保存字符的数组被final修饰了，因此不能改变。这种说法是错误的，不是因为String类自身，或者其内部value被final修饰而不能被修改。

final修饰类表明该类不想被继承，final修饰引用类型表明该引用变量不能引用其他对象，但是其引用对象中的内容是可以修改的。

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

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

字符串修改

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

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

但是这种方式不推荐使用，因为其效率非常低，中间创建了好多临时对象。

public class Test {
    public static void main(String[] args) {
        String str="hello";
        StringBuilder stringBuilder=new StringBuilder();
        stringBuilder.append(str);
        stringBuilder.append("world");
        str=stringBuilder.toString();
        System.out.println(str);

        String str2="hello";
        for (int i = 0; i <1000 ; i++) {
            str2+=i;//内存耗费极大
        }
        System.out.println(str2);

        StringBuilder stringBuilder2=new StringBuilder();
        stringBuilder2.append(str2);
        for (int i = 0; i < 1000; i++) {
            stringBuilder2.append(i);
        }
        str2=stringBuilder2.toString();
        System.out.println();//效率大大提升
    }
}

StringBuilder和StringBuffer
 

StringBuilder的介绍
 

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

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

注意：String和StringBuilder类不能直接转换。如果要想互相转换，可以采用如下原则:
String变为StringBuilder: 利用StringBuilder的构造方法或append()方法。
StringBuilder变为String: 调用toString()方法。

面试题
 

1. String、StringBuffer、StringBuilder的区别

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

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

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

String类oj
 

第一个只出现一次的字符

class Solution {
    public int firstUniqChar(String s) {
        int[] count = new int[26];
        for (int i = 0; i < s.length(); ++i) {
            char ch = s.charAt(i);
            count[ch - 'a']++;
        }
        // 已经统计好了 再次遍历字符串
        for (int i = 0; i < s.length(); ++i) {
            char ch=s.charAt(i);
            if (count[ch - 'a'] == 1) {
                return i;
            }
        }
        return -1;// 没找到
    }
}

最后一个单词的长度

import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        String str = scan.nextLine();
        //1.直接调用分割方法->split方法
        // String[] ss=str.split(" ");
        // int len=ss[ss.length-1].length();
        // System.out.println(len);

        //2.lastIndexof->subString截取到7->求这个字符串的长度
        int index = str.lastIndexOf(" ");
        String ret = str.substring(index + 1);
        System.out.println(ret.length());

    }
}

检测字符串是否为回文

class Solution {
    public boolean isPalindrome(String s) {
        s = s.toLowerCase();

        int left = 0;
        int right = s.length() - 1;
        while (left < right) {
            while (left < right && !isCharacterNum(s.charAt(left))) {
                left++;
            }
            while (left < right && !isCharacterNum(s.charAt(right))) {
                right--;
            }
            // left下标 是合法的字符
            // right下标 是合法的字符
            if (s.charAt(left) == s.charAt(right)) {
                left++;
                right--;
            } else {
                return false;
            }
        }
        return true;
    }

    private boolean isCharacterNum(char ch) {
        if (Character.isDigit(ch) || Character.isLetter(ch)) {
            return true;
        }
        return false;
    }
}