02_Java语音进阶||day01_Object类、常用API(日期时间类，System类，StringBuilder类)、包装类

第一章 Object类

1.1 概述

java.lang.Object类是Java语言中的根类，即所有类的父类。
API中叙述：
- 类 Object 是类层次结构的根(最顶层)类。每个类都使用 Object 作为超类(父类)。所有对象（包括数组）都实现这个类的方法。
如果一个类没有特别指定父类，那么默认则继承自Object类。
- 如果一个类继承了其他的类，那么被继承的类默认也是Object类
```
    public class MyClass /* extends Object */ {
        //...
    }
```

1.2 Object类的toString方法

API：++String++ toString();
- 返回该对象的字符串表示

直接打印对象的名字，其实就是调用对象的toString方法（p = p.toString）

    //主方法中
    Person p = new Person("张三", 20);
    String s = p.toString();
    System.out.println(s);  //cn.javaadvance.day01.demo01.Person@1b6d3586

    System.out.println(p);  //cn.javaadvance.day01.demo01.Person@1b6d3586

所以直接使用toString打印的是地址值（没意义），需要重写Object类中的toString方法，来打印对象的属性

格式：（alt + Ins即可）

    //定义一个Person类
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

看一个类是否重写的toString方法，直接打印这个类对应对象的名字即可。
- 如果没有重写toString方法，那么打印的就是对象的地址值（默认）
- 如果重写toString方法，那么就按照重写的方式打印

    //定义一个Person类：Person.java
    public class Person {
        private String name;
        private int age;
    
        public Person() {
        }
    
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        //所以直接使用toString打印的是==地址值==（没意义），需要==重写Object类中的toString方法==，==来打印对象的属性==
        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", 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;
        }
    }
    
    //主方法：Demo01ToString.java
    public static void main(String[] args) {
        Person p = new Person("张三", 20);
        String s = p.toString();
        System.out.println(s);  //cn.javaadvance.day01.demo01.Person@1b6d3586

        System.out.println(p);  //cn.javaadvance.day01.demo01.Person@1b6d3586

        //测试一些类是否重写了toString方法
        Random r = new Random();
        System.out.println(r);  //没有重写

        Scanner sc = new Scanner(System.in);
        System.out.println(sc); //重写了toString方法

        ArrayList<Integer> listA = new ArrayList<>();
        listA.add(1);
        listA.add(2);
        System.out.println(listA);  //重写了toString方法
    }

1.3 Object类的equals方法

API：++boolean++ equals(Object obj)
- 指示其他某个对象是否与此对象“相等”。
Object类equals方法的源码：
```
    public boolean equals(Object obj) {
        return (this == obj);
    }
```
- 参数：
  - Object obj：可以传递任意的对象
- 方法体：
  - ==：比较运算符，返回的就是一个布尔值true,false
  - 基本数据类型：比较的是值
  - 引用数据类型：比较的是两个对象的地址
  - this是谁？：那个对象调用的方法，方法中的this就是那个对象
  - obj是谁？：传递过来的参数

    //定义的Person类和1.2一样
    
    //主方法：Demo02Equals.java
    public static void main(String[] args) {
        Person p1 = new Person("迪丽热巴", 18);
        Person p2 = new Person("古力娜扎", 18);
        
        boolean equals = p1.equals(p2);
        System.out.println(equals); //false

        //如果想一样就把p2地址赋给p1
        p1 = p2;
        boolean equals1 = p1.equals(p2);
        System.out.println(equals1);    //true
    }

1.4 重写Object类的equals方法

Object类的equals方法默认比较的是两个对象的地址值，没有意义
- 所以我们需要重写equals方法，比较两个对象的属性值
问题：隐含着一个多态
- Object obj = p2 = new Person(“古力娜扎”, 18);
- 多态的弊端：无法使用子类特有的内容（属性，方法）
解决：可以使用向下转型（强转）把Object类型转换为Person
- 需要加一个判断instanceof(左侧对象是否是右侧类的一个实例)，是Person类型在转换，防止类型转换异常（ClassCastException）
  - 不然创建一个Random类对象比较后，向下转型就会出错
