15.常用类--String类的声明及常用方法

String对象的部分创建方式，具体可查看Java源代码

String中的一些常用方法

package com.senior.classuse;

import org.junit.Test;

import java.util.Locale;

/**
 * String的相关操作
 *
 * @author eden
 * @create projectTest:2021-05-11-13:54
 */
public class UseStringClass {
    /*
     * 1.String的源代码中声明为final的，因此不可被继承
     * 2.通过字面量（区别于new）的方式声明定义一个string，其内存存放在方法池的字符常量池中
     *   而字符常量池是不会存储两个内容完全相同的string的。
     * 3.当对string进行重新赋值时，底层实际上并不是在原有的string基础上进行赋值，而是开辟
     *   一个新的内存空间生成一个新值的string并指向目标对象。因为其底层定义的是
     *   final char[] value;来存储数据，final类型的数据不可更改
     * 4.当对当前string进行连接操作时，也需要重新开辟内存空间进行新的赋值。
     * 5.当使用replace()方法对字符或字符串进行修改时，也需要重新开辟内存空间进行新的赋值。
     * */
    @Test
    public void test1() {
        String s1 = "abc";
        String s2 = "123";
        String s3 = "123";
        System.out.println(s2 == s3); //true:s2 s3指向字符常量池中的同一块地址
        s1 = s2;
        System.out.println(s1);
        System.out.println("-------------------------");

        String s4 = "abd";
        String s5 = "abd";
        System.out.println(s4 == s5);
        s5 = s5.replace("d", "e");
        System.out.println(s4);
        System.out.println(s5);
        System.out.println(s4 == s5);


    }


    /*
     * String的声明方式
     * 方式一：new
     * 方式二：字面量的方式
     * String s = new String("abc");这种方式创建对象，在内存中实际上是创建了两个对象。
     *       一个对象在堆空间中，一个对象在方法区的常量池中。
     * */
    @Test
    public void test2() {
        String s1 = "abc";//存放在方法区的字符常量池中
        String s2 = "abc";//存放在方法区的字符常量池中
        String s3 = new String("abc");//存放在堆空间中
        String s4 = new String("abc");//存放在堆空间中

        System.out.println(s1 == s2); //T
        System.out.println(s2 == s3); //F
        System.out.println(s3 == s4); //F

    }

    /*
     * 理解不同声明String的方式的内存结构
     * 如下所述：s3 s4都属于在方法区声明的字符串常量，因此是相等的
     * s5 s6这些，只要在定义时含有变量的，其本质实际上是进行了new操作。
     * 只要有一个变量就一定在堆空间中。
     * 以s5为例，s5在堆空间中申请了一块内存，用来存储javaEE这个常量，
     * 也就是s5保留的是堆空间的这块内存的地址，而堆空间的这块内存的地址中
     * 保存的是这个常量在方法区中的存储地址。
     * */
    @Test
    public void test3() {
        String s1 = "java";
        String s2 = "EE";
        String s3 = "javaEE";
        String s4 = "java" + "EE";
        String s5 = s1 + "EE";
        String s6 = "java" + s2;

        System.out.println(s3 == s4); //T
        System.out.println(s3 == s5); //F
        System.out.println(s5 == s6); //F

        /*
         * String.intern(): 返回的是在方法区字符常量池的字符串
         * */
        String s7 = s5.intern();
        System.out.println(s7 == s3); //true
    }

    /*
     * int length()： 返回字符串的长度： return value.length
     * char charAt(int index)： 返回某索引处的字符return value[index]
     * boolean isEmpty()： 判断是否是空字符串： return value.length == 0
     * String toLowerCase()： 使用默认语言环境， 将 String 中的所有字符转换为小写
     * String toUpperCase()： 使用默认语言环境， 将 String 中的所有字符转换为大写
     * String trim()： 返回字符串的副本， 忽略前导空白和尾部空白,中间空白不变
     * boolean equals(Object obj)： 比较字符串的内容是否相同
     * boolean equalsIgnoreCase(String anotherString)： 与equals方法类似， 忽略大小写
     * String concat(String str)： 将指定字符串连接到此字符串的结尾。 等价于用“+”
     * int compareTo(String anotherString)： 比较两个字符串的大小
     * String substring(int beginIndex)： 返回一个新的字符串，
     *       它是此字符串的从beginIndex开始截取到最后的一个子字符串。
     * String substring(int beginIndex, int endIndex) ： 返回一个新字符串，
     *       它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。
     *        左闭右开区间
     *
     * */
    @Test
    public void test4() {
        String str = "HelloWorld";
        System.out.println(str);//HelloWorld
        System.out.println(str.length());//10
        System.out.println(str.charAt(str.length() - 1));//d
        System.out.println(str.isEmpty());//false
        System.out.println(str.toLowerCase(Locale.ROOT));//helloworld
        System.out.println(str.toUpperCase(Locale.ROOT));//HELLOWORLD
        System.out.println(str);//HelloWorld
        String str1 = " HelloWorld ".trim();
        System.out.println("---");
        System.out.println(str1);
        str1 = "helloWorld";
        System.out.println(str.equals(str1));//false
        System.out.println(str.equalsIgnoreCase(str1));//true
        System.out.println(str.concat(str1));//HelloWorldhelloWorld
        String str2 = "A";
        String str3 = "c";
        System.out.println(str3.compareTo(str2));//34
        System.out.println(str);//HelloWorld
        System.out.println(str1);//helloWorld
        System.out.println(str1.substring(5));//World
        System.out.println(str1.substring(2, 5));//llo


    }

