String

String

1 String的特点

String是一个最终类，是一个常量，创建之后不能更改。

底层是一个字节数组，数组被final修饰，地址不能改变

public static void main(String[] args) {
        StringBuilder stringBuilder = new StringBuilder("a");
        String s = stringBuilder.append("b").append("c").toString();
        System.out.println(s);
    }

    private static void demo1() {
        String s1 = "ab";
        String s2 = "a" + "b";
        String s3 = "a";
        s3 += "b";
        // s3 += "b"; 相当于 
        // s3 = new StringBuilder(s3).append("b").toString;
        System.out.println(s1 == s2);// true
        System.out.println(s1 == s3);// false
    }

    private static void demo() {
        String str1 = "abc";
        String str2 = "abc";
        String str3 = new String("abc");
        System.out.println(str1 == str2);// true
        System.out.println(str1 == str3);// false
    }

2 StringBuilder和String面试题

    public static void main(String[] args) {
        // 计算机元年到当前时间的毫秒值
        long begin = System.currentTimeMillis();
//        String str = "";
//        for (int i = 0; i < 1000000; i++) {
//            str += "a";
//        }
        // OutOfMemoryError 堆内存溢出
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 100000000; i++) {
            sb.append("a");
        }
        String str = sb.toString();
        long end = System.currentTimeMillis();
        System.out.println(end - begin);
    }

3 String的常用方法

String str = "abc";
        // StringIndexOutOfBoundsException 字符串越界异常
        // 获取指定索引处的字符
        char c = str.charAt(1);
        System.out.println(c);

        // 获取字符串的长度
        int length = str.length();
        System.out.println(length);

        // 将字符串转换成字符数组
        char[] charArray = str.toCharArray();
        System.out.println(charArray);

        char[] cs = {'h','e','l','l','o'};
        // 将字符数组转换成字符串
        String s = new String(cs);
        System.out.println(s);
        // 将字符数组的一部分转换成字符串
        // offset:起始位置
        // count:长度
        String s1 = new String(cs, 0, 3);
        System.out.println(s1);

课堂练习:输入一个字符串以及两个数字，按照输入的数字对字符串进行截取

abcdefg 2 5 -->cde 要求包头不包尾

		Scanner scanner = new Scanner(System.in);
        String str = scanner.next();
        int begin = scanner.nextInt();
        int end = scanner.nextInt();
        if (begin < 0 || end > str.length() || begin > end) return;

        char[] charArray = str.toCharArray();
        String s = new String(charArray, begin, end - begin);
        System.out.println(s);

统计字符串中大写、小写、数字字符的个数

sdfGEdfg87945

// 统计字符串中大写、小写、数字字符的个数
        Scanner scanner = new Scanner(System.in);
        String str = scanner.next();

        int upperCount = 0;
        int lowerCount = 0;
        int numCount = 0;
        // 遍历字符串
        for (int i = 0;i < str.length();i++){
            char c = str.charAt(i);
            // 大写字母
            if (c >= 'A' && c <= 'Z'){
                upperCount++;
            }else if (c >= 'a' && c <= 'z'){
                lowerCount++;
            }else if (c >= '0' && c <= '9'){
                numCount++;
            }
        }
        System.out.println("大写字母有" + upperCount + "个");
        System.out.println("小写字母有" + lowerCount + "个");
        System.out.println("数字字母有" + numCount + "个");

输入一个字符串，提取其中的数字并求和

grgr8gthg7hrgr6gr 8 + 7 + 6 = 21

// 输入一个字符串，提取其中的数字并求和
        Scanner scanner = new Scanner(System.in);
        String str = scanner.next();
        // 记录和
        int sum = 0;

        char[] charArray = str.toCharArray();
        for (char c : charArray) {
            if (c >= '0' && c <= '9'){
                sum += (c - '0');
            }
        }

        System.out.println(sum);

输入一个字符串，统计每一个字符出现的次数

aaabbccccd

// 输入一个字符串，统计每一个字符出现的次数
        Scanner scanner = new Scanner(System.in);
        String str = scanner.next();
        // 定义一个布尔数组，存放标记
        boolean[] bs = new boolean[str.length()];
        for (int i = 0; i < bs.length; i++) {
            // 判断是否被统计过
            if (bs[i]) continue;

            // 获取字符
            char c = str.charAt(i);
            // 定义出现的次数
            int count = 0;
            // 从i位置开始向后比较
            for (int j = i;j < str.length();j++){
                if (str.charAt(j) == c){
                    count++;
                    bs[j] = true;
                }
            }
            System.out.println(c + ":" + count);
        }

