第八天javaSE基础

Java EE基础班课程（第八天）

1.API使用

API（Application Programming Interface，应用程序接口）是一些预先定义的接口（如函数、HTTP接口），或指软件系统不同组成部分衔接的约定。 用来提供应用程序与开发人员基于某软件或硬件得以访问的一组例程，而又无需访问源码，或理解内部工作机制的细节.

Java API ：指的就是 JDK 中提供的各种功能的 Java类这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可，我们可以通过帮助文档来学习这些API如何使用.

1.1Scanner使用

/*
    需求：按照帮助文档的使用步骤学习 Scanner 类的使用，并实现键盘录入一个字符串，最后输出在控制台

    1.打来API文档
    2.在搜索框中输入Scanner
    3.查看Scanner的包结构和类结构
        java.util.Scanner
        public final class Scanner extends Object implements Iterator<String>, Closeable
    4.查看Scanner类的描述
        一个简单的文本扫描器
    5.查看构造方法，学习常用构造方法 构造一个新的 Scanner ，产生从指定输入流扫描的值。
        Scanner(InputStream source) 构造一个新的 Scanner ，产生从指定输入流扫描的值。
    6.查看查看成员方法，学习常用成员方法

 */
public class Demo01Scanner {
    public static void main(String[] args) {
        //创建键盘录入的对象
        //Scanner(InputStream source) 构造一个新的 Scanner ，产生从指定输入流扫描的值。
        InputStream xx = System.in;
        Scanner sc = new Scanner(xx);

        //实现键盘录入一个字符串
        //通过查看API：
        // String next()查找并返回此扫描仪的下一个完整令牌。 遇到空就不读取数据了
        System.out.println("请输入一个字符串：");
//        String s1 = sc.next();
//        System.out.println(s1);
        //String nextLine() 将此扫描仪推进到当前行并返回跳过的输入。 遇到回车换行就不读取了
        String s2 = sc.nextLine();
        System.out.println(s2);
    }
}

1.2Random使用

/*
    1.查看API
    2.查看包结构和类结构
        java.util.Random
        public class Random extends Object implements Serializable
    3.类的描述
        该类的实例用于生成伪随机数的流
    4.学习常用的构造方法
        Random() 创建一个新的随机数生成器。
    5.学习常用方法
        int nextInt() 返回下一个伪随机数，从这个随机数发生器的序列中均匀分布 int值。
        int nextInt(int bound) 返回伪随机的，均匀分布 int值介于0（含）和指定值（不包括），从该随机数生成器的序列绘制。
        bound 的值必须大于0，否则报错：IllegalArgumentException
 */

import java.util.Random;

public class Demo02Random {
    public static void main(String[] args) {
        Random random = new Random();
        //int nextInt() 返回下一个伪随机数，从这个随机数发生器的序列中均匀分布 int值。
        for (int i = 0; i < 100; i++) {
            int num = random.nextInt(); //int类型数据的取值范围的内的数据；
            System.out.println(num);
        }
        System.out.println("--------------------");
        //int nextInt(int bound) 返回伪随机的，均匀分布 int值介于0（含）和指定值（不包括），从该随机数生成器的序列绘制。
        for (int i = 0; i < 100; i++) {
            int num = random.nextInt(100);
            System.out.println(num);
        }
    }
}

2.String类的学习

1.打开API 搜索String类
  	String类代表字符串。 Java程序中的所有字符串文字（例如"abc" ）都被实现为此类的实例。 
2.查看包结构和类结构
    java.lang.String //  java.lang.*; lang包下的所有类在使用的时候不需要导包
    public final class String extends Object implements Serializable, Comparable<String>, CharSequence
