java-String笔记

1.String的基本概念

package com.yl.pdfdemo.day08.p1;

import org.junit.Test;

/**
 * @Author wfj
 * @Date 2021/5/8
 * @Description String的使用
 * @Version 1.0
 */

public class StringTest {
    /**
     * String:字符串，使用一对""引起来表示
     * 1.String声明为final,表明为不可被继承的
     * 2.String实现了Serializable,表示字符串是支持序列化的
     *          实现了Comparable接口，表示字符串可以比较大小
     * 3.String内部定义了final char[] value 用于存储字符串数据
     * 4.String代表不可变的字符序列，简称不可变性
     *  体现： 当对字符串重新赋值时，需要新指定内存区域赋值，不能使用原有的value进行赋值
     *        当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值
     *        当调用String的replace()方法修改指定的字符或者字符串时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值
     * 5.通过字面量的方式（区别于new）给一个字符串赋值，此时的字符串值声明在字符串常量池中
     * 6.字符串常量池中是不会存储相同内容的字符串的
     *
     * 面试题：String s = new String("abc")创建了几个对象
     *
     *  两个，一个是堆空间new的结构，另一个是char[]对应的常量池中的数据"abc"
     */
    @Test
    public void test1() {
        String s1 = "abc";//字面量
        String s2 = "abc";
        s1 = "hello";
        String s3 = "abc";
        System.out.println(s1);//hello
        System.out.println(s2);//abc
        System.out.println(s2 == s3);//true

        String s4 = "abc";
        s4 += "def";
        System.out.println(s2 == s4);//false

        String s5 = "abc";
        String s6 = s5.replace('a', 'g');
        System.out.println(s5);//abc
        System.out.println(s6);//gbc
    }

    /**
     * String的实例化方式：
     * 方式一：通过字面量定义的方式
     * 方式二：通过new + 构造器的方式
     */
    @Test
    public void test2() {
        //此时s1与s2的数据"vue"声明在方法区的字符串常量中
        String s1 = "vue";
        String s2 = "vue";
        System.out.println(s1 == s2);//true

        //此时s3何s4的地址值是保存在堆空间中
        String s3 = new String("java");
        String s4 = new String("java");
        System.out.println(s3 == s4);//false

        Person p1 = new Person("tom",18);
        Person p2 = new Person("tom",18);
        /**
         * 注意 String name;
         * name 存到是一个地址值，指向字符串常量池,tom,jerry这些数据是存在字符串常量池里的。
         */
        System.out.println(p1 == p2);//false
        System.out.println(p1.name.equals(p2.name));//true
        System.out.println(p1.name == p2.name);//true
        p1.name = "jerry";
        System.out.println(p2.name);//tom
        System.out.println(p1.name == p2.name);//false
    }

    @Test
    public void test3() {
        /**
         * 结论：
         * 1.常量与常量的拼接结果在常量池中，且常量池中不会存在相同的常量
         * 2.值要其中有一个是变量，结果就在堆中
         * 3.如果拼接的结果调用intern()方法，返回值就会在常量池中
         *
         */
        String s1 = "java";
        String s2 = "vue";

        String s3 = "javavue";
        String s4 = "java" + "vue";
        String s5 = s1 + "vue";
        String s6 = "java" + s2;
        String s7 = s1 + s2;
        System.out.println(s3 == s4);//true
        System.out.println(s3 == s5);//false
        System.out.println(s3 == s6);//false
        System.out.println(s5 == s6);//false
        System.out.println(s5 == s7);//false
        System.out.println(s6 == s7);//false
        String s8 = s5.intern();
        System.out.println(s3 == s8);//true
        //返回值得到的s8使用常量池中已经存在的"javavue"
    }
}

class Person {
    String name;
    int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

2.String的相关方法

package com.yl.pdfdemo.day08.p1;

import org.junit.Test;

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

/**
 * @Author wfj
 * @Date 2021/5/12
 * @Description String中的方法
 * @Version 1.0
 */

public class StringMethodTest {

