Java复习笔记-14

String

1 String

1.1常用方法

    public static void main(String[] args) throws UnsupportedEncodingException {
        // 使用第一个参数把后面的可变参数连接起来
        String str = String.join("-","张三","22","男","网络公司","火星");
        System.out.println(str);

        //以...结尾 判断字符串是否是指定的结尾
        String str1 = "nba";
        System.out.println(str1.endsWith(".jpg"));

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

        // 字符串比较相等要使用equals方法  equals方法是在逐位比较字节数组，只要有一个不相同就返回false
        System.out.println(str1.equals(new String("y")));

        // 忽略大小写比较 常用于验证码验证
        System.out.println(str1.equalsIgnoreCase("YpL"));

        // 将字符串转换成小写
        System.out.println(str1.toLowerCase());
        // 将字符串转换成大写
        System.out.println(str1.toUpperCase());

        // 将字符串转换成字节数组
        byte[] bytes = str1.getBytes();
        for (byte aByte : bytes) {
            System.out.println(aByte);
        }

        String str2 = "字符串";
        // 按照当前工程的默认编码进行转换
//        byte[] bytes1 = str2.getBytes();
        byte[] gbks = str2.getBytes("UTF-8");

        System.out.println(gbks.length);

        // 将字节数组转换成字符串
        // 按照当前工程默认编码进行重新编码
//        String s = new String(bytes1);
        // 指定编码格式对字节数组进行转换
//        String s = new String(gbks,"utf-8");
        // 参数二:要截取的起始索引
        // 参数三:要截取的长度
        String s = new String(gbks, 2, 6);
        System.out.println(s);
		// 打印当前项目的编码格式
        System.out.println(Charset.defaultCharset());
    }

字符串的 equals 方法源码中有 instanceof 关键字。

instanceof 用来判断类和对象的关系

格式

对象 instanceof 类/接口
只要这个对象的实际类型是类的子类或者类本身，或者是接口的实现类，就会返回true
否则返回false

1.2 练习

输入一个字符串和一个数字，数字表示字节的个数，按照指定的字节个数截取字符串(GBK)

GBK 一个汉字占两个字节

截取split 2 截 5 截取s 3 截

    private static void practice1() throws UnsupportedEncodingException {
//        输入一个字符串和一个数字，数字表示字节的个数，按照指定的字节个数截取字符串(GBK)
        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 subStr = new String(bs, 0, n, "gbk");
//        System.out.println(subStr);

        // 判断是否截取了半个字符
        int index = subStr.length() - 1;
        if (subStr.charAt(index) != str.charAt(index)){
            // 说明有乱码
            subStr = new String(bs,0,n - 1,"gbk");
        }
        System.out.println(subStr);

    }

1.3 常用方法

private static void demo2() {
        // String类中重写了hashCode
        // 对于字符串而言，哈希码值是固定不变的
        String str = "abccdcfefrefefe";
        System.out.println(str.hashCode());

        // 获取指定元素第一次出现的位置
        // 如果找不到 返回-1
//        System.out.println(str.indexOf('c'));
//        System.out.println(str.indexOf("ddd"));
        // 参数二表示从 哪一个索引开始向后找
        System.out.println(str.indexOf("fe",7));
        System.out.println(str.indexOf('c',3));

    }

1.4 练习

输入一个字符串和一个子串,打印这个子串在字符串中出现的所有的位置

private static void practice2() {
        // 输入一个字符串和一个子串,打印这个子串在字符串中出现的所有的位置
        Scanner scanner = new Scanner(System.in);
        String str = scanner.next();
        String subStr = scanner.next();

        int index = 0;

        while (index < str.length()){
            index = str.indexOf(subStr,index);
            if (index == -1)
                break;
            System.out.println(index);
            index++;
        }
    }

1.5 常用方法

    private static void demo3() {
        String str = "abc";
        //获取指定元素最后一次出现的索引
        // 参数二:是从当前索引依次往前找
        System.out.println(str.lastIndexOf('a',1));

        // intern 方法表示返回这个字符串的字面量
        System.out.println(str == new String("abc").intern());
        // get.. 获取   set...设置   has...有没有  is... 是不是
        // isEmpty 判断字符串是否是空字符串  空格是\u0000
        System.out.println("".isEmpty());
        // isBlank 判断字符串是否是空或者是否全部由空格组成
        System.out.println("   ".isBlank());
        // replace(替换)方法
        String str1 = "afefefgeg";
        System.out.println(str1.replace('e','+'));
        String str2 = "   hello   ";
        // trim和strip都是移除两端的空格
        System.out.println(str2.trim());
        System.out.println(str2.strip());
        // 移除左边的空格
        System.out.println(str2.stripLeading());
        // 移除右边的空格
        System.out.println(str2.stripTrailing());
        // 截取字符串  表示从索引3处开始向后截取字符串，一直截取到最后
        System.out.println(str1.substring(3));
        // 表示从索引1处截取到索引4处  包头不包尾  [1,4)
        System.out.println(str1.substring(1,4));

//        // valueOf是一个静态方法，是将各种类型的数据转换成字符串类型
//        System.out.println(String.join("-", "Tom", String.valueOf(age)));

        Object obj = new Object();
        String s = String.valueOf(obj);
        System.out.println(s);
    }