3.查看构造方法 学习常用的构造方法
    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对象，使其表示与参数相同的字符序列; 换句话说，新创建的字符串是参数字符串的副本。 
 4.常用方法：
     查看String底层原码，发现 private final byte[] value; 说明String底层是使用字节数组来存储数据的。
     可以知道字符串有索引：索引是从0开始到字符长度减一
     char charAt(int index) 返回 char指定索引处的值。 
     int length() 返回此字符串的长度。 
     boolean equals(Object anObject) 将此字符串与指定对象进行比较。 
     String trim() 返回一个字符串，其值为此字符串，并删除任何前导和尾随空格。
     boolean equalsIgnoreCase(String anotherString) 将此 String与其他 String比较，忽略案例注意事项。 
     String toUpperCase() 将所有在此字符 String使用默认语言环境的规则大写。  
     String toLowerCase() 将所有在此字符 String使用默认语言环境的规则，以小写。  
     String replaceAll(String regex, String replacement) 用给定的替换替换与给定的 regular expression匹配的此字符串的每个子字符串。 
     String replace(CharSequence target, CharSequence replacement) 将与字面目标序列匹配的字符串的每个子字符串替换为指定的字面替换序列。  
     String[] split(String regex) 将此字符串分割为给定的 regular expression的匹配。 
     String substring(int beginIndex) 返回一个字符串，该字符串是此字符串的子字符串。  
     String substring(int beginIndex, int endIndex) 返回一个字符串，该字符串是此字符串的子字符串。
     char[] toCharArray() 将此字符串转换为新的字符数组。 
     boolean isEmpty() 返回 true如果，且仅当 length()为 0 。  
     boolean startsWith(String prefix) 测试此字符串是否以指定的前缀开头。 
     boolean endsWith(String suffix) 测试此字符串是否以指定的后缀结尾。  
      

2.1构造方法

/*
    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对象，使其表示与参数相同的字符序列; 换句话说，新创建的字符串是参数字符串的副本。
 */
public class Demo01String构造方法 {
    public static void main(String[] args) {
        //String() 初始化新创建的 String对象，使其表示空字符序列。
        String s1 = new String();
        System.out.println(s1);

        //String(byte[] bytes) 通过使用平台的默认字符集解码指定的字节数组来构造新的 String 。
        byte[] bytes = {97,98,99,100,101,102,103};
        String s2 = new String(bytes);
        System.out.println(s2);

        //String(byte[] bytes, int offset, int length) 通过使用平台的默认字符集解码指定的字节子阵列来构造新的 String 。
        //offset 参数表示的是从字节数组的第几个索引开始
        //length 参数表示取字节数组中，从offset索引位置开始取几个数据
        String s3 = new String(bytes, 0, 3);
        System.out.println(s3);

        //String(char[] value) 分配一个新的 String ，以便它表示当前包含在字符数组参数中的字符序列。
        char[] chars = {'a','b','c','d','e','f','g'};
        String s4 = new String(chars);
        System.out.println(s4);

        //String(char[] value, int offset, int count) 分配一个新的 String ，其中包含字符数组参数的子阵列中的字符。
        //offset 参数表示的是从字符数组的第几个索引开始
        //count 参数表示取字符数组中，从offset索引位置开始取几个数据
        String s5 = new String(chars, 3, 3);
        System.out.println(s5);

        //String(String original) 初始化新创建的String对象，使其表示与参数相同的字符序列; 换句话说，新创建的字符串是参数字符串的副本。
        String s6 = new String("abcdefg");
        System.out.println(s6);

        //Java程序中的所有字符串文字（例如"abc" ）都被实现为此类的实例
        String s7 = "abcdefg";  //推荐写法
        System.out.println(s7);
    }
}

2.2常用方法char charAt(int index) ，int length()

public class Demo02String常用方法 {
    public static void main(String[] args) {
        String s1 = "abcdefg";
        //char charAt(int index)
        //返回 char指定索引处的值。
        char c1 = s1.charAt(0);
        System.out.println(c1);
        char c2 = s1.charAt(1);
        System.out.println(c2);
        /*
        查看String底层原码，发现 private final byte[] value; 说明String底层是使用字节数组来存储数据的。
        可以知道字符串有索引：索引是从0开始到字符长度减一,可以使用循环遍历字符串中的字符并输出
         */
        for (int i = 0; i < 7; i++) {
            char c = s1.charAt(i);
            System.out.println(c);
        }
        //int length()
        //返回此字符串的长度。
        int length = s1.length();
        System.out.println(length);

        //遍历字符
        for (int i = 0; i < s1.length(); i++) {
            char c = s1.charAt(i);
            System.out.println(c);
        }


    }
}

2.3 常用方法equals