    @Test
    public void test1() {
        String str = "HelloWorld";
        System.out.println(str.length());//返回字符串的长度
        System.out.println(str.charAt(0));//返回指定索引位置的字符
        System.out.println(str.isEmpty());//判断字符串时候为空字符串
        String s1 = str.toUpperCase();//转大写字母,str是不可变的，str仍为原来的内容
        System.out.println(s1);
        String s2 = str.toLowerCase();//转小写字母
        System.out.println(s2);
        String s3 = "   hello  vue    ";
        System.out.println("===" + s3 + "===");
        String s4 = s3.trim();//字符串前后去掉格，中间空格保留
        System.out.println(s4);
        String s5 = "HelloWorld";
        String s6 = "HELLOworld";
        //比较两个字符串的内容是否相等
        System.out.println(str.equals(s5));//true
        //比较两个字符串内容是否相等，忽略字母的大小写
        System.out.println(str.equalsIgnoreCase(s6));//true
        String str1 = "vue";
        //拼接两个字符串,等价于"+"
        String s7 = str.concat(str1);//"HelloWorldvue";
        System.out.println(s7);
        String s8 = "abc";
        String s9 = new String("abd");
        //比较两个字符串大小，为正数，代表s8比s9大，为负数，代表s8比s9小，等于0代表大小相等
        System.out.println(s8.compareTo(s9));//-1
        String s10 = str.substring(2);//从索引为2开始包含索引2截取到后面的所有内容

        String s11 = str.substring(0,3);//相等于[0,3),从索引为0包含索引0开始截取到索引为3不包含索引3的内容
        System.out.println(s10);
        System.out.println(s11);
    }

    @Test
    public void test2() {
        String str = "HelloWorld";
        //判断字符串是否以什么内容开头或者结束
        System.out.println(str.endsWith("HelloWorld"));//true
        System.out.println(str.endsWith("rld"));//true
        System.out.println(str.startsWith("He"));//true
        System.out.println(str.startsWith("HelloWorld"));//true
        //判断从第二个索引位置开始是否以ll开头
        System.out.println(str.startsWith("ll",2));//true
        String s1 = "Wor";
        //判断一个字符串是否包含另一个字符串
        System.out.println(str.contains(s1));//true
        //返回lo在str中第一次出现的索引位置，从左边开始搜索
        System.out.println(str.indexOf("lo"));//3
        //从第五个索引位置开始，查找是否有lol的内容
        System.out.println(str.indexOf("lol",6));//-1
        String s2 = "Hellorvvorld";
        //从右边往左边开始寻找
        System.out.println(s2.lastIndexOf("or"));//8
        System.out.println(s2.lastIndexOf("or",7));//4
    }

    @Test
    public void test3() {
        String s1 = "java  beauty  js java";
        //replace(),用新字符/字符串替换字符串中的内容
        String s2 = s1.replace('j','h');
        System.out.println(s2);//hava  beauty  hs hava
        String s3 = s1.replace("java","vue");
        System.out.println(s3);//vue  beauty  js vue
        //把字符串中的数字替换成,如果结果中开头结尾还有,的话，去掉,
        String s4 = "12hello34java56mysql78vue89";
        String s5 = s4.replaceAll("\\d+",",").replaceAll("^,|,$","");
        System.out.println(s5);
        String s6 = "12345";
        System.out.println(s6.matches("\\d+"));//是否全为数字
        //判断是否是一个固定电话
        String s7 = "0571-4534567";
        System.out.println(s7.matches("0571-\\d{7,8}"));
        String s8 = "java|vue|go";
        String[] strs = s8.split("\\|");
        for (String s : strs) {
            System.out.println(s);
        }
    }

    /**
     * String于char[]之间的相互转换
     */
    @Test
    public void test4() {
        String str = "abc123";
        //String =======> char[]
        char[] strArr = str.toCharArray();
        for (int i = 0; i < strArr.length; i++) {
            System.out.println(strArr[i]);
        }
        //char[] ======> String
        char[] arr1 = {'j','a','v','a'};
        String s1 = new String(arr1);
        System.out.println(s1);
    }

