Java中API、String类、StringBuilder类的使用

- API的使用
- String类的使用  
  - 创建对象
  - 使用类的常用方法
- Stringbuilder类使用
  - 创建对象
  - 使用类的常用方法
  - String类和Stringbuilder类转换

1. API的使用

1.1 API的概述

 API（Application Programming Interface，应用程式编程接口）是一些预先定义的函式，
    目的是提供应用程式与开发人员基于某软体或硬体得以访问一组例程的能力，而又无需
    访问源码，或理解内部工作机制的细节。 把API称之为说明书。

1.2 API的使用

1.2.1 使用API 学习Scanner类

import java.io.InputStream;
import java.util.Scanner;

/*
    使用API 学习Scanner类
        1.包结构：
            java.util.Scanner
        2.继承结构
            public final class Scanner extends Object implements Iterator<String>, Closeable
        4.类的描述
            一个简单的文本扫描器
        5.构造方法
            Scanner(InputStream source) 构造一个新的 Scanner ，产生从指定输入流扫描的值。
        6.常用成员方法的使用：
            int nextInt() 将输入的下一个标记扫描为 int 。
            float nextFloat() 将输入的下一个标记扫描为 float 。
            double nextDouble() 将输入的下一个标记扫描为 double 。
            String next() 查找并返回此扫描仪的下一个完整令牌。
            String nextLine() 将此扫描仪推进到当前行并返回跳过的输入。

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

        InputStream in = System.in;
        //导包 创建对象
        Scanner sc = new Scanner(in);
        //Scanner sc1 = new Scanner(System.in);
        //成员方法的学习
        //int nextInt() 将输入的下一个标记扫描为 int 。
        /*System.out.println("请输入一个整数：");
        int num = sc.nextInt();
        System.out.println("num = " + num);

        // float nextFloat() 将输入的下一个标记扫描为 float 。
        System.out.println("请输入一个小数：");
        float num1 = sc.nextFloat();
        System.out.println("num1 = " + num1);

        //double nextDouble() 将输入的下一个标记扫描为 double 。
        System.out.println("请输入一个小数：");
        double num2 = sc.nextDouble();
        System.out.println("num2 = " + num2);*/

        //String next() 查找并返回此扫描仪的下一个完整令牌。 特点：遇到空格就停止接收数据
        /*System.out.println("请输入一个字符串：");
        String s = sc.next();
        System.out.println("s = " + s);*/

        System.out.println("请输入一个整数：");
        int num3 = sc.nextInt();
        System.out.println("num3 = " + num3);

        //String nextLine() 将此扫描仪推进到当前行并返回跳过的输入。特点：遇到回车换行停止接受数据
        System.out.println("请输入一个字符串：");
        String s1 = sc.nextLine();
        System.out.println("s1 = " + s1);

        /*
            出现这个情况的原因：
                1.用的是键盘录入，Scanner一直在扫描我们的键盘
                2.使用nextInt(); 接收int类型的数据，我们录入int类型的数据，按下了回车键
                    又因为nextInt()方法只接收数据，没有接收回车换行，回车换行还在键盘录入的内存中
                3.nextLine()发现键盘录入的内存中，有个回车换行，又因为nextLine()遇到回车换行，停止接收数据
                4.所以就没让我们键盘录入
         */


    }
}

1.2.2 Scanner类nextInt方法的异常

```java
```java
 import java.util.Scanner;
    /*
        InputMismatchException:
            原因：
                1.键盘录入的数据超出了对应数据类的取值范围
                2.键盘录入的数据和对应的数据类型不匹配
        NoSuchElementException：
                1.数据用尽了
        IllegalStateException
                1.非法的状态异常
     */
    public class Demo03 {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            sc.close();
            System.out.println("请输入一个整数：");
            int num = sc.nextInt();
            System.out.println("num = " + num);
        }
    }