    /*
    * boolean endsWith(String suffix)： 测试此字符串是否以指定的后缀结束
    * boolean startsWith(String prefix)： 测试此字符串是否以指定的前缀开始
    * boolean startsWith(String prefix, int toffset)： 测试此字符串从指定索引开始的
    *       子字符串是否以指定前缀开始
    * boolean contains(CharSequence s)： 当且仅当此字符串包含指定的 char 值序列时，返回 true
    * int indexOf(String str)： 返回指定子字符串在此字符串中第一次出现处的索引
    * int indexOf(String str, int fromIndex)： 返回指定子字符串在此字符串中第一次出
    *       现处的索引，从指定的索引开始
    * int lastIndexOf(String str)： 返回指定子字符串在此字符串中最右边出现处的索引
    * int lastIndexOf(String str, int fromIndex)： 返回指定子字符串在此字符串中最后一次出现处的索引，
    *       从指定的索引开始反向搜索
    * 注： indexOf和lastIndexOf方法如果未找到都是返回-1
    * */
    @Test
    public void test5(){
        String str = "HelloWorld";
        System.out.println(str);
        System.out.println(str.endsWith("World"));//true
        System.out.println(str.startsWith("he"));//false
        System.out.println(str.startsWith("ll", 2));//true

        System.out.println(str.contains("llow"));//false
        System.out.println(str.indexOf("l")); //2 第一次出现l的位置
        System.out.println(str.indexOf("l", 5));//8
        System.out.println(str.lastIndexOf("l"));//8
        System.out.println(str.lastIndexOf("llo", 7));//2 从索引7的位置开始反向搜索,返回正向索引

    }

    /*
    * 替换：
    * String replace(char oldChar, char newChar)： 返回一个新的字符串， 它是
    *       通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
    * String replace(CharSequence target, CharSequence replacement)： 使
    *       用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。
    * String replaceAll(String regex, String replacement) ： 使 用 给 定 的
    *       replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
    * String replaceFirst(String regex, String replacement) ： 使 用 给 定 的
    *       replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
    * 匹配
    * regex是正则表达式的意思
    * boolean matches(String regex)： 告知此字符串是否匹配给定的正则表达式。
    * 切片
    * String[] split(String regex)： 根据给定正则表达式的匹配拆分此字符串。
    * String[] split(String regex, int limit)： 根据匹配给定的正则表达式来拆分此
    *       字符串， 最多不超过limit个， 如果超过了， 剩下的全部都放到最后一个元素中。
    * */
    @Test
    public void test6(){
        String str = "HelloJavaHello";
        String str2 = str.replace("He", "G");
        System.out.println(str);//HelloJavaHello
        System.out.println(str2);//GlloJavaGllo

        str = "12hello34world5java7891mysql456";
        //把字符串中的数字替换成,，如果结果中开头和结尾有，的话去掉
        String string = str.replaceAll("\\d+", ",").replaceAll("^,|,$", "");
        System.out.println(string);//hello,world,java,mysql

        str = "12345";
        //判断str字符串中是否全部有数字组成，即有1-n个数字组成
        boolean matches = str.matches("\\d+");
        System.out.println(matches);//true
        String tel = "0571-4534289";
        //判断这是否是一个杭州的固定电话
        boolean result = tel.matches("0571-\\d{7,8}");
        System.out.println(result);//true

        //分割
        str = "hello|world|java";
        String[] strs = str.split("\\|");
        for (int i = 0; i < strs.length; i++) {
            System.out.println(strs[i]);
        }
        System.out.println();
        str2 = "hello.world.java";
        String[] strs2 = str2.split("\\.");
        for (int i = 0; i < strs2.length; i++) {
            System.out.println(strs2[i]);
        }
    }
}

该博客图片来源于尚硅谷宋老师教学课件