    /**
     * String与byte[]的相互转换
     */
    @Test
    public void test5() throws UnsupportedEncodingException {
        String str = "abc321清风";
        //String ===> byte[]
        byte[] bytes = str.getBytes();//使用默认的字符集进行转换
        System.out.println(Arrays.toString(bytes));//[97, 98, 99, 51, 50, 49, -26, -72, -123, -23, -93, -114]

        byte[] bytes1 = str.getBytes("gbk");//使用gbk字符集进行编码
        System.out.println(Arrays.toString(bytes1));//[97, 98, 99, 51, 50, 49, -57, -27, -73, -25]
        //byte ===> String
        String s1 = new String(bytes);
        System.out.println(s1);
        String s3 = new String(bytes);
        System.out.println(s3);//出现乱码
        String s2 = new String(bytes1,"gbk");//以什么字符集编码，就得以什么字符集解码
        System.out.println(s2);
    }
}

3.String的面试题

package com.yl.pdfdemo.day08.p1;

/**
 * @Author wfj
 * @Date 2021/5/12
 * @Description String面试题
 * @Version 1.0
 */

public class StringTest1 {
    String str = new String("java");
    char[] ch = new char[]{'t','e','s','t'};
    public void change(String str,char[] ch) {
        str = "test ok";
        ch[0] = 'b';
    }
    public static void main(String[] args) {
        StringTest1 test1 = new StringTest1();
        test1.change(test1.str,test1.ch);
        System.out.println(test1.str + "and");//javaand
        System.out.println(test1.ch);//best
    }
}

4.String的相关练习

package com.yl.pdfdemo.day08.p1;

import org.junit.Test;

/**
 * @Author wfj
 * @Date 2021/5/21
 * @Description String相关练习
 * @Version 1.0
 */

public class StringDemo {

    /**
     * 将部分字符串内容反转
     */
    public String reverse(String str, int startIndex, int endIndex) {
        if (str != null && str != "") {
            char[] strs = str.toCharArray();
            for (int x = startIndex, y = endIndex; x < y; x++,y--) {
                char temp = strs[x];
                strs[x] = strs[y];
                strs[y] = temp;
            }
            return new String(strs);
        }
        return null;
    }

    //方式二，使用String的拼接，来解决字符串内容反转
    public String reverse1(String str, int startIndex, int endIndex) {
        if (str != null && str != "") {
            String s1 = str.substring(0,startIndex);
            for (int i = endIndex; i >= startIndex; i--) {
                s1 += str.charAt(i);
            }
            s1 += str.substring(endIndex+1);
            return s1;
        }
        return null;
    }

    //方式三：使用StringBuilder/StringBuffer

    public String reverse2(String str, int startIndex, int endIndex) {
        if (str != null && str != "") {
            StringBuilder sb = new StringBuilder(str.length());
            //第一部分
            sb.append(str.substring(0,startIndex));
            //第二部分
            for (int i = endIndex; i >= startIndex; i--) {
                sb.append(str.charAt(i));
            }
            sb.append(str.substring(endIndex + 1));
            return sb.toString();
        }
       return null;
    }

    @Test
    public void testReverse() {
        String str = "abcdefg";
//        String reverse = reverse(str, 2, 5);
//        String reverse1 = reverse1(str, 2, 5);
        String reverse2 = reverse1(str, 2, 5);
        System.out.println(reverse2);
    }

    /**
     * 获取一个字符串在另外一个字符串出现的次数
     * @param mainStr
     * @param subStr
     * @return
     */
    public int getCount(String mainStr, String subStr) {
        //s1 = "ab" s2 = "hjhjhabsdsdsdaaaabll"
        int mainLength = mainStr.length();
        int subLength = subStr.length();
        int count = 0;
        int index = 0;
        if (mainLength >= subLength) {
//            while ((index = mainStr.indexOf(subStr)) != -1) {
                count++;
                mainStr = mainStr.substring(index + subLength);
            }
            while ((index = mainStr.indexOf(subStr,index)) != -1) {
                count++;
                index += subLength;
            }
            return count;
        } else {
            return 0;
        }
    }

    @Test
    public void testCount() {
        String mainStr = "hjhjhabsdsdsdaaaabll";
        String subStr = "ab";
        int count = getCount(mainStr, subStr);
        System.out.println(count);
    }

