String类

概述

字符串是被final修饰的类，无法继承

字符串是常量

字符串可以被共享

字符串的拼接

public static void method() {
    String s1 = "ab";
    // s2是字面量，在编译期间已经变成了"ab"
    String s2 = "a" + "b";
    // 在编译到这一行时，知道s3是"a"
    String s3 = "a";
    // 在编译这一行时候，只知道s3是String类型，不能确定其值
        /*
        相当于
        StringBuilder stringBuilder = new StringBuilder("a");
        // 拼接字符串
        stringBuilder.append("b");
        String s = stringBuilder.toString();
        System.out.println(s);
         */
    s3 += "b";

    System.out.println(s1);
    System.out.println(s2);
    System.out.println(s3);
    System.out.println(s1 == s2);// true
    System.out.println(s1 == s3);// false
}

public static void method() {
//        long startTime = new Date().getTime();
//        String str = "";
//        for (int i = 0; i < 100000; i++) {
//            str += "a";
//        }
//        long endTime = new Date().getTime();
//        System.out.println(endTime - startTime);

    long startTime = new Date().getTime();
    //记录开始时间
    StringBuilder stringBuilder = new StringBuilder();
    for (int i = 0; i < 10000000; i++) {
        stringBuilder.append("a");
    }
    String str = stringBuilder.toString();
    long endTime = new Date().getTime();
    //记录结束时间
    System.out.println(endTime - startTime);

}

3常用方法

1.根据索引获取对应的字符

public static void method() {
    //输出字符串中下标为1的字符
    String str = "abcd";
    char c1 = str.charAt(1);
    System.out.println(c1);
}

public static void method() {
    String str = "abcd";
    // 获取字符串的长度
    System.out.println(str.length());

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

 public static void method() {
    String str = "abcd";
    char c1 = str.charAt(1);//  ---> b
    System.out.println(c1);

    // 获取字符串的长度
    System.out.println(str.length());   //--->4
    // 把字符串转换成字符数组
    char[] chars = str.toCharArray();
    System.out.println(chars);      //--->abcd

    // 把字符数组转换成字符串
    char[] chs = {'h', 'e', 'l', 'l', 'o'};
//        String s = new String(chs);
    // 把字符数组的一部分转换成字符串
    // offset:表示截取字符数组的起始索引
    // count:截取的长度
    String s = new String(chs, 1, 3);// 新建字符串对象为数组，内容为原数组下标1-3指向的元素
    System.out.println(s);// --->ell
}

练习 1. 输入字符串和两个数字,按照输入的数字对字符串进行截取，并且要求包头不包尾

public static void method() {
    Scanner scanner = new Scanner(System.in);
    String str = scanner.next();
    int start = scanner.nextInt();
    int end = scanner.nextInt();
    if (start < 0 || start > end || end > str.length() || end < 0) {
        System.out.println("输入不合法");
        return;
    }
    // 把字符串转换成数组
    char[] chars = str.toCharArray();
    // 把字符数组中被选取的部分转化为字符串
    String s = new String(chars, start, end - start);
    System.out.println(s);
}

练习2:统计字符串中英文大写 小写 数字和其他字符的个数

public static void method() {
    // 统计字符串中英文大写 小写 数字和其他字符的个数
    System.out.println("请输入字符串");
    String str = new Scanner(System.in).next();
    // 定义变量  统计大写 小写  数字 其他字符
    int upperNum = 0;
    int lowerNum = 0;
    int num = 0;
    int otherNum = 0;
    // 获取每一个字符判断
    for (int i = 0; i < str.length(); i++) {
        char ch = str.charAt(i);
        if (ch >= 'A' && ch <= 'Z') {
            upperNum++;
        } else if (ch >= 'a' && ch <= 'z') {
            lowerNum++;
        } else if (ch >= '0' && ch <= '9') {
            num++;
        } else {
            otherNum++;
        }
    }
    System.out.println("大写字母有" + upperNum + "个");
    System.out.println("小写字母有" + lowerNum + "个");
    System.out.println("数字字符有" + num + "个");
    System.out.println("其他字符有" + otherNum + "个");
}

练习3:输入一个字符串，求其中数字的和

public static void method() {
    String str = new Scanner(System.in).next();
    int sum = 0;
    char[] chars = str.toCharArray();
    for (char aChar : chars) {
        // 判断是否是数字
        if (aChar >= '0' && aChar <= '9') {
            sum += (aChar - '0');
        }
    }
    System.out.println(sum);
}

练习:输入一个字符串，统计字符出现的次数。

public static void method() {
    // 输入一个字符串，统计字符出现的次数
    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;    //如果 bs[i] 为 true，则表示当前位置的字符已经统计过了，跳过本次循环，继续下一个字符。
        // 获取字符
        char ch = str.charAt(i);
        // 定义变量统计出现的次数
        int count = 0;
        for (int j = i; j < str.length(); j++) {
            if (str.charAt(j) == ch) {
                count++;
                bs[j] = true;
            }
        }
        System.out.println(ch + "出现了" + count + "次");
    }
}