public class Demo02String常用方法equals {
    public static void main(String[] args) {
        //boolean equals(Object anObject)
        //将此字符串与指定对象进行比较。
        String s1 = "abc";
        String s2 = new String("abc");
        boolean b =   s1.equals(s2);
        System.out.println(b);

        //比较两个数值是否相等  使用 ==
        //如果比较两个对象是否相等 若使用 == 比较的是 对象在内存中的地址
        int a = 10;
        int c = 20;
        c = 10;
        System.out.println(a==c);
        System.out.println(s1==s2);
    }
}

2.4用户登录

import java.util.Scanner;

/*
    模拟用户登录
    1.键盘录入 用户名和密码
    2.和已存在的用户名和密码比较
    3.如果相等就输出登陆成功
    4.如果不相等提示登录信息，只允许登录三次
 */
public class Demo03用户登录 {
    public static void main(String[] args) {
        //已存在的用户名和密码
        String userName = "admin";
        String passWord = "123 456";
        //键盘录入 用户名和密码
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < 3; i++) {
            //提示请输入用户名  提示请输入密码
            System.out.println("请输入用户名");
            String user = sc.nextLine();
            System.out.println("请输入密码");
            String pwd = sc.nextLine();
            if (userName.equals(user) && passWord.equals(pwd)) {
                System.out.println("登录成功");
                break;
            }else {
                if (2-i==0){
                    System.out.println("您的账户已锁定，请联系管理员！！！");
                }else {
                    System.out.println("登录失败,还有"+(2-i)+"次机会！！");
                }
            }
        }
    }
}

2.5用户登录案例优化版

import java.util.Scanner;

/*
    模拟用户登录
    1.键盘录入 用户名和密码
    2.和已存在的用户名和密码比较
    3.如果相等就输出登陆成功
    4.如果不相等提示登录信息，只允许登录三次
 */
public class Demo03用户登录 {
    public static void main(String[] args) {
        //已存在的用户名和密码
        String userName = "admin";
        String passWord = "123456";

        //验证码
        String yanZhengMa = "Abc12D";

        //键盘录入 用户名和密码
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < 3; i++) {
            //提示请输入用户名  提示请输入密码
            System.out.println("请输入用户名");
            String user = sc.nextLine();
            String newUser = user.trim();
            System.out.println("请输入密码");
            String pwd = sc.nextLine();
            System.out.println("请输入验证码Abc12D：");
            String yzm = sc.nextLine();
          	//比较键盘录入的数据和模拟数据进行比较
            if (userName.equals(newUser) && passWord.equals(pwd) && yanZhengMa.equalsIgnoreCase(yzm)) {
                System.out.println("登录成功");
                break;
            }else {
                if (2-i==0){
                    System.out.println("您的账户已锁定，请联系管理员！！！");
                }else {
                    System.out.println("登录失败,还有"+(2-i)+"次机会！！");
                }
            }
        }
    }
}

2.6 toUpperCase()和 toLowerCase()方法的使用

/*
    模拟用户登录
    1.键盘录入 用户名和密码
    2.和已存在的用户名和密码比较
    3.如果相等就输出登陆成功
    4.如果不相等提示登录信息，只允许登录三次
 */
public class Demo03用户登录 {
    public static void main(String[] args) {
        //已存在的用户名和密码
        String userName = "admin";
        String passWord = "123456";

        //验证码
        String yanZhengMa = "Abc12D";

        //键盘录入 用户名和密码
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < 3; i++) {
            //提示请输入用户名  提示请输入密码
            System.out.println("请输入用户名");
            String user = sc.nextLine();
            String newUser = user.trim();
            System.out.println("请输入密码");
            String pwd = sc.nextLine();
            //String toUpperCase()
            //将所有在此字符 String使用默认语言环境的规则大写。
            //String toLowerCase()
            //将所有在此字符 String使用默认语言环境的规则，以小写。
            System.out.println("请输入验证码Abc12D：");
//            String yzm = sc.nextLine().toUpperCase();
            String yzm = sc.nextLine().toLowerCase();

            if (userName.equals(newUser) && passWord.equals(pwd) && yanZhengMa.toLowerCase().equals(yzm)) {
                System.out.println("登录成功");
                break;
            }else {
                if (2-i==0){
                    System.out.println("您的账户已锁定，请联系管理员！！！");
                }else {
                    System.out.println("登录失败,还有"+(2-i)+"次机会！！");
                }
            }
        }
    }
}