补充：
1. 可以增加一个判断，如果传递的参数obj是null（引用数据类型的默认），直接返回false——>提高程序效率
2. 可以增加一个判断，传递的参数obj是this本身，直接返回true，提高程序效率

(自己写的)重写equals

//定义的一个Person类
//(自己写的)重写equals
@Override
public boolean equals(Object obj) {
    //可以增加一个判断，传递的参数obj是this本身，直接返回true，提高程序效率
    if(obj == this){
        return true;
    }

    //如果传递的参数obj是null（引用数据类型的默认），直接返回false
    if(obj == null){
        return false;
    }

    //需要加一个判断，是Person类型在转换，防止类型转换异常（ClassCastException）
    if(obj instanceof Person){
        //使用向下转型（强转）把Object类型转换为Person
        Person p = (Person) obj;
        //比较两个对象的属性；一个是调用方法的this（p1），一个就是p（obj = p2）
        boolean b = this.name.equals(p.name) && (this.age == p.age);   //这里的equals是字符串重写的方法比较两个字符串内容是否相同
        return b;
    }
    //不是Person类型直接返回false
    return false;
}

注：上面讲原理，实际使用看下面

以后使用(alt+Ins)快捷添加——这里直接添加equals()和hashCode()

默认equals版本

//快捷键生成的默认版本equals
@Override
public boolean equals(Object o) {
    if (this == o) return true; //判断是否是本身
    if (!(o instanceof Person)) return false;   //判断o如果不是Person的实例返回false

    Person person = (Person) o; //向下转型

    if (getAge() != person.getAge()) return false;  //比较年龄，如果不相等就返回false
    return getName() != null ? getName().equals(person.getName()) : person.getName() == null;   //如果不为空执行前面来判断名字，否则和null比较
}

Java7 +版本——建议使用这个版本【重点】

其中调用了Objects（注：多s）工具类里面的equals方法
Objects传递的是两个对象
import java.util.Objects;需要导包

@Override
public boolean equals(Object o) {
    if (this == o) return true; //判断是否是本身
    if (!(o instanceof Person)) return false;   //判断o如果不是Person的实例返回false
    Person person = (Person) o; //向下转型
    return getAge() == person.getAge() &&
            Objects.equals(getName(), person.getName());    //调用了Objects（注：多s）工具类里面的equals方法
}

注：今后学习：getClass() != o.getClass()——反射技术，判断o是不是Person类型，等同于：!(o instanceof Person)

1.5 Objects类的equals方法

概述Object工具类（因为是静态的所以直接通过类名.来使用）
- 在++JDK7++添加了一个Objects工具类，它提供了一些方法来操作对象，它由一些静态（static）的实用方法组成，这些方法是：
  - null-save(空指针安全的)或null-tolerant(容忍空指针的)
    - 字符串和null的字符串比较不会抛异常
  - 用于计算对象的hashcode
  - 返回对象的字符串表示形式
  - 比较两个对象
在比较两个对象的时候（Object类和Objects工具类区别）
- Object类的equals方法容易抛出空指针异常
- Objects工具类的equals方法就优化了这个问题

Objects工具类equals方法的源码：

public static boolean equals(Object a, Object b) {
    return (a == b) || (a != null && a.equals(b));
}

默认比较的是两个对象的地址，但是如果类重写了（Object类的）equals方法，比较的就是内容【重点】

    Person p1 = new Person("人", 18);
    Person p2 = new Person("人", 18);
    boolean equals = Objects.equals(p1, p2);
    System.out.println(equals);
    //如果Person类重写了Object类的equals方法返回true（比较的是内容）
    //如果Person类没有重写Object类的equals方法返回false（比较的是地址）

对两个对象比较，防止空指针异常