1.2.3 使用API学习 Random 类

   /*
        使用API学习 Random 类
            1.打开API搜索Random类，双击找到的Random类
              包结构：
                java.util.Random
            2.继承结构
                public class Random extends Object implements Serializable
            3.描述：
                该类的实例用于生成伪随机数的流
            4.构造方法：
                Random() 创建一个新的随机数生成器。
            5.常用成员方法
                int nextInt(int bound) 返回伪随机的，均匀分布 int值介于0（含）和指定值（不包括），从该随机数生成器的序列绘制。
                int nextInt() 返回下一个伪随机数，从这个随机数发生器的序列中均匀分布 int值。
            6. int nextInt(int bound) 使用异常：
                IllegalArgumentException:非法的参数异常
                原因：
                    bound<=0
            7. 生成区间内的随机数：
                生成区间内的随机数：
                    nextInt(最大值 - 最小值 + 1) + 最小值;
    
     */
    public class Demo04Random {
        public static void main(String[] args) {
            Random random = new Random();
            //int nextInt(int bound) 返回伪随机的，均匀分布 int值介于0（含）和指定值（不包括），从该随机数生成器的序列绘制。
            /*for (int i = 0; i < 100; i++) {
                int num = random.nextInt(10);
                System.out.println(num);
            }*/
            //int nextInt() 返回下一个伪随机数，从这个随机数发生器的序列中均匀分布 int值。 int类型取值范围内的随机数
            /*for (int i = 0; i < 1000; i++) {
                int num = random.nextInt();
                System.out.println(num);
            }*/
            //IllegalArgumentException
            /*int num = random.nextInt(0);
            System.out.println(num);*/
            //生成区间内的随机数：nextInt(最大值 - 最小值 + 1) + 最小值;
            //比如生成 [20,80]之间的随机数，科学记数法的一种，说明20到80之间数字，包含20到80
            int num = random.nextInt(61) + 20;
    
            //生成 [-20, 80]
            int num1 = random.nextInt(101)-20;
    
        }
    }

2. String类的学习

2.1 使用API学习String类

  /*
         使用API学习String类
            1.包结构
                java.lang.String  提示：java中lang包下的所有类，在使用的时候不要导包
            2.继承结构
                public final class String extends Object implements Serializable, Comparable<String>, CharSequence
            3.描述：
                String类代表字符串
                Java程序中的所有字符串文字（例如"abc" ）都被实现为此类的实例。类的对象，类的实体
                字符串的底层是数组
                字符串不变; 它们的值在创建后不能被更改,因为String对象是不可变的，它们可以被共享
            4.构造方法
                String() 初始化新创建的 String对象，使其表示空字符序列。
                String(byte[] bytes) 通过使用平台的默认字符集解码指定的字节数组来构造新的 String 。
                String(byte[] bytes, int offset, int length) 通过使用平台的默认字符集解码指定的字节子阵列来构造新的 String
                String(char[] value) 分配一个新的 String ，以便它表示当前包含在字符数组参数中的字符序列。
                String(char[] value, int offset, int count) 分配一个新的 String ，其中包含字符数组参数的子阵列中的字符。
                String(String original) 初始化新创建的String对象，使其表示与参数相同的字符序列; 换句话说，新创建的字符串是参数字符串的副本。
            5.常用成员方法
                char charAt(int index) 返回 char指定索引处的值。
    
    
    
     */
    public class Demo01String {
        public static void main(String[] args) {
            //Java程序中的所有字符串文字（例如"abc" ）都被实现为此类的实例。
            char c = "abc".charAt(0);
            System.out.println(c);
            char c1 = "abc".charAt(1);
            char c2 = "abc".charAt(2);
            System.out.println(c1);
            System.out.println(c2);
    
            //字符串不变; 它们的值在创建后不能被更改,因为String对象是不可变的，它们可以被共享
            String s = "abcd";
            String s1 = "abcd";
            System.out.println(s1 == s);
            //== 基本数据类型 比较的是值，引用数据类型比较是地址值
    
            //构造方法
            //String() 初始化新创建的 String对象，使其表示空字符序列。
            String s2 = new String(); //String s = "";
            System.out.println(s2);
            //String(byte[] bytes) 通过使用平台的默认字符集解码指定的字节数组来构造新的 String 。
            byte[] bytes = {97, 98, 99, 100, 101, 102, 103};
            String s3 = new String(bytes);
            System.out.println(s3);//abcdefg
            //String(byte[] bytes, int offset, int length) 通过使用平台的默认字符集解码指定的字节子阵列来构造新的 String 。
            //offset :从哪个索引开始
            //length : 去几个数据
            String s4 = new String(bytes, 0, 3);
            System.out.println(s4);//abc
    
            //String(char[] value) 分配一个新的 String ，以便它表示当前包含在字符数组参数中的字符序列。
            char[] chars = {'a', 'b', 'c', 'd', 'e', 'f', 'g'};
            String s5 = new String(chars);
            System.out.println(s5);
    
            //String(char[] value, int offset, int count) 分配一个新的 String ，其中包含字符数组参数的子阵列中的字符。
            //offset :从哪个索引开始
            //count :去几个数据
            String s6 = new String(chars, 0, 3);
            System.out.println(s6);//abc
    
            //String(String original) 初始化新创建的String对象，使其表示与参数相同的字符序列; 换句话说，新创建的字符串是参数字符串的副本。
            String s7 = "abcdefg";
            String s8 = new String(s7);
            System.out.println(s7);
            System.out.println(s8);
        }
    }