常用方法

public static void method() {

    /*字符串是以字节数组形式存储
    在比较两个字符数组的时候，是进行逐位比较
            如果对应字符不相等返回的是字符之差
    如果字符相同，返回的是长度之差
    如果返回的是一个正数, 对象 > 参数
    如果返回的是一个负数，参数 > 对象
    System.out.println(str.compareTo(str1));
    */
    // 忽略大小写比较
    System.out.println(str.compareToIgnoreCase(str1));

    // 把字符串转换成大写
    System.out.println(str.toUpperCase());

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

    // 字符串的拼接  本质上是将两个字节数组合并成一个字节数组再转换成字符串返回
    System.out.println(str.concat("abc"));

    // 拼接字符串
    System.out.println(String.join("-", "谷丰硕", "尚马教育", "30", "男"));

    // 判断是否包含某一个字符串
    System.out.println(str.contains("ad"));

    // 比较字符串是否相等
    System.out.println("ABCD".equals(str1));

    // 忽略大小写比较字符串
    System.out.println("abcd".equalsIgnoreCase(str1));

    // 把字符串转换成字节数组
    // utf-8一个汉字占3个字节
    byte[] bytes = str.getBytes();
    System.out.println(str.length());
    System.out.println(bytes.length);

    // 指定编码来将字符串转换成数组
    // gbk 一个汉字占两个字节
    byte[] gbks = str.getBytes("gbk");
    System.out.println(gbks.length);

    // 将字节数组转换成字符串
    String s = new String(bytes, "utf-8");
    System.out.println(s);

    // 指定编码转换
    String gbk = new String(gbks, "GBK");
}

关键字: 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

练习:输入一个字符串和一个数字，数字表示字节的个数，按照指定的字节个数截取字符串(不要出现乱码),编码用gbk

public static void method() {
    // 输入一个字符串和一个数字，数字表示字节的个数，按照指定的字节个数截取字符串(不要出现乱码),编码用gbk
    Scanner scanner = new Scanner(System.in);
    String str = scanner.next();
    System.out.println("请输入要截取的字节");
    int n = scanner.nextInt();
    // 将字符串转换成字节数组
    byte[] bs = str.getBytes("gbk");

    // 按照用户指定的字节进行截取
    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);
}

常用方法

public static void method() {

    String str = "D:\\img\\sifangzhao\\me.png";
    // 同一个字符串的哈希码值是固定不变的
    System.out.println(str.hashCode());

    // 获取指定元素首次出现的索引,如果找不到返回-1
    System.out.println(str.indexOf('a', 1));
    System.out.println(str.indexOf("k"));

    String str1 = new String("abc");

    // 获取字符串的字面量
    System.out.println(str == str1.intern());

    // 判断字符串是否是空  判断底层数组长度是否是0
    System.out.println(str.isEmpty());

    // 判断字符串是否是空字符串或者全是空格
    System.out.println(str.isBlank());

    // 寻找对应字符最后一次出现的索引
    int index = str.lastIndexOf("a");
    System.out.println(index);

    // 从fromIndex开始依次向前找
    int index1 = str.lastIndexOf("a", 7);
    System.out.println(index1);

    String repeat = str.repeat(3);
    System.out.println(repeat);
    System.out.println(str.replace('a', 'A'));

    // 截取字符串 从beginIndex截取到最后
    String substring = str.substring(3);

    // 截取一部分，包头不包尾
    String substring = str.substring(3, 6);
    System.out.println(substring);

    System.out.println(str.substring(str.lastIndexOf("\\") + 1));

    // 生成验证码
    String code = UUID.randomUUID().toString().substring(0, 6);
    System.out.println(code);

    // 去除字符串两端空格
    String str2 = "     hello  我是   ";
    System.out.println(str2.trim());

    System.out.println(new Object());

    // 将对应的类型转换成字符串
    String s = String.valueOf(10);
    System.out.println(s);
    String s1 = String.valueOf(new Object());
    System.out.println(s1);
}