Day08Java基础-API & String & 字符串比较和遍历 & StringBuilder

一. API

1. API(Application Programming Interface) : 应用程序编程接口

   ------就是别人写好的一些类, 给程序员直接拿去调用即可解决问题的.

   如键盘录入Scanner, 生成随机数Random等, 具体见API帮助文档.

API帮助文档的使用流程:

1. 在索引位置搜索自己要查看的类

2. 看包

   目的: 是不是java.lang包 (核心包), 不需要编写导包代码 (import); 若不是java.lang包, 都需要编写导包代码

3. 看这个类的介绍

   目的: 搞清楚这个类的作用

4. 看这个类的构造方法

   目的: 为了将该类的对象, 创建出来

5. 看这个类的成员方法 (方法摘要)

   1.  方法名

   2.  参数

   3.  返回值

   4. 介绍

package com.itheima.scanner;

import java.util.Scanner;

public class ScannerDemo1 {
    /*
        Scanner键盘录入字符串

            String next() : 遇到了空格, 或者是tab键就不再录入了
            String nextLine() : 以回车作为录入的结束标记

            弊端:
                    1. next() : 数据可能录入不完整
                    2. nextLine() : 之前调用过nextInt(), nextDouble(), nextFloat()...后
                                            nextLine()方法, 就干活了

            解决方案: 不用解决
                            Scanner : 采集用户信息 (只在学习过程用得到)

            目前的使用方案:
                            需求如果要键盘录入字符串
                                    1. 如果所有的数据, 全部都是字符串, 直接nextLine();
                                            举例:
                                                    键盘录入用户名, 键盘录入用户密码

                                    2. 如果数据除了字符串, 还有其他类型, 需要调用next()方法
                                            举例:
                                                    键盘录入用户名, 键盘录入用户年龄, 用户身高
     */
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入用户年龄:");
        String age = sc.nextLine();
        System.out.println(age);

        System.out.println("请输入用户名:");
        String password = sc.next();
        System.out.println(password);

    }
}

二. String类

package com.itheima.string;

import com.itheima.domain.Student;

public class StringDemo1 {
    /*
    String类的特点 :

        1. Java 程序中所有双引号字符串, 都是String这个类的对象

        2. 字符串一旦被创建, 就不可更改, 字符串内容不可改变
                        如果想要更改, 只能使用新的对象, 做替换

        3. String字符串虽然不可改变, 但是可以被共享

                    字符串常量池: 当我们使用双引号创建字符串对象时, 会检查常量池中是否存在该数据
                                不存在: 创建
                                存在: 复用
                    如下:
                            String s1 = "abc";
                            String s2 = "abc";
                            System.out.println(s1 == s2);   // 打印为true

        System.out.println(s.toUpperCase()); // 将小写转换为大写

        System.out.println("helloworld".toUpperCase());
     */
    public static void main(String[] args) {
        String s1 = "abc";
        String s2 = "abc";
        System.out.println(s1 == s2);   // 打印为true
    }
}

1. String类常见的构造方法

2. String 类用于比较的方法

package com.itheima.string.method;

public class StringMethodDemo1 {
    /*
        String类中用于比较的方法 :

             public boolean equals(Object anObject)
             将此字符串与指定的对象比较, 完全一样结果才是true, 否则为false

             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));
        System.out.println(ss1.equalsIgnoreCase(ss2));
    }
}

package com.itheima.test;

import java.util.Scanner;

public class StringTest1 {
    /*
        需求: 模拟用户登录, 一共三次机会, 登录之后要给出相应的提示

        分析:
                1. 定义两个字符串类型变量, 模拟已经存在的用户名和密码

                2. 键盘录入用户输入的用户名, 密码

                3. 比对
     */
    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        // 1. 定义两个字符串类型变量, 模拟已经存在的用户名和密码
        String username = "admin";
        String password = "123456";

        for (int i = 1; i <= 3; i++) {
            // 2. 键盘录入用户输入的用户名, 密码
            System.out.println("请输入用户名:");
            String inputUsername = sc.nextLine();

            System.out.println("请输入密码:");
            String inputPassWord = sc.nextLine();

            // 3. 比对
            if (inputUsername.equals(username) && inputPassWord.equals(password)) {
                System.out.println("登录成功!");
                break;
            } else {
                if(i==3){
                    System.out.println("登录失败, 请明天再试!");
                }else{
                    System.out.println("登录失败, 您还剩下"+(3-i)+"次机会");
                }

            }
        }

    }
}

3. String 字符串的遍历

package com.itheima.string.method;

public class StringMethodDemo2 {
    /*
        String类当中用于遍历的方法:

            public char[] toCharArray() 将此字符串转换为一个新的字符数组

            public char charAt(int index) 返回指定索引index处的 char 值

            public int length() 返回此字符串的长度

     */
    public static void main(String[] args) {

        print1();
        print2();

    }

    /**
     * 字符串遍历的第二种方式
     */
    private static void print2() {
        String s = "itheima";

        for (int i = 0; i < s.length(); i++) {

            char c = s.charAt(i);
            System.out.println(c);
        }
    }

    /**
     * 字符串的第一种遍历方式 (少调方法,效率更高)
     */
    private static void print1() {
        String s = "itheima";

        char[] chars = s.toCharArray();

        for (int i = 0; i < chars.length; i++) {
            System.out.println(chars[i]);
        }
    }
}