注：null是不能调用方法的，会抛出空指针异常。【重点】
- 但是String str = “”; //""可以调用方法，虽然为空也是字符串

    String s1 = null;   //不可以调用方法
    String s2 = "aaa";

    //boolean b = s1.equals(s2);//这里的equals是字符串重写的方法，比较的是内容
    //System.out.println(b);  //NullPointerException

    boolean b1 = Objects.equals(s1, s2);
    System.out.println(b1); //false

1.6 Object类&Objects类总结

总结图：

同用的类：Student.java

    public class Student {
        private String name;
        private int age;
        ;
    
        public Student() {
        }
    
        public Student(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof Student)) return false;
            Student student = (Student) o;
            return getAge() == student.getAge() &&
                    Objects.equals(getName(), student.getName());
        }
    
    
    
        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;
        }
    }

Objact类中的toString()方法演示

    //定义一个Test01.java
    public static void main(String[] args) {
        String str = "abc";
        System.out.println(str);    //abc——String类已经重写的toString

        Student s = new Student("张三", 20);
        //System.out.println(s);  //对象地址
        //System.out.println(s.toString());   //效果一样

        //重写toString后
        System.out.println(s);  //Student{name='张三', age=20}
    }

Objact类中的equals()方法演示

    //定义一个Test02.java
    public static void main(String[] args) {
        //String类当中重写的equals方法
        String s1 = "abc";
        String s2 = "abc";
        System.out.println(s1.equals(s2));  //true：字符串重写的equals方法，比较内容

        Student stu1 = new Student("张三", 20);
        Student stu2 = new Student("张三", 20);
        //重写方法前
        //System.out.println(stu1.equals(stu2));  //false：没有重写类中equals方法，所以比较的地址

        //想比较对象中的属性(重写equals方法后)
        System.out.println(stu1.equals(stu2));  //true：比较的内容
    }

Objacts工具类中的equals()方法演示

    public static void main(String[] args) {
        //String类当中重写的equals方法
/*        String s1 = "abc";
        String s2 = "abc";
        System.out.println(s1.equals(s2));  //true：字符串重写的equals方法，比较内容*/

        //s1若为null
        /*String s1 = null;
        String s2 = "abc";
        System.out.println(s1.equals(s2));  //NullPointerException空指针异常*/

        //避免空指针问题——Objects工具类的equals方法
        String s1 = null;
        String s2 = "abc";
        System.out.println(Objects.equals(s1, s2));  //false
    }

第二章日期时间类——API

2.1 Date类概述（需要util导包）

java.util.Date 类表示特定的瞬间，精确到毫秒
- 毫秒：千分之一秒（1000毫秒 = 1秒）
- 特定的瞬间：一个时间点，一刹那时间（2020-1-2 10:40:43:333）
毫秒值得作用：可以对时间和日期进行计算
- 可以把日期转换为毫秒进行计算，计算完毕，再把毫秒转换为日期
把日期转化为毫秒
- 当前的日期：2020-1-2
- 时间原点（0毫秒）：1970 年 1 月 1 日 00:00:00（++英国格林威治++）——API中称为（历元）
- 就是计算当前日期到时间原点之间一共经历了多少毫秒
- 注：中国属于东八区：会把时间增加8个小时
  - 所以在我们这里时间原点是：1970 年 1 月 1 日 08:00:00
- 注：System.currentTimeMillis() //获取当前系统时间一共到1970 年 1 月 1 日 00:00:00经历了多少毫秒（1581389766050L）
```
public static void main(String[] args) {
    System.out.println(System.currentTimeMillis()); //获取当前系统时间一共到1970 年 1 月 1 日 00:00:00经历了多少毫秒
}
```
把毫秒转换为日期
- 1 天 = 24 × 60 × 60 = 86400 秒 = 86400 x 1000 = 86400000毫秒

2.2 Date类的构造方法和成员方法

Date类的空参数构造方法：

Date()：获取的就是当前系统的日期和时间

public static void main(String[] args) {
    demo01();
}