2.2 == 号

public class Demo02 {
        public static void main(String[] args) {
            String s1 = "abc";
            String s2 = "ab";
            String s3 = s2 + "c";//在java后台  new StringBuilder(s2).append("c").toString();
            System.out.println(s1 == s3); //false
    
            String s4 = "a" + "b" + "c";
        }
    }
    
    /*
        boolean equals(Object anObject) 将此字符串与指定对象进行比较。
        比较的是字符串的内容 包括字符串的大小写，字符串的顺序
        在比较的时候区分大小写
     */
    public class Demo03 {
        public static void main(String[] args) {
            String s1 = "abc";
            String s2 = "abc";
            String s3 = new String("abc");
            System.out.println(s1 == s2); //true
            System.out.println(s1 == s3); //false
    
            System.out.println(s1.equals(s3));
    
            String s4 = "Abc";
            System.out.println(s2.equals(s4));
        }
    }

2.3用户登录

import java.util.Scanner;
/*
需求：已知用户名和密码，请用程序实现模拟用户登录。总共给三次失败机会，登录之后，给出相应的提示
 */
public class Demo04用户登录 {
    public static void main(String[] args) {
        //准备用户名和密码
        String username = "admin";
        String --- = "123456";
        //模拟用户登录
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < 3; i++) {
            System.out.println("请输入用户名：");
            String uName = sc.next();
            System.out.println("请输入密码：");
            String pwd = sc.next();
            //比较用户名和密码是否相等，如果相等就输出登录成功
            if (uName.equals(username) && pwd.equals(password)){
                System.out.println("登录成功，你可以上网冲浪！");
                break;
            }else {
                if (2-i == 0){
                    System.out.println("用户名和密码有误，账户被锁定，请联系管理员！");
                }else {
                    System.out.println("用户名和密码有误！您还有"+(2-i)+"次机会");
                }
            }
        }
    }
}

2.4 equalsIgnoreCase(String anotherString)

/*
    boolean equalsIgnoreCase(String anotherString) 将此 String与其他 String比较，忽略案例注意事项。

    比较字符串中的内容：忽略大小写,字母顺序要一致
 */
public class Demo05 {
    public static void main(String[] args) {
        String s1 = "aBc";
        String s2 = "AbC";
        System.out.println(s1.equals(s2));

        System.out.println(s1.equalsIgnoreCase(s2));
    }
}