package com.itheima.test;

import java.util.Scanner;

public class StringTest2 {
    /*
        需求：键盘录入一个字符串，统计该字符串中大写字母字符，小写字母字符，数字字符出现的次数
                （不考虑其他字符）

                例如：aAb3&c2B*4CD1

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

    }
}

4. String 字符串的截取方法

package com.itheima.string.method;

public class StringMethodDemo3 {
    /*
        String类的截取方法 :

             public String substring(int beginIndex) : 根据传入的索引开始做截取, 截取到字符串的末尾

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

    public static void main(String[] args) {

        String s = "itheima";

        String result = s.substring(0,1);

        System.out.println(result);
    }

    private static void method() {
        String s = "itheima";

        String result = s.substring(2);

        System.out.println(result);
    }
}

package com.itheima.test;

import java.util.Scanner;

public class StringTest3 {
    /*
        需求：以字符串的形式从键盘接受一个手机号，将中问四位号码屏蔽
                最终效果为：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);

        // 前三位 + "****" + 后四位
        System.out.println(start + "****" + end);
    }
}

5. String字符串的敏感词替换

package com.itheima.string.method;

public class StringMethodDemo4 {
    /*
        String类的替换方法:

            public String replace(CharSequence target, CharSequence replacement):

                                    参数1: 旧值
                                    参数2: 新值
     */
    public static void main(String[] args) {

        String s = "itheima";

        String result = s.replace("heima", "baima");

        System.out.println(result);
    }
}

package com.itheima.test;

import java.util.Scanner;

public class StringTest4 {
    /*
        需求：键盘录入一个字符串，如果字符串中包含(TMD)，则使用**替换
     */
    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);
    }
}

6. String字符串的切割方法

package com.itheima.string.method;

public class StringMethodDemo5 {
    /*
        String类的切割方法:
             public String[] split(String regex) : 根据传入的字符串作为规则, 切割当前字符串

             注意: "."作为任意字符, 要是想要按照"."来切割, 则用"\\."来进行切割

             建议: 先按照指定切割规则, 后来发现没有得到自己想要的效果, 就可以尝试在规则前面, 加入\\
     */
    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]);
        }
    }
}

三.StringBuilder类

1. StringBuilder 构造方法

package com.itheima.stringbuilder;

import java.awt.*;

public class StringBuilderDemo1 {
    /*
        StringBuilder的作用: 提高字符串的操作效率

                1. StringBuilder的特点
                2. StringBuilder的构造方法
                3. 练习
                4. StringBuilder提高效率
     */
    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);    // 17

    }

    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);    //2350
    }
}

package com.itheima.stringbuilder;

public class StringBuilderDemo2 {
    /*
        StringBuilder的介绍:

            1. 一个可变的字符序列
            2. StringBuilder是字符串缓冲区, 将其理解是容器, 这个容器可以存储任意数据类型, 但是只要进入到这个容器, 全部变成字符串.

        StringBuilder的构造方法:

               public StringBuilder() : 创建一个空白的字符串缓冲区(容器), 其初始容器为16个字符, 当装不下时会自动扩容.
               public StringBuilder(String str) : 创建一个字符串缓冲区(容器), 容器在创建好之后, 就会带有参数的内容.
     */
    public static void main(String[] args) {

        StringBuilder sb = new StringBuilder("abc");

        sb.append("123456789123456789");

        System.out.println(sb);
    }
}

2. StringBuilder常用成员方法

package com.itheima.stringbuilder;

public class StringBuilderDemo3 {
    /*
        StringBuilder常用成员方法 :

            1. public StringBuilder append(boolean b) : 添加数据, 并返回对象自己

            2. public StringBuilder reverse() : 将缓冲区中的内容, 进行反转.

            3. public  int length() 返回长度

            4. public  String toString() : 将缓冲区的内容, 以String字符串类型返回
     */
    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]);
        }
    }
}

3. StringBuilder 的案例和原理

(1) 案例分析

package com.itheima.test;

import java.util.Scanner;

public class StringBuilderTest1 {
    /*
        需求：健盘接受一个字符串，程序判断出该字符串是否是对称字符串（回文字符串），并在控制台打印是或不是
                对称字符串：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("不是对称字符串");
        }

    }
}

package com.itheima.test;

public class StringBuilderTest2 {
    /*
        需求:
            定义一个方法, 把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) StringBuilder拼接效率高原理

首先要理解String拼接效率低下的原因, 如下图所示:

再对照StringBuilder拼接, 分析其高效率, 如下图所示:

分析:

        在拼接的过程中, 只有 sb 这一个StringBuilder对象, 且不产生String类型的对象, 故当进行大量数据拼接操作时, StringBuilde的效率会高很多.

4. StringBuilder和StringBuffer的区别

(1) 开始的版本不同

前者(StringBuilder)是从 1.5 版本开始的, 而后者(StringBuffer)是从 1.0 版本开始的.

(2) 多线程安全性不同

前者(StringBuilder)的实例用于多线程是不安全的, 而后者(StringBuffer)是则是安全的.

(需注意的是: 往往线程安全的效率就会偏低, 但线程不安全的效率就会偏高, 所以按需选用为好.)