Java学习第八天

全栈小精灵

于 2024-10-02 20:51:06 发布

阅读量396

点赞数 6

文章标签： java 学习开发语言

本文链接：https://blog.csdn.net/Y_Y1230704/article/details/142673083

版权

2.2StringBuilder的构造方法

2.3StringBuilder的常用成员方法

2.4.1案例回文字符

2.4.2案例数组转换字符串

2.5String、StringBuffer、StringBuilder的区别

1.String类

1.1特点

String类的特点 :
        1. Java 程序中所有双引号字符串, 都是String这个类的对象
        2. 字符串一旦被创建, 就不可更改, 字符串内容不可改变 如果想要更改, 只能使用新的对象, 做替换
        3. String字符串虽然不可改变, 但是可以被共享
        字符串常量池: 当我们使用双引号创建字符串对象时, 会检查常量池中是否存在该数据
        不存在 : 创建
        存在 : 复用

public class StringDemo {
    public static void main(String[] args) {
        String s="abc";
        System.out.println(s.toUpperCase());
        System.out.println("abc".toUpperCase());
    }
}

public static void main(String[] args) {
        String s1 = "abc";
        String s2 = "abc";
        System.out.println(s1 == s2);
    }

1.2构造方法

String类常见构造方法 :
public String() : 创建一个空白字符串, 里面不含任何内容
public String(char[] chs) : 根据传入的字符数组, 创建字符串对象
public String(String original) : 根据传入的字符串, 来创建字符串对象
        -----------------------------------------------------------------
        1. 打印对象名, 会看到对象的内存地址, 这里打印字符串对象, 为什么没有看到地址值
        回答: 暂不解释
        TODO: 面向对象(继承), 方法重写, Object类, toString方法
        2. 这三个构造方法, 创建字符串对象, 都没有双引号直接创建来的方便.
        String s = "abc";
        -----------------------------------------------------------------
        字符串对象, 两种创建方式的区别
        1. 双引号直接创建
        2. 通过构造方法创建

 public static void main(String[] args) {
        // public String() : 创建一个空白字符串, 里面不含任何内容
        String s1 = new String();
        System.out.println(s1);

        // public String(char[] chs) : 根据传入的字符数组, 创建字符串对象
        char[] chs = {'a','b','c'};
        String s2 = new String(chs);
        System.out.println(s2);

        // public String(String original) : 根据传入的字符串, 来创建字符串对象
        String s3 = new String("abc");
        System.out.println(s3);
 
        String ss1 = "abc";
        String ss2 = "a" + "b" + "c";
 
        System.out.println(ss1 == ss2);
    }
}

1.3常见面试题

1.4字符串比较

String类中用于比较的方法 :
        public boolean equals(Object anObject) 将此字符串与指定的对象比较
        public boolean equalsIgnoreCase(String anotherString) 将此 String 与另一个 String 比较，不考虑大小写

public static void main(String[] args) {
        String s1 = "abc";
        String s2 = new String("abc");
 
        System.out.println(s1 == s2);               // false
        System.out.println(s1.equals(s2));          // true
 
        System.out.println("---------------------");
 
        String ss1 = "abc";
        String ss2 = "ABC";
 
        System.out.println(ss1.equals(ss2));                // false
        System.out.println(ss1.equalsIgnoreCase(ss2));      // true
    }
}

1.5字符串遍历

String类用于遍历的方法:

public char[] toCharArray() 将此字符串转换为一个新的字符数组
public char charAt(int index) 返回指定索引处的 char 值
public int length() 返回此字符串的长度

private static void print1() {
        String s = "itheima";
        char[] chars = s.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            System.out.println(chars[i]);
        }
    }

private static void print2() {
        String s = "itheima";
        for (int i = 0; i < s.length(); i++) {
            // i = 0 1 2 3 4 5 6
            char c = s.charAt(i);
            System.out.println(c);
        }
    }

1.5.1案例：统计字符个数

需求 : 键盘录入一个字符串，统计该字符串中大写字母字符，小写字母字符，数字字符出现的次数
        (不考虑其他字符)
        例如 :  aAb3&c2B*4CD1
        小写字母 : 3个
        大写字母 : 4个
        数字字母 : 4个