• compareTo方法

public static void main(String[] args) {
        String str1 = "abc";
        String str2 = "ABC";
        // 逐位比较字符是否相等，如果不相等，返回字符之差
        // 如果字符都相等，返回长度之差
        int i = str1.compareTo(str2);
        System.out.println(i);
        // 忽略大小写 去比较
        int j = str1.compareToIgnoreCase(str2);
        System.out.println(j);
    }

• 常用方法

        String str1 = "D:\\aa\\bb\\helloworld.txt";
        String str2 = "ABC";
        // 逐位比较字符是否相等，如果不相等，返回字符之差
        // 如果字符都相等，返回长度之差
        int i = str1.compareTo(str2);
        System.out.println(i);
        // 忽略大小写 去比较
        int j = str1.compareToIgnoreCase(str2);
        System.out.println(j);

        // 拼接字符串
        String concat = str1.concat("hello");
        System.out.println(concat);

        // 判断字符串是否为空
        boolean empty = str1.isEmpty();
        System.out.println(empty);
        // 判断字符串是否为空  如果字符串中都是空格或者制表符  也认为是空
        boolean blank = str1.isBlank();
        System.out.println(blank);
        // 拼接字符串
        String s = String.join("-", "谷丰硕", "18", "尚马教育");
        System.out.println(s);

        // 判断是否包含某个字符串
        boolean contains = str1.contains("bc");
        System.out.println(contains);

        // 判断是否是以...结尾
        boolean endsWith = str1.endsWith(".txt");
        System.out.println(endsWith);

        // 判断是否是以...开头
        boolean startsWith = str1.startsWith("http://");
        System.out.println(startsWith);

        // 判断字符串是否相等
        boolean equals = "abc".equals(new String("abc"));
        System.out.println(equals);
        // 忽略大小写判断字符串是否相等
        System.out.println("abc".equalsIgnoreCase("ABC"));

instanceof是一个关键字，用来判断类和对象的关系

对象 instanceof 类/接口 --- 只要这个对象的实际类型是后面的类或者类的子类，或者接口的实现类，那么就返回true

interface A{}
class B implements A{}
class C extends B{}
class D extends C{}

C c = new D();
c instanceof A  -- true
c instanceof B  -- true
c instanceof C  -- true
c instanceof D  -- true
   

// 模式匹配  jdk17特性
        Object obj = "abc";
        if (obj instanceof  String s){
            s.endsWith("");
        }else if (obj instanceof Scanner s){

        }