private static void demo01() {
    Date date = new Date();
    System.out.println(date);   //Tue Feb 11 11:09:49 CST 2020
}

CST：中国标准时间

Date类的有参数构造方法：

Date(long date)：传递毫秒值，把毫秒值转换为Date日期
参数要加L

public static void main(String[] args) {
    demo02();
}

private static void demo02() {
    Date date = new Date(0L);
    System.out.println(date);   //Thu Jan 01 08:00:00 CST 1970
    
    Date d3 = new Date(System.currentTimeMillis());
    System.out.println(d3); //Tue Feb 11 11:25:05 CST 2020
}

0L：传入的0毫秒就是时间原点（中国的）

Date类的成员方法
1. ++long++ getTime() ：把日期转换为毫秒
  - API：返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
  - 相当于System.currentTimeMillis(),但是getTime()可以是不同对象，不是固定指：当前系统时间一共到1970 年 1 月 1 日 00:00:00经历了多少毫秒
```
public static void main(String[] args) {
    demo03();
}

private static void demo03() {
    Date da = new Date();   //获取当前日期
    System.out.println(da.getTime());   //1581392267620
}
```

2.3 DateFormat类&SimpleDateFormat类介绍

java.text.DateFormat：是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。
- 子类：Format类的子类
- 抽象类：无法直接创建对象使用
作用
1. 格式化（日期->文本）：将默认英文日期转换为我们看的日期形式，所以转换后为String类型
2. 解析（文本->日期）：
怎么变的->成员方法【重点】
1. ++String++ format(Date date)
  - 按照指定的模式，把Date日期，格式化为符合模式的字符串
2. ++Date++ parse(String source)
  - 把符合模式的字符串，解析为Date日期
抽象类：无法直接创建对象使用，所以使用时需要SimpleDateFormat子类【重点】。(java.text.SimpleDateFormat extends DateFormat)
++SimpleDateFormat中构造方法++：
1. SimpleDateFormat(String pattern)
  - 用给定的模式和默认语言环境的日期格式符号构造 SimpleDateFormat。
  - 参数：
    - String pattern：传递指定的模式
  - 模式：API中有解释
  - 常用模式如下（区分大小写）
```
    * y 年
    * M 月
    * d 日
    * H 时
    * m 分
    * s 秒
```
  - 写对应的模式,会把模式替换成对应的日期和时间
    - “yyyy-MM-dd HH:mm:ss”
    - “yyyy年MM月dd日 HH时mm分ss秒”
  - 模式中的字母不能更改，连接模式的符号可以更改

    //主方法：Demo03DateFormat.java
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    public static void main(String[] args) throws ParseException {  //throws ParseException——>parse()方法用到
        //因为DateFormat是抽象类，所以创建对象用SimpleDateFormat子类
        //参数就是自己指定的模式
        SimpleDateFormat sD = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        //获取当前日期：
        Date date = new Date();

        //使用SimpleDateFormat子类覆盖重写的抽象父类（DateFormat）的方法
        //format()：按照指定的模式，把Date日期，格式化为符合模式的字符串
        String format1 = sD.format(date);
        System.out.println(format1);    //2020-02-11 12:28:12

        //parse()：把符合模式的字符串，解析为Date日期
        Date parse = sD.parse(format1);
        System.out.println(parse);
        System.out.println("===================");
        //======================格式二
        //因为DateFormat是抽象类，所以创建对象用SimpleDateFormat子类
        //参数就是自己指定的模式
        SimpleDateFormat sD1 = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");

        //获取当前日期：
        Date date1 = new Date();

        //使用SimpleDateFormat子类覆盖重写的抽象父类（DateFormat）：format方法
        //format()：按照指定的模式，把Date日期，格式化为符合模式的字符串
        System.out.println(sD1.format(date1));    //2020-02-11 12:28:12
    }
    
    //结果：
    2020-02-11 12:35:38
    Tue Feb 11 12:35:38 CST 2020
    ===================
    2020年02月11日 12时35分38秒