2.5 遍历字符串

 import java.util.Scanner;
    
    /*
        b遍历字符串
            char charAt(int index) 返回 char指定索引处的值。
            int length() 返回此字符串的长度。
        需求：遍历指定的字符串，获取字符串中的元素
        需求：键盘录入一个字符串，使用程序实现在控制台遍历该字符串
    
     */
    public class Demo06 {
        public static void main(String[] args) {
            //需求：遍历指定的字符串，获取字符串中的元素
            String s = "abcdefg";
            /*System.out.println(s.charAt(0));
            System.out.println(s.charAt(1));
            System.out.println(s.charAt(2));
            System.out.println(s.charAt(3));
            System.out.println(s.charAt(4));
            System.out.println(s.charAt(5));
            System.out.println(s.charAt(6));*/
            /*for (int i = 0; i < 7; i++) {
                System.out.println(s.charAt(i));
            }*/
            for (int i = 0; i < s.length(); i++) {
                System.out.println(s.charAt(i));
            }
            System.out.println("--------------");
            //需求：键盘录入一个字符串，使用程序实现在控制台遍历该字符串
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入一个字符串：");
            String line = sc.nextLine();
            //遍历字符 line
            for (int i = 0; i < line.length(); i++) {
                System.out.println(line.charAt(i));
            }
    
    
        }
    }

 /*
        char[] toCharArray() 将此字符串转换为新的字符数组。
    
        需求：键盘录入一个字符串，使用程序实现在控制台遍历该字符串
     */
    public class Demo07 {
        public static void main(String[] args) {
            //创建键盘录入的对象
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入一个字符串：");
            String line = sc.nextLine();
            //char[] toCharArray() 将此字符串转换为新的字符数组。
            char[] chars = line.toCharArray();
            //遍历数组
            for (int i = 0; i < chars.length; i++) {
                System.out.println(chars[i]);
            }
        }
    }

2.6 遍历字符串练习

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


 */
public class Demo08字符串遍历的练习 {
    public static void main(String[] args) {
        //键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();
        //count(line);
        //要统计三种类型的字符个数，需定义三个统计变量，初始值都为0
        int bigCount = 0;//统计大写字母
        int smallCount = 0;//统计小写字母
        int numCount = 0;//统计数字字符
        //遍历字符串，得到每一个字符
        for (int i = 0; i < line.length(); i++) {
            char ch = line.charAt(i);
            if (ch>='A'&&ch<='Z'){
                bigCount++;
            }
            if (ch>='a'&&ch<='z'){
                smallCount++;
            }
            if (ch>='0'&&ch<='9'){
                numCount++;
            }
        }
        //输出三种类型的字符个数
        System.out.println("大写字母："+bigCount+"个");
        System.out.println("小写字母："+smallCount+"个");
        System.out.println("数字字符："+numCount+"个");
    }

    public static void count(String line) {
        //要统计三种类型的字符个数，需定义三个统计变量，初始值都为0
        int bigCount = 0;//统计大写字母
        int smallCount = 0;//统计小写字母
        int numCount = 0;//统计数字字符
        //遍历字符串，得到每一个字符
        char[] chars = line.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            char ch = chars[i];
            if (ch>='A'&&ch<='Z'){
                bigCount++;
            }
            if (ch>='a'&&ch<='z'){
                smallCount++;
            }
            if (ch>='0'&&ch<='9'){
                numCount++;
            }
        }
        //输出三种类型的字符个数
        System.out.println("大写字母："+bigCount+"个");
        System.out.println("小写字母："+smallCount+"个");
        System.out.println("数字字符："+numCount+"个");
    }
}