public static void main(String[] args) {
        // 1. 键盘录入一个字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入:");
        String content = sc.nextLine();
        // 2. 定义三份计数器变量, 用于统计操作
        int smallCount = 0;
        int bigCount = 0;
        int numCount = 0;
        // 3. 遍历字符串, 获取到每一个字符
        char[] chars = content.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            char c = chars[i];
            // 4. 在遍历的过程中, 加入if判断, 看字符属于哪一种类别
            if (c >= 'a' && c <= 'z') {
                // 5. 对应的计数器变量自增
                smallCount++;
            } else if (c >= 'A' && c <= 'Z') {
                bigCount++;
            } else if (c >= '0' && c <= '9') {
                numCount++;
            }
        }
        // 6. 在遍历结束后, 将统计好的计数器变量, 打印在控制台
        System.out.println("小写字母 : " + smallCount + "个");
        System.out.println("大写字母 : " + bigCount + "个");
        System.out.println("数字字符 : " + numCount + "个");
    }
}

1.6字符串的截取

String类的截取方法 :
public String substring(int beginIndex) : 根据传入的索引开始做截取, 截取到字符串的末尾
public String substring(int beginIndex, int endIndex) : 根据传入的开始和结束索引, 对字符串做截取
- 包含头, 不包含尾
注意: 截取出来的内容, 是作为新的字符串返回, 别忘记找变量接收

public class StringMethodDemo3 {
     
    public static void main(String[] args) {
 
        String s = "itheima";
 
        String result = s.substring(0, 2);
 
        System.out.println(result);
 
    }
 
    private static void method() {
        String s = "itheima";
 
        String result = s.substring(2);
 
        System.out.println(result);
    }
}

1.6.1案例：屏蔽号码

需求：以字符串的形式从键盘接受一个手机号，将中间四位号码屏蔽
        最终效果为：156****1234
        分析:
        1. 键盘录入字符串
        2. 截取前三位
        3. 截取后四位
        4. 前三位 + "****" + 后四位

public static void main(String[] args) {
        // 1. 键盘录入字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入手机号:");
        String tel = sc.nextLine();
 
        // 2. 截取前三位
        String start = tel.substring(0, 3);
 
        // 3. 截取后四位
        String end = tel.substring(7);
 
        // 4. 前三位 + "****" + 后四位
        System.out.println(start + "****" + end);

1.7字符串替换

String类的替换方法 :
    public String replace(CharSequence target, CharSequence replacement)  :
                        参数1 : 旧值
                        参数2 : 新值

public class StringMethodDemo4 {
    public static void main(String[] args) {
        String s = "itheima"; 
        String result = s.replace("heima", "baima");
        System.out.println(result);
    }
}

1.7.1案例：替换字符

需求：键盘录入一个 字符串，如果字符串中包含(TMD), 则使用 *** 替换

public class StringTest4 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入:");
        String content = sc.nextLine();
        content = content.replace("TMD","***");
        System.out.println(content);
    }
}

1.8字符串切割

String类的切割方法 :
    public String[] split(String regex) : 根据传入的字符串作为规则, 切割当前字符串
建议: 先正常指定切割规则, 后来发现没有得到自己要的效果, 就可以尝试在规则前面, 加入 \\

public class StringMethodDemo5 {
    public static void main(String[] args) {
        String s = "192+168+1+1";
        String[] sArr = s.split("\\+");
        for (int i = 0; i < sArr.length; i++) {
            System.out.println(sArr[i]);
        }
    }
}

1.9String小结

2.StringBuilder类

2.1StringBuilder的特点

提高效率：

public static void main(String[] args) {
        long start = System.currentTimeMillis();
        StringBuilder sb = new StringBuilder();
        for(int i = 1; i <= 100000; i++){
            sb.append(i);
        }
        System.out.println(sb);
        long end = System.currentTimeMillis();
        System.out.println(end - start);            // 10
    }
    private static void method() {
        // 获取1970年1月1日0时0分0秒到现在所经历过的毫秒值 (1秒 = 1000毫秒)
        long start = System.currentTimeMillis();
        String s = "";
        for(int i = 1; i <= 100000; i++){
            s += i;
        }
        System.out.println(s);
        long end = System.currentTimeMillis();
        System.out.println(end - start);            // 2804
    }