2.7遍历字符串

import java.util.Scanner;

/*
    需求：键盘录入一个字符串，使用程序实现在控制台遍历该字符串
 */
public class Demo04遍历字符串 {
    public static void main(String[] args) {
//        printString01();
        printString02();
    }
    /*
    char[] toCharArray() 将此字符串转换为新的字符数组。
    分析：
        1.键盘录入
        2.遍历字符串
            2.1   toCharArray()
            2.2   直接遍历数组 拿到每一个元素输出
     */

    public static void printString02() {
        //1.键盘录入
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();
        //2.遍历字符串
        //2.1 char[] toCharArray() 将此字符串转换为新的字符数组。
        char[] chars = line.toCharArray();
        //2.2遍历字符数组
        for (int i = 0; i < chars.length; i++) {
            System.out.println(chars[i]);
        }
    }

    /*
    //char charAt(int index)返回 char指定索引处的值。
    分析：
        1.键盘录入
        2.遍历字符串
            2.1 charAt(int index)
            2.2 因为字符串的底层是数组，所以我们知道，它有索引，并且索引从0开始，到字符串的长度减一
            2.3 字符串的长度，可以使用 int length() 返回此字符串的长度。
            2.4 使用循环遍历 for循环
     */
    public static void printString01() {
        //1.键盘录入
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();
        //2.遍历字符串
        for (int i = 0; i < line.length(); i++) {
            char c = line.charAt(i);
            System.out.println(c);
        }
    }
}

2.8 统计字符次数

//需求：键盘录入一个字符串，统计该字符串中大写字母字符，小写字母字符，数字字符出现的次数(不考虑其他字符)
/*
    需求：以字符串的形式从键盘接受一个手机号，将中间四位号码屏蔽
    最终效果为：156****1234

    //CharSequence subSequence(int beginIndex, int endIndex)
    //返回一个字符序列，该序列是该序列的子序列。
    //String phoneNum = "13917295832";
    //CharSequence sequence = phoneNum.subSequence(0, 3);
    //System.out.println(sequence);

    //String substring(int beginIndex)
    //返回一个字符串，该字符串是此字符串的子字符串。

    //String substring(int beginIndex, int endIndex)
    //返回一个字符串，该字符串是此字符串的子字符串。
    //beginIndex:从字符串的哪个索引开始
    //endIndex:到哪个索引结束，只能获取到endIndex索引-1的位置上的元素

    数据脱敏：
        把有敏感的信息屏蔽
 */
public class Demo06手机号屏蔽 {
    public static void main(String[] args) {
        String phoneNum = "13917295832";
//        CharSequence sequence = phoneNum.subSequence(0, 3);
//        System.out.println(sequence);
        String lastStr = phoneNum.substring(7);
        System.out.println(lastStr);

        String firstStr = phoneNum.substring(0, 3);
        System.out.println(firstStr);

        String newPhoneNum = firstStr+"****"+lastStr;
        System.out.println(newPhoneNum);

    }
}

2.9 敏感词替换

import java.util.Scanner;

/*
    需求：键盘录入一个 字符串，如果字符串中包含（TMD），则使用***替换
    //String replace(CharSequence target, CharSequence replacement)
        将与字面目标序列匹配的字符串的每个子字符串替换为指定的字面替换序列。

     分析：
        1.键盘录入
        2.替换敏感词汇
 */
public class Demo07 {
    public static void main(String[] args) {
        //键盘录入
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();
        String newString = line.replace("TMD", "***");
        System.out.println(newString);
    }
}

2.10字符串切割

import java.util.Arrays;
import java.util.Scanner;

/*
    需求：以字符串的形式从键盘录入学生信息，例如：“张三 , 23”从该字符串中切割出有效数据
    封装为Student学生对象

    //分析：
        1.键盘录入
        2.切割字符串
            String[] split(String regex)将此字符串分割为给定的 regular expression的匹配。
        3.切割出来的数据封装成学生类对象
            3.1 学生类

 */