    /**
     * 获取两个字符串中最大相同子字串，比如：
     * str1 = abcdfdfhellofdfdf,str2 = kkjhelloaa
     * @param str1
     * @param str2
     * @return
     */
    public String getMaxNameString(String str1, String str2) {
        String maxStr = str1.length() >= str2.length() ? str1 : str2;
        String minStr = str1.length() < str2.length() ? str1 : str2;
        int length = minStr.length();
        for (int i = 0; i < length; i++) {
            for (int x = 0,y = length - i; y <= length; x++,y++) {
                String subStr = minStr.substring(x,y);
                if (maxStr.contains(subStr)) {
                    return subStr;
                }
            }
        }
        return null;
    }

    @Test
    public void testGetMxName() {
        String str1 = "abcdfdfhellofdfdf";
        String str2 = "lkkjhelloaa";
        String s = getMaxNameString(str1, str2);
        System.out.println(s);
    }
}
在这里插入代码片

5.StringBuilder和StringBuffer(重点)

package com.yl.pdfdemo.day08.p1;

import org.junit.Test;

/**
 * @Author wfj
 * @Date 2021/5/12
 * @Description 关于StringBuffer和StringBuilder
 * @Version 1.0
 */

public class StringBufferBuilder {
    /**
     * String、StringBuffer、StringBuilder的异同
     * String:jdk1.0 不可变的字符序列，底层使用char[]存储数据
     * StringBuffer:jdk1.0,可变的字符序列，线程安全的，效率低下，底层使用char[]存储数据
     * StringBuilder:jdk.15,可变的字符序列，线程不安全的，效率高，底层使用char[]存储数据
     * 效率： StringBuilder > StringBuffer > String
     *
     * 分析：
     * String s1 = new String();//char[] value = new char[0]
     * String s2 = new String("abc")//char[] value = new char[]{'a','b','c'}
     * StringBuffer sb = new StringBuffer()//char[] value = new char[16] 底层创建了一个容量为16的字符数组
     * System.out.println(sb.length())  ==> 0  这个长度只是取数组里元素有多少个，而不是取数组的长度
     * sb.append('a')//value[0] = 'a'
     * sb.append('b')//value[1] = 'b'
     *
     * StringBuffer sb1 = new StringBuffer("qq");//char[] value = new cha["abc".length() + 16]
     * System.out.println(sb1.length) //2
     *
     *  扩容问题：
     *      如果要添加的数据底层数组装不下了，那就需要扩容底层的数组，默认情况下扩容为原来容量的2倍+2，同时将原来数组的元素赋值到新的数组
     *
     *   所以开发中，如果没有涉及到线程安全问题，就用StringBuilder
     *   如果涉及到线程安全问题，就用StringBuffer
     *   最好都指定容量大小 new StringBuffer(int capacity)
     */

    @Test
    public void test1() {
        StringBuffer sb1 = new StringBuffer("abc");
        sb1.setCharAt(0,'g');
        System.out.println(sb1);//gbc
    }

    //StringBuffer中常用的方法
    @Test
    public void test2() {
        StringBuffer sb = new StringBuffer("abc");
        //append，添加元素
        sb.append(1);
        sb.append("e");
        sb.append('f');
        System.out.println(sb);//abc1ef
        //delete，删除指定索引范围内的元素[int start,int end)
//        sb.delete(2,4);
//        System.out.println(sb);//abef
        //replace,[int start,int end),替换开始索引到结束索引位置的内容
        sb.replace(2,4,"java");
        System.out.println(sb);//abjavaef
        //insert,在第二个索引的位置插入内容，原来的内容往后挪
        sb.insert(2,"vue");
        System.out.println(sb);//abvuejavaef
        //reverse() 反转
        sb.reverse();
        System.out.println(sb);//feavajeuvba
        System.out.println(sb.length());//11
        //截取元素[0,2)
        String s = sb.substring(0, 2);
        System.out.println(s);
        //获取索引0的元素
        System.out.println(sb.charAt(0));
        //setCharAt更换某个位置的元素
        sb.setCharAt(0,'p');
        System.out.println(sb);
    }
}