2.2StringBuilder的构造方法

StringBuilder的介绍 :
    1. 一个可变的字符序列
    2. StringBuilder是字符串缓冲区, 将其理解是容器, 这个容器可以存储任意数据类型, 但是只要进入到这个容器, 全部变成字符串.
StringBuilder的构造方法 :
    public StringBuilder() : 创建一个空白的字符串缓冲区(容器), 其初始容量为16个字符
    public StringBuilder(String str) : 创建一个字符串缓冲区(容器), 容器在创建好之后, 就会带有参数的内容

public class StringBuilderDemo2 {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("abc");
        System.out.println(sb);
    }
}

2.3StringBuilder的常用成员方法

StringBuilder常用成员方法 :
    1. public StringBuilder append(任意类型) : 添加数据, 并返回对象自己
    2. public StringBuilder reverse() : 将缓冲区中的内容, 进行反转
    3. public int length() : 返回长度
    4. public String toString() : 将缓冲区的内容, 以String字符串类型返回

public class StringBuilderDemo3 {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        // 链式编程: 调用的方法, 返回的结果是对象, 就可以继续向下调用方法
        sb.append("红色").append("绿色").append("蓝色");
        System.out.println(sb);
        // 情况: 我数据在StringBuilder当中, 我要调用的方法, StringBuilder没有, 但是String有
        // 解决: 转换为String, 再调用
        String[] sArr = sb.toString().split("色");
        for (int i = 0; i < sArr.length; i++) {
            System.out.println(sArr[i]);
        }
    }
}

2.4.1案例回文字符

需求: 键盘接受一个字符串，程序判断出该字符串是否是对称字符串(回文字符串)，并在控制台打印是或不是
        对称字符串:  123321、111
        非对称字符串: 123123
        思路: 对拿到的字符串进行反转, 反转后的内容, 跟原数据相同, 判定为回文字符串
        String ---> StringBuilder
        String s = "abc";
        StringBuilder sb = new StringBuilder(s);
        StringBuilder ---> String
        String s = sb.toString();

 public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个对称字符串: ");
        String content = sc.nextLine();
 
        // 将String转换为StringBuilder, 为了调用内部反转的方法
        StringBuilder sb = new StringBuilder(content);
        sb.reverse();
 
        // 判断反转后的内容, 和原数据是否相同
        // content : String类型
        // sb : StringBuilder类型
        if (content.equals(sb.toString())) {
            System.out.println("是对称字符串");
        } else {
            System.out.println("不是对称字符串");
        }
    }
}

2.4.2案例数组转换字符串

需求:
        定义一个方法, 把int数组中的数据按照指定的格式拼接成一个字符串返回
        调用该方法, 并在控制台输出结果。
        例如: 数组为int[] arr = {1,2,3};
        执行方法后的输出结果为: [1, 2, 3]

public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        String result = arrayToString(arr);
        System.out.println(result);
    }
    public static String arrayToString(int[] arr) {
 
        // 1. 创建StringBuilder, 准备进行拼接
        StringBuilder sb = new StringBuilder("[");
 
        // 2. 遍历数组, 获取内部元素
        for (int i = 0; i < arr.length - 1; i++) {
            // 3. 将获取到的元素, 拼接到字符串缓冲区
            sb.append(arr[i]).append(", ");
        }
 
        // 4. 特殊处理最后一个元素
        sb.append(arr[arr.length - 1]).append("]");
 
        return sb.toString();
    }
}

2.5String、StringBuffer、StringBuilder的区别

StringBuilder和StringBuffer在用法上是一样

	String	StringBuffer	StringBuilder
执行速度	最差	其次	最高
线程安全	线程安全	线程安全	线程不安全
使用场景	少量字符串操作	多线程环境下的大量操作	单线程环境下的大量操作