2.4 时间日期相关类总结

Date类
- ++String++ toLocaleString(); //根据本地格式转换日期对象

    public static void main(String[] args) {
        //空参构造方法
        Date d = new Date();
        System.out.println(d);  //Tue Feb 11 14:46:39 CST 2020

        //引用本地日期格式
        System.out.println(d.toLocaleString()); //2020-2-11 14:47:42

        //有参构造方法
        Date d1 = new Date(3000L);
        System.out.println(d1.toLocaleString());  //1970-1-1 8:00:03
    }

DateFormat类&SimpleDateFormat类
- 注：adf.format(d) + .var（快捷方式）->String format = adf.format(d);
- parse()方法会涉及到异常，先阶段把它抛出去（throws ParseException）

    public static void main(String[] args) {
        //空参构造方法
        Date d = new Date();
        System.out.println(d);  //Tue Feb 11 14:46:39 CST 2020

        //创建日期格式化对象
        SimpleDateFormat adf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        String format = adf.format(d);
        System.out.println(format); //2020年02月11日 15:03:21

        String str = "2021年05月17日 15:03:21";
        Date parse = adf.parse(str);
        System.out.println(parse);  //Mon May 17 15:03:21 CST 2021
    }

3. Calendar类（日历类）——>抽象类
* 创建对象不能new，提供了静态方法
1. 创建对象方式：
* Calendar c = Calendar.getInstance();
* 获取日历类对象
2. 成员方法：
* ++int++ get(int n);
* 获取指定日历字段信息
* ++void++ set(int n, int value);（无返回值）
* 将指定日历字段设置为指定的值
* ++void++ add(int n, int value);（无返回值）
* 将指定日历字段增加或减少指定的值
* 注：get方法获取月的时候从0开始，所以要加1

    public static void main(String[] args) {
        //获取日历类对象
        Calendar c = Calendar.getInstance();

        //get方法
        int year = c.get(Calendar.YEAR);
        System.out.println(year);   //2020

        int month = c.get(Calendar.MONTH) + 1;
        System.out.println(month);  //2

        System.out.println("=============");
        //set方法
        c.set(Calendar.YEAR, 2088);
        year = c.get(Calendar.YEAR);
        System.out.println(year);   //2088
        //add方法
        c.add(Calendar.YEAR, 2);
        year = c.get(Calendar.YEAR);
        System.out.println(year);   //2090

        c.add(Calendar.YEAR, -2);
        year = c.get(Calendar.YEAR);
        System.out.println(year);   //2086
    }

第三章 System类——API

3.1 System类的常用方法

java.lang.System 类中提供了大量的静态方法，可以获取与系统相关的信息或系统级操作
常用的方法：
1. ++public static long++ currentTimeMillis();
  - 返回以毫秒为单位的当前时间。
2. ++public static void++ arraycopy(Object src, int srcPos, Object dest, int destPos, int length) ;（无返回值）
  - 从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。
currentTimeMillis方法：返回以毫秒为单位的当前时间
1. 作用：用来测试程序的效率（看一看运行一个程序需要多长时间）
2. 练习：验证for循环打印1-9999所需要使用的时间（毫秒）
  1. 程序执行之前，先获取一次毫秒值
  2. 执行for循环
  3. 程序执行之后，再获取一次毫秒值
  4. end-start

    public class Demo01System {
        public static void main(String[] args) {
            demo01();
        }
    
    
        private static void demo01() {  //验证for循环打印1-9999所需要使用的时间（毫秒）
            //程序执行之前，先获取一次毫秒值
            long s = System.currentTimeMillis();
            //执行for循环
            for(int i = 1; i <= 9999; i++){
                System.out.println(i);
            }
            //程序执行之后，再获取一次毫秒值
            long e = System.currentTimeMillis();
            //end-start
            System.out.println("程序共耗时：" + (e - s) + "毫秒");  //程序共耗时：117毫秒
        }
    }