public class Demo08切割字符串 {
    public static void main(String[] args) {
        //键盘录入
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入学生信息用','隔开：");
        String line = sc.nextLine();
        //把line字符串，切割成字符数组
        String[] stuInfo = line.split(",");
        System.out.println(Arrays.toString(stuInfo));
        //创建学生对象
        Student stu = new Student();
        stu.setName(stuInfo[0]);
        stu.setAge(stuInfo[1]);

        System.out.println(stu.getName());
        System.out.println(stu.getAge());


    }
}

public class Student {
    private String name;
    private String age;

    public Student() {
    }

    public Student(String name, String age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }
}

2.11字符串切割 封装对象 了解

/*
    需求：以字符串的形式从键盘录入学生信息，例如：“张三 , 23”从该字符串中切割出有效数据
    封装为Student学生对象

    //分析：
        1.键盘录入
        2.切割字符串
            String[] split(String regex)将此字符串分割为给定的 regular expression的匹配。
        3.切割出来的数据封装成学生类对象
            3.1 学生类

 */
public class Demo08切割字符串 {
    public static void main(String[] args) {
        //键盘录入
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入学生信息用','隔开：");
        String line = sc.nextLine();
        //把line字符串，切割成字符数组
        String[] stuInfo = line.split(",");
        System.out.println(Arrays.toString(stuInfo));
        //创建学生对象
        Student stu = new Student();
        stu.setName(stuInfo[0]);
        String age = stuInfo[1];
        /*
            了解
            Integer 类中的 static Integer valueOf(String s)返回一个 Integer对象，保存指定的值为 String 。
         */
        stu.setAge(Integer.valueOf(age));

        System.out.println(stu.getName());
        System.out.println(stu.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;
    }
}

2.12 String 常用方法摘要

 boolean isEmpty() 返回 true如果，且仅当 length()为 0 。  
 boolean startsWith(String prefix) 测试此字符串是否以指定的前缀开头。 
 boolean endsWith(String suffix) 测试此字符串是否以指定的后缀结尾。

/*
     boolean isEmpty() 返回 true如果，且仅当 length()为 0 。
     boolean startsWith(String prefix) 测试此字符串是否以指定的前缀开头。
     boolean endsWith(String suffix) 测试此字符串是否以指定的后缀结尾。
 */
public class Demo09 {
    public static void main(String[] args) {
        String str = "";
        // boolean isEmpty() 返回 true如果，且仅当 length()为 0 。
        boolean b = str.isEmpty();
        System.out.println(b);
        str = "张三";
        boolean b1 = str.startsWith("张");
        System.out.println(b1);
        str = "100ml";
        boolean b2 = str.endsWith("ml");
        System.out.println(b2);
    }
}

3.Stringbuilder类学习

java.lang.StringBuilder 
  
public final class StringBuilder
extends Object
implements Serializable, CharSequence
  
//一个可变的字符序列

3.1学习构造方法

StringBuilder() 构造一个没有字符的字符串构建器，初始容量为16个字符。
StringBuilder(int capacity) 构造一个没有字符的字符串构建器，由 capacity参数指定的初始容量。 
StringBuilder(String str) 构造一个初始化为指定字符串内容的字符串构建器。 

/*
    StringBuilder() 构造一个没有字符的字符串构建器，初始容量为16个字符。
    StringBuilder(int capacity) 构造一个没有字符的字符串构建器，由 capacity参数指定的初始容量。
    StringBuilder(String str) 构造一个初始化为指定字符串内容的字符串构建器。
 */
public class Demo01构造方法 {
    public static void main(String[] args) {
        //StringBuilder() 构造一个没有字符的字符串构建器，初始容量为16个字符。
        StringBuilder ss = new StringBuilder();
        System.out.println(ss);
        //int capacity() 返回当前容量。
        int capacity = ss.capacity();
        System.out.println(capacity);
        // StringBuilder(int capacity) 构造一个没有字符的字符串构建器，由 capacity参数指定的初始容量。
        StringBuilder ss2 = new StringBuilder(32);
        int capacity1 = ss2.capacity();
        System.out.println(capacity1);
        //StringBuilder(String str) 构造一个初始化为指定字符串内容的字符串构建器。
        String str = "abc";
        StringBuilder builder = new StringBuilder(str);
        System.out.println(builder);
    }
}

3.2学习常用方法

int capacity()返回当前容量。 
StringBuilder append(Object obj) 追加 Object参数的字符串 Object形式。  

/*
StringBuilder append(Object obj) 追加 Object参数的字符串 Object形式。
 */
public class Demo02 {
    public static void main(String[] args) {
        StringBuilder ss = new StringBuilder();
        StringBuilder s1 = ss.append(100);
        StringBuilder s2 = ss.append('a');
        StringBuilder s3 = ss.append(true);
        System.out.println(ss);
        System.out.println(ss == s1);
        System.out.println(s2 == s1);
        System.out.println(s2 == s3);
        //append方法添加数据后返回值是对象本身
        StringBuilder sss = new StringBuilder();
        sss.append(100).append('a').append(true);//链式编程
        System.out.println(sss);

    }
}

import java.util.Scanner;

/*
    键盘录入一个字符串，以字符串的逆序存在

     //StringBuilder reverse() 导致该字符序列被序列的相反代替。
     //String toString() 返回表示此顺序中的数据的字符串。
 */
public class Demo03 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String line = scanner.nextLine();
        String newStr = "";
        //遍历字符串
        /*
           不能实现字符串反转
        for (int i = 0; i < line.length(); i++) {
            char c = line.charAt(i);
            newStr += c;
        }*/
        /*字符串的反转 方式一
        for (int i = line.length()-1; i >= 0; i--) {
            char c = line.charAt(i);
            newStr += c;
        }*/
        //StringBuilder reverse() 导致该字符序列被序列的相反代替。
        //把字符串对象装成StringBuilder对象
        StringBuilder builder = new StringBuilder(line);
        /*
        //调用StringBuilder的reverse方法实现字符串的反转
        StringBuilder reverse = builder.reverse();
        System.out.println(builder == reverse);
        //StringBuilder对象转成String对象
        //String toString() 返回表示此顺序中的数据的字符串。
        newStr = reverse.toString();
        */
        newStr = new StringBuilder(line).reverse().toString();