`

• 常用方法

String str3 = "羊肉串";
        // 按照当前工程的默认编码转换成字节数组
//        byte[] bytes = str3.getBytes();
        byte[] bytes = str3.getBytes("gbk");
        System.out.println(bytes.length);
        // *** ***
        // 按照当前工程的默认编码把字节数组转换成字符串
//        String s1 = new String(bytes,"GBK");
        // 指定编码转换字节数组的一部分内容
        // offset 起始索引
        // length 截取的长度
        // charsetName:编码
        String s1 = new String(bytes,1,3,"GBK");
        System.out.println(s1);

课堂练习:输入一个字符串和一个数字，数字表示字节的个数，按照指定的字节个数截取字符串,使用GBK码表

截取abcde 3 截

// 输入一个字符串和一个数字，数字表示字节的个数，按照指定的字节个数截取字符串,使用GBK码表
    private static void demo7() throws UnsupportedEncodingException {
        Scanner scanner = new Scanner(System.in);
        String str = scanner.next();
        int n = scanner.nextInt();
        // 先将字符串转换成字节数组
        byte[] bs = str.getBytes("gbk");
        if (n < 0 || n > bs.length) return;
        // 按照指定的字节个数进行截取
        String sub = new String(bs,0,n,"gbk");
        // 判断是否截取了半个字符
        int index = sub.length() - 1;
        if (sub.charAt(index) != str.charAt(index)){
            sub = new String(bs,0,n - 1,"gbk");
        }
        System.out.println(sub);
    }

// 字符串的哈希码值是固定不变的
        String str = "rgergerdger";
        System.out.println(str.hashCode());
        // 获取指定字符/字符串首次出现的索引
        System.out.println(str.indexOf('q'));
        System.out.println(str.indexOf("er"));
        // 从指定索引处开始向后找字符串首次出现的索引 找不到返回-1
        System.out.println(str.indexOf("er",3));
        // 获取指定字符/字符串最后一次出现的索引
        int i = str.lastIndexOf('e');
        int j = str.lastIndexOf('e',4);
        System.out.println(j);

课堂练习:输入一个字符串和一个子串，打印这个子串在字符串中出现的所有的位置

Scanner scanner = new Scanner(System.in);
        String str = scanner.next();
        String subStr = scanner.next();
        // ddabcabcabc
        // abc
        int index = 0;
        while (index < str.length()){
            index = str.indexOf(subStr,index);
            if (index != -1){
                System.out.println(index);
                index++;
            }else {
                break;
            }
        }

• 常用方法

String str1 = "  hello world  ";
        String str2 = new String("abc");
        // 返回字符串的字面量
        String intern = str2.intern();
        System.out.println(str1 == intern);

        // 把字符串重复count次
        System.out.println(str1.repeat(3));
        // 替换字符或者字符串
        System.out.println(str1.replace('a','+'));
        System.out.println(str1.replace("a",""));
        // 截取字符串
        System.out.println(str1.substring(1));
        // 从beginIndex截取到endIndex  包头不包围
        System.out.println(str1.substring(1, 3));

        String substring = str1.substring(str1.lastIndexOf("\\") + 1);
        System.out.println(substring);
        // 快速生成验证码
        String code = UUID.randomUUID().toString().substring(0, 6);
        System.out.println(code);
        // 把字符串转换成小写
        System.out.println(str1.toLowerCase());
        // 把字符串转换成大写
        System.out.println(str1.toUpperCase());
        // 去除字符串两端空格
        String trim = str1.trim();
        System.out.println(trim);

        // 把不同的类型转换成字符串
        String s = String.valueOf(20);
        System.out.println(new Object());

4 正则表达式

基本用法

public static void main(String[] args) {
        // 判断一个字符串是否是abc
        String str = "\\";
        // 指定规则
//        Pattern pattern = Pattern.compile("abc");
//        // 将规则和要判断的字符串进行关联
//        Matcher matcher = pattern.matcher(str);
//        // 进行判断
//        boolean matches = matcher.matches();
//        System.out.println(matches);

        // 匹配字符串
        // 要求 第一个字符  a/b/c  第二个字符  3/4/6/7   第三个字符  o/q/w
//        Pattern pattern = Pattern.compile("[abc][3467][oqw]");
//        Matcher matcher = pattern.matcher(str);
//        System.out.println(matcher.matches());
        boolean matches = str.matches("[abc][3467][oqw]");
        System.out.println(matches);

        // 匹配由一个小写字母组成的字符串
        System.out.println(str.matches("[a-z]"));
        // 匹配由一个英文字母组成的字符串 [m-q]
        System.out.println(str.matches("[a-zA-Z]"));
        // 匹配数字
        System.out.println(str.matches("[0-9]"));
        // 匹配由一个字符组成的字符串，这个字符不是a/b/c
        System.out.println(str.matches("[^abc]"));

        // 匹配任意字符
        System.out.println(str.matches("."));
        // 匹配由3个字符组成的字符串 开头是数字  结尾是字母
        System.out.println(str.matches("[0-9].[a-zA-Z]"));

        // 匹配 .
        System.out.println(str.matches("\\."));
        // 匹配 \
        System.out.println(str.matches("\\\\"));
    }

数量词

// 判断一个字符串是否是abc
        String str = "75uhj5thj5theh8";
        // ab  abb abbb abbbb....
        // + 表示之前的字符至少出现1次    >= 1
        System.out.println(str.matches("ab+"));
        // 匹配由字母开头后续是数字的字符串
        System.out.println(str.matches("[a-zA-Z]\\d+"));
        // 由数字作为开头和结尾的字符串
        // * 表示之前的字符可有可无  >= 0
        System.out.println(str.matches("\\d.*\\d"));
        // 匹配一个不超过两位的数字组成的字符串
        // ? 表示之前的字符最多出现一次   <= 1
        System.out.println(str.matches("\\d\\d?"));

课堂练习:输入一个字符串，判断这个字符串是否是一个小数

System.out.println(str.matches("-?0\\.\\d+") | str.matches("-?[1-9]\\d*\\.\\d+"));
        System.out.println(str.matches("-?0\\.\\d+|-?[1-9]\\d*\\.\\d+"));

数量词2

// 匹配由5个数字组成的字符串
        // {n} 表示这个字符出现恰好n次    == n
        System.out.println(str.matches("\\d{5}"));
        // 匹配由至少5个数字组成的字符串
        // {n,} 表示这个字符至少出现n次   >= n
        System.out.println(str.matches("\\d{5,}"));
        // 匹配由5-8个数字组成的字符串
        // {n,m} 表示这个字符出现至少n次，但不超过m次   n <=  x  <= m
        System.out.println(str.matches("\\d{5,8}"));
        
        // 判断一个字符串是否连续出现了3个及以上的数字
        System.out.println(str.matches(".*\\d{3}.*"));
        // 判断字符串中是否出现了2个及以上的数字
        System.out.println(str.matches(".*\\d.*\\d.*"));

课堂练习:输入一个字符串作为密码，长度要求是8-12位，大写字母、小写字母、数字、空格至少出现2种

public static boolean checkPassword(String password){
        
        // 密码长度是8-12位
        if (!password.matches("[a-zA-Z\\d ]{8,12}")){
            return false;
        }
        
        // 定义变量，记录出现的字符的种类
        int count = 0;
        // 判断是否出现了小写字母
        if (password.matches(".*[a-z].*")){
            count++;
        }
        // 判断是否出现了大写字母
        if (password.matches(".*[A-Z].*")){
            count++;
        }
        // 判断是否出现了数字
        if (password.matches(".*\\d.*")){
            count++;
        }
        // 判断是否出现了空格
        if (password.matches(".* .*")){
            count++;
        }
        return count >= 2;
    }

捕获组

        // 判断一个字符串是否是abc
        String str = "小龙女  欧阳锋      杨过  尹志平";
        // 判断一个字符串是否包含2个及以上的54h54h56g6yht
        // () 在正则中表示一个捕获组
        // 捕获组可以看作一个字符进行操作
        // \\n  表示引用编号为n的捕获组
        // 捕获组的编号是从1开始计算的
        // 捕获组的编号是从 ( 出现的位置开始计算的
        // (A((BC)D(E))F)(G)
        // \\1   A((BC)D(E))F
        // \\2   (BC)D(E)
        // \\3   BC
        // \\4   E
        // \\5   G
        System.out.println(str.matches(".*(54h54h56g6yht).*\\1.*"));
        // 判断叠字
        System.out.println(str.matches("(.)\\1+"));
        // AABB结构
        System.out.println(str.matches("(.)\\1(.)\\2"));
        // ABAB结构
        System.out.println(str.matches("(..)\\1"));

        // 替换第一个出现的字符串
//        str = str.replaceFirst("\\d","+");
        // 替换所有的数字
//        str = str.replaceAll("\\d","-");
        System.out.println(str);

        // 提取字符串中所有的数字
        System.out.println(str.replaceAll("\\D",""));
        // 交换字符串的内容
        System.out.println(str.replaceAll("(.*)(欧阳锋)(.*)(尹志平)","$1$4$3$2"));

        String str1 = "我我我我我我我我我我我爱爱爱爱爱爱爱爱爱爱顶顶顶顶珍珍珍珍珍珍珍珍";
        System.out.println(str1.replaceAll("(.)\\1+","$1"));

• 练习:统计字符出现的次数

public static void main(String[] args) {
        //fesgreregfagasf
        Scanner scanner = new Scanner(System.in);
        String str = scanner.next();
        // 如果字符串有内容，那么就继续替换
        while (str.length() != 0){
            // 替换字符串的内容

            // 获取替换之前字符串的长度
            int len = str.length();
            // 获取字符串的第一个字符
            char c = str.charAt(0);

            str = str.replaceAll(c + "","");
            System.out.println("字符" + c + "出现的个数为" + (len - str.length()));
        }
    }

public static void main(String[] args) {
        String str = "1greg47grgtr6hrger3erg";
        String[] split = str.split("\\d");
        /// 如果边界符在结尾，会被直接切掉
        // 如果两个边界符相连，会切出一个""
        // 在最左边的边界符，有几个切几个""
        for (String s : split) {
            System.out.println(s);
        }
    }