arraycopy方法：数组复制的方法
1. 参数：（API）
  - src - 源数组。
  - srcPos - 源数组中的起始位置。
  - dest - 目标数组。
  - destPos - 目标数据中的起始位置。
  - length - 要复制的数组元素的数量。
2. 练习：
  - 将src数组中前3个元素，复制到dest数组的前3个位置上
  - 复制元素前：src数组元素[1,2,3,4,5]，dest数组元素[6,7,8,9,10]
  - 复制元素后：src数组元素[1,2,3,4,5]，dest数组元素[1,2,3,9,10]

    public class Demo01System {
        public static void main(String[] args) {
            demo02();
        }
        
        private static void demo02() {  //数组复制的方法
            //定义源数组
            int[] src = {1, 2, 3, 4, 5};
            //定义目标数组
            int[] dest = {6, 7, 8, 9, 10};
    
            System.out.println("复制前的目标数组：" + Arrays.toString(dest));
    
            //使用System类中arraycopy方法
            System.arraycopy(src, 0, dest, 0, 3);
    
            System.out.println("复制后的目标数组：" + Arrays.toString(dest));
    
    /*        //for循环
            for (int i = 0; i < dest.length; i++) {
                System.out.print(dest[i] + " ");
            }
            System.out.println();
            //foreach循环
            for(int d : dest){
                System.out.print(d + " ");
            }
            System.out.println();*/
            //利用Arrays类中的toString方法
        }
    }
    
    //结果：
    复制前的目标数组：[6, 7, 8, 9, 10]
    复制后的目标数组：[1, 2, 3, 9, 10]

第四章 StringBuilder类——API

4.1 StringBuilder的原理

java.lang.StringBuilder（不用导包）
也称为：字符串缓存区——支持可变的字符串（提高字符串效率）

注：一旦超过16就自动扩容一倍->32

4.2 StringBuilder的构造方法和常用方法

构造方法：

public StringBuilder()
- 构造一个空的StringBuilder容器
public StringBuilder(String str)
- 构造一个StringBuilder容器，并将字符串添加进去

    public static void main(String[] args) {
        //StringBuilder无参构造
        StringBuilder bu1 = new StringBuilder();
        System.out.println("bu1:" + bu1);   //bu1:

        //StringBuilder有参构造
        StringBuilder bu2 = new StringBuilder("abc");
        System.out.println("bu2:" + bu2);   //bu2:abc

    }

常用方法：
1. ++public StringBuilder++ append(…)——返回值也是StringBuilder
  - 添加任意类型数据的字符串形式，并返回当前对象自身
  - append方法返回的是this，调用方法的对象本身
  - 所以使用append方法无需接收返回值【重点】
2. ++public String++ toString()
  - 将当前StringBuilder对象转换为String对象

StringBuilder类的append方法

接收返回值-使用apped方法

    public static void main(String[] args) {
        //创建StringBuilder对象
        StringBuilder bu1 = new StringBuilder();

        //接收返回值-使用apped方法
        StringBuilder bu2 = bu1.append("abc");
        System.out.println(bu1);    //abc
        System.out.println(bu2);    //abc
        //引用数据类型比较的是地址
        System.out.println(bu1 == bu2); //true，他本身所以无需接收返回值
    }

基本-使用apped方法【重点】

    public static void main(String[] args) {
        //创建StringBuilder对象
        StringBuilder bu1 = new StringBuilder();

        bu1.append("abc");
        bu1.append(1);
        bu1.append(true);
        bu1.append(2.8);
        System.out.println(bu1);
    }

3.便捷-链式编程：方法的返回值是一个对象，可以根据对象继续调用方法【重点】

    public static void main(String[] args) {
        //创建StringBuilder对象
        StringBuilder bu1 = new StringBuilder();

        bu1.append("abc").append(1).append(true).append(2.8);
        System.out.println(bu1);    //abc1true2.8
    }