2.7 字符串截取

 /*
        String substring(int beginIndex) 返回一个字符串，该字符串是此字符串的子字符串。
        String substring(int beginIndex, int endIndex) 返回一个字符串，该字符串是此字符串的子字符串。
        提示：endIndex对应元素获取不到
    
        需求：以字符串的形式从键盘接受一个手机号，将中间四位号码屏蔽
        最终效果为：156****1234
     */
    public class Demo09 {
        public static void main(String[] args) {
            //String substring(int beginIndex) 返回一个字符串，该字符串是此字符串的子字符串。
            String phoneNum = "13917295832";
            String s = phoneNum.substring(7);
            System.out.println(s);//5832
            String s1 = phoneNum.substring(0, 3);
            System.out.println(s1);//139
            String newPhoneNum = s1+"****"+s;
            System.out.println(newPhoneNum);
    
            //一行代码实现
            String phone = phoneNum.substring(0,3)+"****"+phoneNum.substring(7);
            System.out.println(phone);
    
        }
    }

2.8 字符串替换

import java.util.Scanner;

/*
    String replace(CharSequence target, CharSequence replacement)
将与字面目标序列匹配的字符串的每个子字符串替换为指定的字面替换序列。

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

 */
public class Demo10敏感词的替换 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入一个字符串：");
        String line = sc.nextLine();
        //如果字符串中包含敏感词,如(TMD)，则使用***替换
        String s = line.replace("TMD", "***");
        //打印替换后的结果
        System.out.println(s);
    }
}

2.9 字符串截取练习

   /*
        需求：以字符串的形式从键盘录入学生信息，例如：“张三 , 23”从该字符串中切割出有效数据
    封装为Student学生对象
    
        String[] split(String regex) 将此字符串分割为给定的 regular expression的匹配。
     */
    public class Demo11 {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入学生的信息：【格式:姓名,年龄】");
            String stuInfo = sc.next();
            //split(String regex)
            String[] str = stuInfo.split(",");
            System.out.println(Arrays.toString(str));
            //创建学生对象
            String name = str[0];
            String age = str[1];
            //Integer.valueOf(age) 可以把字符串的数值 转变成int类型数字
            Student student = new Student(name,Integer.valueOf(age));
            //打印学生对象获取值
            System.out.println(student.getName());
            System.out.println(student.getAge());
    
        }
    }

  public class Student {
        private String name;
        private int age;
    
        public Student() {
        }
    
        public Student(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    }

3. StringBuilder类

3.1使用API学习 StringBuilder类

/*
    StringBuilder类：
        1.包结构
            java.lang.StringBuilder
        2.继承结构
            public final class StringBuilder extends Object implements Serializable, CharSequence
        3.描述
            一个可变的字符序列。底层是一个可变大小容器
        4.构造方法
            StringBuilder() 构造一个没有字符的字符串构建器，初始容量为16个字符。
            StringBuilder(int capacity) 构造一个没有字符的字符串构建器，由 capacity参数指定的初始容量。
            StringBuilder(String str) 构造一个初始化为指定字符串内容的字符串构建器。
        5.常用成员方法
            int capacity() 返回当前容量。
            StringBuilder reverse() 导致该字符序列被序列的相反代替。
            String toString() 返回表示此顺序中的数据的字符串。
            StringBuilder append(boolean b) 将 boolean参数的字符串表示附加到序列中。
 */
public class Demo01 {
    public static void main(String[] args) {
        //StringBuilder() 构造一个没有字符的字符串构建器，初始容量为16个字符。
        StringBuilder builder = new StringBuilder();
        //int capacity() 返回当前容量。
        int capacity = builder.capacity();
        System.out.println(capacity);//16

        //StringBuilder(int capacity) 构造一个没有字符的字符串构建器，由 capacity参数指定的初始容量。
        StringBuilder builder1 = new StringBuilder(32);
        System.out.println(builder1.capacity());//32

        //StringBuilder(String str) 构造一个初始化为指定字符串内容的字符串构建器。
        StringBuilder builder2 = new StringBuilder("abc");
        System.out.println(builder2);
        System.out.println("----------");
        //需求：字符串的反转存放
        String str = "abc";
        String s ="";
        for (int i = str.length()-1; i >= 0; i--) {
//            System.out.println(str.charAt(i));
            s+= str.charAt(i);
        }
        System.out.println(s);

        //1.先把字符串转成Stringbuilder的对象  使用 StringBuilder(String str) 构造一个初始化为指定字符串内容的字符串构建器。
        StringBuilder builder3 = new StringBuilder(str);
        //StringBuilder reverse()致该字符序列被序列的相反代替。
        //String toString() 返回表示此顺序中的数据的字符串。
        String s1 = builder3.reverse().toString();
        System.out.println(s1);
        System.out.println(new StringBuilder(str).reverse().toString());
        //String和Stringbuilder互转
        //String 对象转成 Stringbuilder对象 使用Stringbuilder类的 StringBuilder(String str)
        //Stringbuilder对象 转成String对象 使用Stringbuilder类的 toString()方法

        //StringBuilder append(boolean b) 将 boolean参数的字符串表示附加到序列中。
        //添加数据 返回对象本身
        StringBuilder builder4 = new StringBuilder();
        StringBuilder builder5 = builder4.append(100);
        System.out.println(builder4 == builder5);

        builder4.append(true);

        System.out.println(builder4);//100true
        System.out.println(builder5);//100true

        builder4.append(520).append(5.20).append('a');//链式编程

        System.out.println(builder4);
        System.out.println(builder5);

        int length = builder4.length();
        System.out.println(length);


    }
}

3.2 对称字符串

import java.util.Scanner;

/*
    需求：键盘接受一个字符串，程序判断出该字符串是否是对称字符串，并在控制台打印是或不是
	对称字符串：123321、111
	非对称字符串：123123

 */
public class Demo02 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();


        //String 转StringBuilder 调用StringBuilder类 构造方法
        StringBuilder builder = new StringBuilder(line);
        //StringBuilder reverse()方法
        builder.reverse();
        //StringBuilder装成String  调用StringBuilder类的toString方法
        String s = builder.toString();
        //如果反转后的字符串和源字符串一样 就是对称字符串
        if (line.equals(s)) {
            System.out.println(line + "是对称字符串");
        } else {
            System.out.println(line + "不是对称字符串");
        }
    }
}

