【JavaSE】搞定String类

前言

常用的三种字符串构造

    public static void main(String[] args) {
        //直接赋值的方法， 定义字符串
        String str1="abcdef";//简写形式
        String str2=new String("hello Word!");

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

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

String是引用类型，内部并不存储字符串本身

    // s1和s2引用的是不同对象 s1和s3引用的是同一对象
    String s1 = new String("hello");
    String s2 = new String("world");
    String s3 = s1;

字符串长度length

.length用于求字符长度

.isEmpty用于判断字符串是否为空

      String str1="abcdef";
      System.out.println(str1.length());//6

      String str2=null;
      System.out.println(str2);//null
      System.out.println(str1.length());//空指针异常

      String str3="";
      System.out.println(str3.length());//0
      System.out.println(str3.isEmpty());//用于判断字符串是否为空 返回true或false

字符串比较

==比较

注意：

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

下面代码结果是true还是false？

        String str1="abcdef";
        String str2="abcdef";
        System.out.println(str1==str2);

答案是true，解释如下

只要是双引号引起来的字符串常量，会存在一个字符串常量池中。

存储逻辑：先检查内存（字符串常量池）中是否有这个字符串；如果没有，存进去；如果有，直接去现有对象的即可。

上面代码str1先存在了字符串常量池中，str2不会在生成一个对象了，而是直接指向str1同一个对象。

不同上一题，下面代码结果是true还是false？

        String str3=new String("abcd");
        String str4=new String("abcd");
        System.out.println(str3==str4);

结果是false

因为这里是强制产生了两个不同的对象，位于两个不同的空间，所以str3和str4是两个不同的字符串，结果是false

比较字符串的内容equals

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

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

这里的结果两个都为true，equals比较的是两者的内容是否一致

忽略大小写比较equalsIgnoreCase

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

比较字符串大小compareTo

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

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

     String str1="abcde";
     String str2="edf";
     System.out.println(str1.compareTo(str2));

忽略大小写比较compareToIgnoreCase

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

获取字符串中某一个字符

        String str1="abcde";
        char ch=str1.charAt(2);
        System.out.println(ch);

通过字符获取下标indexOf

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

从指定位置开始找

        int index =str1.indexOf('a',2);//从2位置开始找a

从后的指定位置开始找lastIndexOf

        String str3="ababcabcd";
        int index3=str3.lastIndexOf('a',4);
        System.out.println(index3);//2

转化

数值和字符串转化valueOf

        String s1=String.valueOf(1234);
        String s2=String.valueOf(12.34);
        String s3=String.valueOf(true);

        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);

字符串转数值parseInt和parseDouble

        int data1=Integer.parseInt("1234");//用类调用的方法，说明parseInt是静态方法
        double data2=Double.parseDouble("23.34");
        System.out.println(data1+6);
        System.out.println(data2+6);

查看parseInt源码，他是被static修饰的

大小写转化toLowerCase和toUpperCase

        String str1="ABCD";//大写转小写
        String str2=str1.toLowerCase();//不是在原字符串本身进行修改（str1并没有改变，str2是产生的新的对象）
        System.out.println(str1);
        System.out.println(str2);

        String str3=str2.toUpperCase();//小写转大写
        System.out.println(str3);

将字符串转数组toCharArray

        String str1="ABCD";
        char[]array=str1.toCharArray();
        System.out.println(Arrays.toString(array));

格式化format

        String s=String.format("%d-%d-%d",2024,4,15);
        System.out.println(s);

字符串替换replace

有两种替换（replace的重载）

图中第一种是字符整体 替换，第二种是字符串整体替换

        String str1="abcdab";
        String ret=str1.replace('a','z');
        String ret2=str1.replace("ab","yiyi");
        System.out.println(ret);
        System.out.println(ret2);

替换字符串的第一个replaceFirst和整体替换replaceAll

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

        //字符串的整体替换
        String ret4=str1.replaceAll("ab","ttttt");
        System.out.println(ret4);

字符串拆分split

        //字符串拆分
        String s1="abc&tttt&hijk";
        String []str1=s1.split("&",2);//2表示最多分两组
        for (String s:str1) {
            System.out.println(s);
        }

注意：

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

代码示例

        String s2="2024.4.15";
        String []str2=s2.split("\\.");

        String s3="abc&pppp*hhhh";
        String []str3=s3.split("&|\\*");//用|表示将&和*分开，有这两个分隔符，用\\表示转义*

多次拆分

//多次拆分
        String str="name=zhangsan&name=lisi";
        String[]strings=str.split("&");
        for (String s:strings) {
            String []ss=s.split("=");
            for (String x:ss) {
                System.out.println(x);
            }
        }

字符串截取substring

        //字符串截取
        String s1="abcdrrrr";
        //从指定下标开始一直往下截取
        String s2=s1.substring(1);
        System.out.println(s2);


        //截取目标下标下的字符串
        String s3=s1.substring(2,5);//左闭右开[2,5）
        System.out.println(s3);

去掉字符串左右两边的空格trim

       String s1="    ab s c   d    f    ";
        System.out.println(s1);
        String s2=s1.trim();//去掉字符串左右两边的空格
        System.out.println(s2);

字符串不可变性

字符串String类的源码中，value的值被final修饰，不能发生改变（value指向不能发生改变 ），但它指向的对象的内容是可以修改的

又因为value被private封装了，源码中有没有get和set方法，使得字符串具有不可变性。

例如下面代码中数组array被final修饰

        final int[]array=new int[]{1,3,4};
        array=new int[]{1,3,6};//报错
        array[0]=99;//可以修改

所以字符串实际上是不能被修改的。

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

字符串拼接

由于String的不可更改特性，为了方便字符串的修改，Java中又提供StringBuilder和StringBuﬀer类。这两个类大部分功能是相同的。以下演示StringBuilder

StringBuilde用于在原字符串上拼接字符串

        StringBuilder stringBuilder=new StringBuilder("abcd");
        stringBuilder.append("yyyyyyy");

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

String、StringBuﬀer、StringBuilder的区别

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