StringBuilder类的toString方法
1. StringBuilder和String可以相互转换
  - String->StringBuilder：可以使用StringBuilder的构造方法
  - StringBuilder->String：使用StringBuilder中的toString方法

    public static void main(String[] args) {
        ///先String->StringBuilder
        String str = "Hello";
        System.out.println("str:" + str);
        StringBuilder bu = new StringBuilder(str);
        //StringBuilder添加数据
        bu.append(" World");
        System.out.println("bu:" + bu);

        ///StringBuilder->String
        String s = bu.toString();
        System.out.println("s:" + s);
    }
    
    //结果：
    str:Hello
    bu:Hello World
    s:Hello World

4.3 System类&StringBuilder类总结

System类

    public static void main(String[] args) {
        //获取一下当前系统毫秒值时间
        long time = System.currentTimeMillis();
        System.out.println(time);

        //arraycopy(int[] src, int srcIndex, int[] dest, int dextIndex, int count)复制数组
        int[] src = {1, 2, 3, 4, 5};
        int[] dest = {9, 8, 7, 6, 5};
        System.out.println("复制前：" + Arrays.toString(dest));
        //将src数组中前四个数字复制到dest数组中
        System.arraycopy(src, 0, dest, 0, 4);

        System.out.println("复制后：" + Arrays.toString(dest));
    }
    
    //结果：
    1581422894426
    复制前：[9, 8, 7, 6, 5]
    复制后：[1, 2, 3, 4, 5]

StringBuilder类
- StringBuilder reverse(); //反转内容

    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();

        //append方法——链式编程
        sb.append(6).append("avd").append(4.9).append(true);
        System.out.println(sb);

        //reverse方法——反转
        sb.reverse();
        System.out.println("反转后：" + sb);
        
        //toString方法——StringBuilder转换为String
        String s = sb.toString();
        System.out.println("转为String后：" + s);
    }
    
    //结果：
    6avd4.9true
    反转后：eurt9.4dva6
    转为String后：eurt9.4dva6

第五章包装类

5.1 包装类的概述

包装类：（位于java.lang包中）
- 基本数据类型的数据，使用起来非常的方便，但是没有对应的方法来操作这些数据
- 所以我们可以使用一个类，把基本数据类型的数据包装起来，这个类叫做包装类
- 在包装类中可以定义一些方法，用来操作基本数据类型的数据
包装类和基本数据类型的缺点：
1. 包装类：无法直接参与运算
2. 基本数据类型：没有对应的方法操作数据

5.2 包装类的装箱与拆箱

基本数据类型与对应的包装类对象之间，来回转换的过程称为“装箱”与“拆箱”
- 装箱：从++基本数据类型++转换为对应的++包装类对象++
- 拆箱：从++包装类对象++转换为对应的++基本数据类型++
装箱
1. 构造方法
  1. Integer(int value) 构造一个新分配的 Integer 对象，它表示指定的 int 值。
  2. Integer(String s) 构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。
    - 注：传递的字符串，必须是基本数据类型的字符串，否则会抛出异常;"100"正确,"a"错误【重点】
```
    Integer int1 = new Integer(1);
```
2. 静态方法
  1. static ++Integer++ valueOf(int i) 返回一个表示指定的 int 值的 Integer 实例。
  2. static ++Integer++ valueOf(String s) 返回保存指定的 String 的值的 Integer 对象。
    - 注：传递的字符串，必须是基本数据类型的字符串，否则会抛出异常;"100"正确,"a"错误【重点】
```
    Integer int3 = Integer.valueOf(3);
```
拆箱
1. int intValue() 以 int 类型返回该 Integer 的值。
```
    int i = int4.intValue(); 
```

    public static void main(String[] args) {
        //装箱-构造方法
        Integer int1 = new Integer(1);
        System.out.println(int1);   //1,重写了toString方法
        Integer int2 = new Integer("2");
        System.out.println(int2);

        //装箱-静态方法
        Integer int3 = Integer.valueOf(3);
        System.out.println(int3);
        Integer int4 = Integer.valueOf("4");
        System.out.println(int4);

        //拆箱-intValue方法
        int i = int4.intValue();    //将包装类int4拆箱成基本数据类型
        System.out.println(i);
    }
    
    //结果：
    1
    2
    3
    4
    4