        System.out.println(newStr);
    }
}

3.3StringBuilder和String的区别

String ：内容是不可变的
StringBuilder ：内容是可变的

3.4练习

/*
    需求：键盘接受一个字符串，程序判断出该字符串是否是对称字符串，并在控制台打印是或不是
	对称字符串：123321、111
	非对称字符串：123123
	分析：
	    1.键盘录入
	    2.字符串变成StringBuilder对象
	    3.调用reverse()方法反转
	    4.调用toString()方法转成String对象
	    5.String的equals方法比较

 */
public class Demo04 {
    public static void main(String[] args) {
        //1.键盘录入
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();
        /*//2.字符串变成StringBuilder对象
        StringBuilder builder = new StringBuilder(line);
        //3.调用reverse()方法反转
        StringBuilder reverse = builder.reverse();
        //4.调用toString()方法转成String对象
        String s = reverse.toString();*/
        String s = new StringBuilder(line).reverse().toString();

        //5.String的equals方法比较
        if (s.equals(line)) {

            System.out.println("回文数");
        }else {
            System.out.println("不是回文数");
        }

    }
}

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

        分析：
            1.参数列表：int[]arr
            2.返回值类型：String
            3.功能：把数组变成字符串格式化输出
            4.方法名printArray

 */
public class Demo05拼接字符串 {
    public static void main(String[] args) {
        int[] arr = {1,2,3};
        String ss = printArray(arr);
        System.out.println(ss);

    }
    public static String printArray(int[] arr) {
        StringBuilder str = new StringBuilder();
        str.append("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length-1){
                str.append(arr[i]);
            }else {
                str.append(arr[i]).append(", ");

            }
        }
        str.append("]");
        return str.toString();

    }

    /*public static String printArray(int[] arr) {
        String str = "[";
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length-1){
                str+=arr[i];
            }else {
                str += arr[i];
                str += ", ";
            }
        }
        str +="]";
        return str;

    }*/
}

3.5StringBuilder 和 String 相互转化

1. StringBuilder 转换为 String
        public String toString()：通过 toString() 就可以实现把 StringBuilder 转换为 String
2. String 转换为 StringBuilder
        public StringBuilder(String s)：通过构造方法就可以实现把 String 转换为 StringBuilder