2 正则表达式

目标:把常用的正则表达式能够读懂即可。

2.1 使用Pattern类匹配正则表达式

private static void demo4() {
        // 正则表达式
        // 需求:判断一个字符串是否是 abc
        // 需要判断是否是指定规则的字符串
        String str = "feafeef";
        // 制定匹配的规则
        Pattern pattern = Pattern.compile("abc");
        // 将匹配的规则和要判断的字符串进行关联
        Matcher matcher = pattern.matcher(str);
        // 开始匹配,匹配成功结果是true，匹配失败结果是false
        boolean matches = matcher.matches();
        System.out.println(matches);
    }

private static void demo5() {
        // 匹配一个字符串  第一个字符 a/b/c  第二个字符 3/4/6/8  第三个字符 o/p/q
        String str = "b6q";
        Pattern pattern = Pattern.compile("[abc][3468][qop]");
        Matcher matcher = pattern.matcher(str);
        System.out.println(matcher.matches());
    }

2.2 String类的matches方法实现正则表达式

// 匹配一个字符串  第一个字符 a/b/c  第二个字符 3/4/6/8  第三个字符 o/p/q
System.out.println(str.matches("[abc][3468][qop]"));

2.2.1 []的使用

private static void demo5() {
        // 匹配一个字符串  第一个字符 a/b/c  第二个字符 3/4/6/8  第三个字符 o/p/q
        String str = "6";
//        Pattern pattern = Pattern.compile("[abc][3468][qop]");
//        Matcher matcher = pattern.matcher(str);
//        System.out.println(matcher.matches());
        // [] 代表一个占位符 里面是这个位置中可选的符号
        System.out.println(str.matches("[abc][3468][qop]"));

        // 判断由一个小写字母组成的字符串
        // []中的内容如果是连续的，可以使用-来连接
        System.out.println(str.matches("[a-m]"));
        // 判断由一个字母组成的字符串
        System.out.println(str.matches("[a-zA-Z]"));
        // 判断由一个数字组成的字符串
        System.out.println(str.matches("[0-9]"));
    // 判断由一个字符组成的字符串，这个字符不能是a/b/c
        System.out.println(str.matches("[^abc]"));
    }

2.2.2 常用符号

• 通配符 . 代表任意字符

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

• \d代表0-9 等价于[0-9]
• \D 非0-9 等价于

[^0-9]

• \s 空格字符
• \S 不是空格的字符

[^\s]

• \w 就是单词字符 [a-zA-Z_0-9]

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

2.2.3 数量词

private static void demo7() {
        String str = "09";
        // ab abb abbb abbbb...
        // + 是数量词 表示之前的字符至少出现一次  >= 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?"));
        // 注意:这三个数量词字符后面只能出现一次
    }

总结:

+   >=1
*   >=0
?   <=1

• 练习：

输入一个字符串，判断这个字符串是否是一个小数 --> 5.23 5.00 5.0000 0.24

00.23 – false 不是小数

10. ​ 不是小数

	private static void demo8() {
        // 输入一个字符串，判断这个字符串是否是一个小数
        String str = "-100.11";
        System.out.println(str.matches("-?[1-9]\\d*\\.\\d+") || str.matches("-?0\\.\\d+"));
    }

2.2.4 数量词2

	private static void demo9() {
        String str = "";
        // 匹配由5个数字组成的字符串  {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次
        System.out.println(str.matches("\\d{5,8}"));
    }

练习:

输入一个字符串作为密码:长度是8-12位，由大写字母/小写字母/数字/空格 这4种至少出现2种。

private static boolean checkPassword(String password){
        // 密码长度是8-12位
        if (!password.matches("[a-zA-Z0-9 ]{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;
    }

2.2.5 捕获组

private static void demo10() {
        String str = "afewfewf8fefefef9ef";
        // 判断一个字符串中是否出现了3个及以上的连续数字
        System.out.println(str.matches(".*\\d{3}.*"));

        // 判断字符串是否出现了2个及以上的数字
        System.out.println(str.matches(".*\\d.*\\d.*"));

        // 判断一个字符串是否含有2个及以上的g34t34gg
        System.out.println(str.matches(".*g34t34gg.*g34t34gg.*"));

        // 捕获组可以看作一个字符进行操作 使用()括起来即可
        // \\n 代表引用编号为n的捕获组
        System.out.println(str.matches(".*(g34t34gg).*\\1.*"));

        /**
         * 正则表达式会对捕获组进行自动的编号
         * 编号是从1开始计算的
         * 捕获组的编号是从  (   出现的位置开始计算
         * (A((BC)D(E))F)(G)
         * \\1   A((BC)D(E))F
         * \\2   (BC)D(E)
         * \\3   BC
         * \\4   E
         * \\5   G
         */

        // 判断叠字
        String str1 = "嘿嘿嘿嘿";
        System.out.println(str1.matches("(.)\\1+"));

        // AABB 高高兴兴  开开心心
        System.out.println(str1.matches("(.)\\1(.)\\2"));
        // ABAB 可笑可笑  妙哉妙哉  
        System.out.println(str1.matches("(..)\\1"));
        
        // ^  强制以这个字符开头
        // $  强制以这个字符结尾
    }