5.3 包装类的自动装箱与自动拆箱

JDK1.5之后出现的新特性

自动装箱：

直接把int类型的整数赋值给包装类

    Integer in = 1; //相当于Integer in = new Integer(1);

自动拆箱：
- in是包装类，无法直接参与运算，可以自动转换为基本数据类型，再参与计算
```
    in = in + 2;
```
- 注：in + 2;就相当于in.intValue() + 2 = 3;
- 注：in = in + 2;相当于in = new Integer(3); //自动装箱

装箱拆箱例子：

    //ArrayList集合无法直接存储整数，可以存储Integer包装类
    ArrayList<Integer> listA = new ArrayList<>();
    listA.add(1);   //自动装箱-->listA.add(new Integer(1));
    int i = listA.get(0);   //自动拆箱-->listA.get(0).intValue();

5.4 基本类型与字符串类型之间的相互转换【重点】

基本数据类型–>String总共有三种方式：
1. 基本数据类型直接与“”相连接即可【重点】。
  - 如：32 + “”;
```
    String s1 = 100 + "";
    //没有转换成功就是300
    System.out.println(s1 + 200);   //100200
```
2. 使用包装类中的静态方法（++和Object类中的toString不一样++）
  - static ++String++ toString(int i)——>返回一个表示指定整数的 String 对象。
```
    String s2 = Integer.toString(123);
    //没有转换成功就是323
    System.out.println(s2 + 200);   //123200
```
3. 使用String类中的静态方法
  - static ++String++ valueOf(int i)——>返回 int 参数的字符串表示形式。
```
    String s3 = String.valueOf(456);
    //没有转换成功就是656
    System.out.println(s3 + 200);   //456200
```
String–>对应的基本类型：
1. 使用包装类中的静态方法
  - 除了Character类之外，都具有parseXxx()静态方法【重点】
  - 格式：parseXxx(“字符串”);
```
    int in1 = Integer.parseInt("100");
    //没有转换成功就是100200
    System.out.println(in1 + 200);  //300
```
  - 注：参数字符串有限定（不然会有数组格式化异常）

5.5 包装类总结

基本数据类型对应的包装类
数字转换为字符串(三种方式)
1. 基本数据类型直接与“”相连接即可【重点】。
  - 如：32 + “”;
```
    String s1 = 100 + "";
    //没有转换成功就是300
    System.out.println(s1 + 200);   //100200
```
2. 使用包装类中的静态方法（++和Object类中的toString不一样++）
  - static ++String++ toString(int i)——>返回一个表示指定整数的 String 对象。
```
    String s2 = Integer.toString(123);
    //没有转换成功就是323
    System.out.println(s2 + 200);   //123200
```
3. 使用String类中的静态方法
  - static ++String++ valueOf(int i)——>返回 int 参数的字符串表示形式。
```
    String s3 = String.valueOf(456);
    //没有转换成功就是656
    System.out.println(s3 + 200);   //456200
```
字符串转换为数字
1. 使用包装类中的静态方法
  - 除了Character类之外，都具有parseXxx()静态方法【重点】
  - 格式：parseXxx(“字符串”);
```
    int in1 = Integer.parseInt("100");
    //没有转换成功就是100200
    System.out.println(in1 + 200);  //300
```
自动拆装箱
1. 自动装箱：
  - 直接把int类型的整数赋值给包装类
```
    Integer in = 1; //相当于Integer in = new Integer(1);
```
2. 自动拆箱：
  - in是包装类，无法直接参与运算，可以自动转换为基本数据类型，再参与计算
```
    in = in + 2;
```

狂野小白兔

发布了42 篇原创文章 · 获赞 6 · 访问量 1138

私信关注