3.3 格式化输出数组

  import java.util.Arrays;
    
    /*
        需求：定义一个方法，把 int 数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法，并在控制台输出结果。
        例如，数组为int[] arr = {1,2,3}; ，执行方法后的输出结果为：[1, 2, 3]
     */
    public class Demo03 {
        public static void main(String[] args) {
            int[] arr = {1, 2, 3};
            //printArray(arr);
            String s = Arrays.toString(arr);
            System.out.println(s);
            String str = printArray2(arr);
            System.out.println(str);
    
            String str2 = printArray3(arr);
            System.out.println(str2);
        }
    
        public static String printArray3(int[] arr) {
            if (arr == null){
                return "null";
            }
            int iMax = arr.length-1;
            if (iMax == -1){
                return "[]";
            }
            //创建对象
            StringBuilder builder = new StringBuilder();
            builder.append("[");
            for (int i = 0; i < arr.length; i++) {
                if (i == arr.length-1){
                    builder.append(arr[i]).append("]");
                }else {
                    builder.append(arr[i]).append(", ");
                }
            }
            return builder.toString();
        }
    
        public static String printArray2(int[] arr) {
            String s = "[";
            for (int i = 0; i < arr.length; i++) {
                if (i == arr.length - 1) {
                    s += arr[i];
                } else {
                    s += arr[i];
                    s += ", ";
                }
            }
            s += "]";
            return s;
        }
    
        public static void printArray(int[] arr) {
            System.out.print("[");
            for (int i = 0; i < arr.length; i++) {
                if (i == arr.length-1){
                    System.out.print(arr[i]);
                }else {
                    System.out.print(arr[i]+", ");
                }
            }
            System.out.println("]");
        }
    }