java中Object类、常用API

1.1 Object类

1.1.1 概述

• Java.lang.object类是Java语言中的根类，即所有类的父类。它里面描述的所有方法都可以使用。在对象实例化的时候，最终找的父类就是Object。
• 如更一个类没有特别指定父类，那么默认继承自Object类。
• 根据JDK源代码及Object类的API文档，Object类当中文档包含的方法有11个。下面重点介绍其中2个：
• public String toString():返回该对象的字符串表示。
• public boolean  equals(Object obj):指示其他某个对象是否与此对象“相等”。

public class Student extends Object {
    //...
}

1.1.2 equals方法

回顾Object类的特点：

• 是所有类的父类。
• 所有类都直接或间接继承Object。

equals方法概述：

• boolean equals(object obj)

1. 用来比较两个对象是否相同，相同则返回true，否则false
2. 默认是通过比较两个对象的地址值判断两个对象是否相同

重写equals方法的目的：

1. 在比较两个对象是否相同时不希望通过比较地址值判断，因为比较地址值没有任何意义。而是希望通过比较两个对象的成员变量值来判断两个对象是否相同。 

• 示例代码 

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;
    }

    @Override
    public boolean equals(Object obj){
        //obj ==>s2
        //this==>s1
        //判断obj是否为null
        if(obj == null){
            return false;
        }

        //判断obj是否是this
        if(this == obj){
            return true;
        }

        //判断obj是否是当前类的对象
        if(!(obj instanceof Student)){
            return false;
        }
        //向下转型
        Student s=(Student)obj;
        //比较姓名
        if(!this.name.equals(s.name)){
            return false;
        }
        //比较年龄
        if(this.age != s.age){
            return false;
        }
        return true;
    }
}

public class EqualsDemo {
    public static void main(String[] args) {
        //创建两个学生对象
        Student s1=new Student("jack",10);
        Student s2=new Student("jack",10);

        //比较s1和s2是否相同
        boolean b=s1.equals(s2);
        System.out.println(b);
    }
}

•  这段代码充分考虑了对象为空、类型一致等问题，但方法内容并不唯一。大多数IDE都可以自动生成equals方法的代码内容。在IntelliJ IDEA中，可以使用 Code 菜单中的 Generate… 选项，也可以使用快捷键 alt+insert ，并选 择 equals() and hashCode() 进行自动代码生成，效果相同。

  @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {

        return Objects.hash(name, age);
    }

 1.1.3 toString方法

方法摘要

• public String toString():返回该对象的字符串表示。
• toString方法返回该对象的字符串表示，其实该字符串的内容就是对象的类型+@+内存地址值。
• 由于toString方法返回的结果是内存地址，而在开发中，经常需要按照对象的属性得到相应的字符串表现形式，因此也需要重写它。
• 如果不需要使用toString的默认行为，则可以对它进行覆盖重写。

toString方法归纳：

• 默认返回值是：类全名@对象在内存中的地址值
• toString方法的调用时机

1. 直接调用：通过对象名调用
2. 直接打印对象到控制台，系统会自动调用该对象的toString方法

• 重写toString方法的目的：在打印对象时不想看到对象在内存中的地址值，而是希望看到对象的成员变量是什么。 

•  示例代码
• 在IntelliJ IDEA中，可以点击 Code 菜单中的 Generate... ，也可以使用快捷键 alt+insert ，点击 toString() 选 项。选择需要包含的成员变量并确定。如下图所示：

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;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class ToStringDemo {
    public static void main(String[] args) {
        //创建学生对象
        Student s=new Student("rose",20);
        System.out.println(s.getName()+"="+s.getAge());//rose=20

        //间接调用
        System.out.println(s);//Student{name='rose', age=20}

        //直接调用
        System.out.println(s.toString());//Student{name='rose', age=20}
    }
}

 1.2 Objects类

1.2.1 概述：

• 在刚才IDEA自动重写equals代码中，使用到了java.util.Objects类，那么这个类是什么呢？在JDK7中添加了一个Objects工具类，它提供了一些方法来操作对象，它由一些静态的实用方法组成，这些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的），用于计算对象的hashcode、返回对象的字符串表示形式、比较两个对象。

• public static boolean equals(Object a,Object b)

1. 比较对象a和对象b是否相同，相同则返回true，否则false
2. 底层依赖于对象的equals方法，如果对象没有重写equals方法则是通过比较地址判断

• public static Object requireNonNull（Object obj）

1. 判断对象是否不为null，如果是则返回obj本身，否则抛出异常

• public static boolean nonNull（Object obj）

1. 判断对象obj是否不为null，是返回true，否则返回false

• public static boolean isNull（Object obj）

1. 判断对象obj是否为null，是返回true，否则返回false 

• 示例代码 1

import Test02.Student;

import java.util.Objects;

public class ObjectsDemo01 {
    public static void main(String[] args) {
        //创建两个学生对象
        Student s1= new Student("rose",20);
        Student s2=new Student("jack",20);

        System.out.println(Objects.requireNonNull(s1));//Student{name='rose', age=20}

        if(s1 != null){
            System.out.println(Objects.requireNonNull(s1));//Student{name='rose', age=20}
        }

        //判断对象s1是否为null
        System.out.println(Objects.isNull(s1));//false
        //判断对象s1是否不为null
        System.out.println(Objects.nonNull(s1));//true

        //比较对象是否相同
        System.out.println(Objects.equals(s1,s2));//false

        saveStudent(s1);//Student{name='rose', age=20}
    }
    public static void saveStudent(Student stu){
        //在JDK1.7之前
        /*
            if(stu == null){
             throw new NullPointerException();
            }
         */
        //在JDK1.7之后
        Objects.requireNonNull(stu);

        System.out.println(stu);
    }
}

•  示例代码2

import java.util.Objects;

public class Student {
    private String name;

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

    public String getName() {
        return name;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return Objects.equals(name, student.name);
    }

}

import java.util.Objects;

public class ObjectsDemo {
    public static void main(String[] args) {
        //创建两个学生对象
        Student s1=new Student("张三");
        Student s2=new Student("张三");

        System.out.println(s1);//Test04.Student@75412c2f

        System.out.println(s2);//Test04.Student@282ba1e

        //判断两个对象是否相等
        System.out.println(Objects.equals(s1,s2));//true

        //requireNonNull方法
        System.out.println(Objects.requireNonNull(s1));//Test04.Student@75412c2f
        s1=null;

        //notNull方法
        System.out.println(Objects.nonNull(s1));//false

        //isNull方法
        s2=null;
        System.out.println(Objects.isNull(s2));//true
    }
}

 2.1 Date类

• Java.util.Date类表示特定的瞬间，精确到毫秒。
• 继续查阅Date类的描述，发现Date拥有多个构造函数，只是部分已经过时，但是其中有未过时的构造函数可以把毫秒值转成日期对象。
• public Date():分配Date对象并初始化此对象，以表示分配它的时间（精确到毫秒）。
• public Date(long date):分配Date对象并初始化此对象，以表示自从标准基准时间（称为“历元”（epoch））,即1970年1月1日00:00:00 GMT）以来的指定毫秒数。

1. 由于我们处于东八区，所以我们的基准时间为1970年1月1日8时0分0秒。
2.  简单来说，使用无参构造，可以自动设置当前系统时间的毫秒时刻；指定long类型的构造参数，可以自定义毫秒时刻。

•  代码示例1

import java.util.Date;
/*
    在使用println方法时，会自动调用Date类中的toString方法。
    Date类对Object类中的toString方法进行了覆盖重写，所以结果为指定格式的字符串。
 */
public class Demo01Date {
    public static void main(String[] args) {
        //创建日期对象
        System.out.println(new Date());//Sun Jul 29 18:59:47 CST 2018

        //创建日期对象，把当前的毫秒值转成日期对象
        System.out.println(new Date(0L));//Thu Jan 01 08:00:00 CST 1970
    }
}

总结：

• Date类概述：时间日期类；用来获得时间和日期信息。
• Date类构造方法

1. Date（）获取当前系统时间日期对象
2. Date（long date）根据指定的毫秒值创建日期对象

• Date类成员方法

1. long getTime():获取当前时间的毫秒值

• 毫秒值概述

1.    1秒==1000毫秒

• 时间零点

1.     1970.1.1  00:00:00

import java.util.Date;

public class Demo02Date {
    public static void main(String[] args) {
        //创建日期对象
        Date d=new Date();
        //Sun Jul 29 19:11:32 CST 2018 ==>china standard Time
        //2018-07-29 19:11:32
        //2018/07/29 19:11:32
        System.out.println(d);

        //获取当前时间的毫秒值：1532862798682
        System.out.println(d.getTime());

        //根据毫秒值创建日期对象
        Date d2=new Date(1000L);
        System.out.println(d2);//Thu Jan 01 08:00:01 CST 1970
    }
}

 2.2 DateFormat类

• Java.text.DateFormat是日期/时间格式化子类的抽象类，我们通过这个类可以帮我们完成日期和文本之间的转换，也就是可以在Date对象与String对象之间进行来回转换。
• 格式化：按照指定的格式，从Date对象转换成String对象。
• 解析：按照指定的格式，从String对象转换为Date对象。
•  构造方法： 由于DateFormat为抽象类，不能直接使用，所以需要常用的子类java.text.SimpleDateFormat。这个类需要一个模式（格式）来指定格式化或解析的标准。构造方法为：

1. public simpleDateFormat(String pattern):用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat。参数pattern是一个字符串，代表日期时间的自定义格式。

标识字母（区分大小写）	含义
y	年
M	月
d	日
H	时
m	分
s	秒

• 更详细的格式规则，可以参考SimpleDateFormat类的API文档。

总结：

• DateFormat类概述：是一个日期格式类，抽象类，不能直接创建该类的对象，只能创建子类对象。
• DateFormat类常用子类：SimpleDateFormat
• DateFormat类常见操作：

1. 将日期对象转换为字符串：Date==>String
2. 将日期字符串转换为日期对象：String==>Date

• SimpleDateFormat类的构造方法

1. SimpleDateFormat（）：创建日期格式化对象，使用默认的日期模式
2. SimpleDateFormat（String patte）：指定日期模式创建日期格式化对象

• SimpleDateFormat类的常用方法

1. String format（Date date）：将日期对象格式化为字符串：Date == >String
2. void applyPattern（String pattern）:修改日期模式
3. Date parse（String str）：将日期转换为日期对象：String==>Date

 日期模式

• yyyy    年
• MM     月
• dd       日
• HH      时    HH：24小时制   hh:12小时制
• mm     分
• ss        秒

• 日期转换字符串的步骤
• 创建日期对象
• 创建日期格式化对象并制定日期模式

1. SimpleDateFormat sdf=new SimpleDateFormat（"yyyy/MM/dd  HH:mm:ss"）;

• 调用日期格式化对象format方法并将日期转换为字符串

1. String dstr=sdf.format(d);

• 示例代码1

import java.text.SimpleDateFormat;
import java.util.Date;

public class DateFormatDemo01 {
    public static void main(String[] args) {
        //创建日期对象
        Date d=new Date();
        //使用日期格式化对象：使用默认的日期模式
        SimpleDateFormat sdf=new SimpleDateFormat();
        //方式1：修改日期模式
        sdf.applyPattern("yyyy/MM/dd HH:mm:ss");

        //方式2：创建日期格式化对象：指定日期模式
       // SimpleDateFormat sdf=new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");

        //将日期对象格式化为字符串
        String dstr=sdf.format(d);
        System.out.println(dstr);//2018/07/29 20:02:44
    }
}

• 示例代码2

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/*
    字符串转换日期对象的步骤
        *创建日期格式化对象并指定日期模式
        * SimpleDateFormat sdf=new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
        * 调用日期格式化对象的parse方法将日期转换为日期对象
        * Date d=sdf.parse(str);
 */
public class DateFormatDemo02 {
    public static void main(String[] args) throws ParseException {
        //日期字符串
        String str="2018-07-29 10:26:24";
        //创建日期格式化对象
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //将字符串转换为日期对象
        Date d=sdf.parse(str);
        System.out.println(d);//Sun Jul 29 10:26:24 CST 2018

    }
}

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

/*
    请使用日期相关的API，计算出一个人已经出生了多少天？
    思路：
    1.获取当前时间对应的毫秒值
    2.获取自己出生日期对应的毫秒值
    3.两个时间相减(出生时间-出生日期)
 */
public class DateFormatDemo03 {
    public static void main(String[] args) throws ParseException {
        System.out.println("请输入出生日期 格式 YYYY-MM-dd");
        //获取出生日期，键盘输入
        String birthdayString=new Scanner(System.in).next();

        //将字符串日期转成Date对象
        //创建SimpleDateFormat对象，写日期模式
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");

        //调用方法parse，字符串转成日期对象
        Date birthdayDate=sdf.parse(birthdayString);

        //获取今天的日期对象
        Date todayDate=new Date();

        //将两个日期转成毫秒值。Date类的方法getTime
        long birthdaySecond=birthdayDate.getTime();
        long todaySecond=todayDate.getTime();
        long secone=todaySecond-birthdaySecond;
        if(secone<0){
            System.out.println("还没出生呢");
        }else{
            System.out.println(secone/1000/60/60/24);
        }
    }
}

  2.3 Calendar类

• java.util.Calendar是日历类，在Date后出现，替换掉了许多Date的方法。该类将所有可能用到的时间信息封装为静态成员变量，方便获取。日历就是方便获取各个时间属性的。
• 获取方式：Calendar为抽象类，在创建对象时并非直接创建，而是通过静态方法创建，返回子类对象，如下：
• Calendar静态方法：public static calendar getInstance():使用默认时区和语言环境获得一个日历对象

import java.util.Calendar;

public class Demo06CalendarInit {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
    }
}

• 根据Calendar类的API文档，常用的方法有：
• public abstract void add(int field,int amount):根据日历的规则，为给定日历字段添加或减去指定的时间量。
• public void set(int field,int value):将给定的日历字段设置为给定值。
• public int get(int field):返回给定日历字段的值。
• public Date getTime():返回一个表示此Calendar时间值（从历元到现在的毫秒偏移量）的Date对象。

字段值	含义
YEAR	年
MONTH	月（从0开始，可以+1使用）
DAY_OF_MONTH	月中的天（几号）
HOUR	时（12小时制）
HOUR_OF_DAY	时（24小时制）
MINUTE	分
SECOND	秒
DAY_OF_WEEK	周中的天（周几，周日为1，可以-1使用）

•  get/set方法

import java.util.Calendar;
/*
    get方法用来获取指定字段的值，set方法用来设置指定字段的值，代码使用演示：
 */
public class CalendarUtil {
    public static void main(String[] args) {
        //创建Calendar对象
        Calendar cal=Calendar.getInstance();

        //设置年
        int year=cal.get(Calendar.YEAR);
        //设置月
        int month=cal.get(Calendar.MONTH)+1;
        //设置日
        int dayofMonth=cal.get(Calendar.DAY_OF_MONTH);
        System.out.println(year+"年"+month+"月"+dayofMonth+"日");//2018年7月29日
    }
}

import java.util.Calendar;

public class Demo07CalendarMethod {
    public static void main(String[] args) {
        Calendar cal=Calendar.getInstance();
        cal.set(Calendar.YEAR,2020);

        System.out.print(cal.get(Calendar.YEAR)+"年"+(cal.get(Calendar.MONTH)+1)+"月"+cal.get(Calendar.DAY_OF_MONTH)+"日");//2020年7月29日
    }
}

•  add方法：add方法可以对指定日历字段的值进行加减操作，如果第二个参数为正数则加上偏移量，如果为负数则减去偏移量。

import java.util.Calendar;

public class Demo07CalendarMethod {
    public static void main(String[] args) {
        Calendar cal=Calendar.getInstance();
        cal.set(Calendar.YEAR,2020);
        //设置年
        int year=cal.get(Calendar.YEAR);
        //设置月
        int month=cal.get(Calendar.MONTH)+1;
        //设置日
        int dayofMonth=cal.get(Calendar.DAY_OF_MONTH);

        System.out.print(year+"年"+month+"月"+dayofMonth+"日");//2020年7月29日
    }
}

• getTime方法
• Calendar中的getTime方法并不是获取毫秒时刻，而是拿到对应的Date对象。
• 西方星期开始为周日，中国为周一。在Calendar类中，月份表示是以0-11代表1-12月。日期是有大小关系的，时间靠后，时间越大。

import java.util.Calendar;
import java.util.Date;

public class Demo09CalendarMethod {
    public static void main(String[] args) {
        Calendar cal=Calendar.getInstance();
        Date date=cal.getTime();
        System.out.println(date);//Sun Jul 29 21:17:52 CST 2018
    }
}

 总结：

• Calendar类概述：是一个 日历类，通过日历类可以获取日期和时间信息；是一个抽象类，不能直接创建该类的对象，只能使用子类。
• 如何获得日历类对象：通过调用Calendar类的静态方法获得日历对象该方法申明如下：static Calendar getInstance()
• Calendar类常用方法：

1. int get(int field):根据日历字段获得对应的值。常见的日历字段：年月日时分秒
2. void set(int field,int value):修改指定日历字段的值为value
3. void add（int field，int value）：将指定日历字段的值在此基础上偏移一个值value（value：正数，向后偏移；value：负数，向前偏移）
4. long getTimeInMillis():获取当前时间的毫秒值
5. Date getTime():获取日期对象
6. void set(int year,int month,int date):修改年月日

• Date和Calendar如何选择

1. Date是不支持国际化的
2. Calendar是支持国际化的
3. 如果项目需要支持国际化，则选择Calendar，否则随便选择。

•  示例代码

import java.util.Calendar;
import java.util.Date;

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

        //获取日期对象
        Date date=c.getTime();
        System.out.println(date.getTime());//获取当前毫秒值：1532871690196

        //修改年月日
        c.set(2000,10,30);

        //修改年份
        c.set(Calendar.YEAR,2000);
        c.set(Calendar.MONTH,12);
        c.set(Calendar.DATE,32);

        //将 指定日历字段的值在当前的基础上偏移一个value
        c.add(Calendar.YEAR,-1);

        //获得年
        int year=c.get(Calendar.YEAR);
        //获得月
        int month=c.get(Calendar.MONTH)+1;
        //获得日
        int day=c.get(Calendar.DATE);

        //获得时分秒
        int hour=c.get(Calendar.HOUR);
        int minute=c.get(Calendar.MINUTE);
        int second=c.get(Calendar.SECOND);

        System.out.println(year);
        System.out.println(month);
        System.out.println(day);
        System.out.println(hour);
        System.out.println(minute);
        System.out.println(second);


    }
}

•  示例代码

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/*
    计算出生到现在活了多少天：使用Date和SimpleDateFormat实现
 */
public class CalendarDemo01 {
    public static void main(String[] args) throws ParseException {
        //出生日期
        String birthDayStr="1996-07-07";

        //创建日期格式化对象
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");

        //将字符串转换成日期对象
        Date birthDayDate=sdf.parse(birthDayStr);

        //获得出生时间的毫秒值
        long birthDayTime=birthDayDate.getTime();

        //获取当前时间日期对象
        Date todayDate=new Date();

        //获取当前时间的毫秒值
        long todayTime=todayDate.getTime();

        //两个毫秒值相减
        long distance=todayTime-birthDayTime;
        System.out.println(distance/1000/3600/24);//8057天
    }
}

import java.util.Calendar;

/*
    计算出生到现在活了多少天，使用Calendar实现
 */
public class CalendarDemo02 {
    public static void main(String[] args) {
        //获得日历对象
        Calendar c=Calendar.getInstance();

        //获得当前的毫秒值
        long todayTime=c.getTimeInMillis();

        //修饰年月日为出生日期
        c.set(1996,7,7);
        //获得出生时的毫秒值
        long birthDayTime=c.getTimeInMillis();
        //两个毫秒值相减
        long distance=todayTime-birthDayTime;
        System.out.println(distance/1000/3600/24);
    }
}

3.1 System类

• java.lang.System 类提供了大量的静态方法，可以获取与系统相关的信息或系统级操作，在System类的API文档中，常用的方法有：

1. public static long currentTimeMillis():返回以毫秒为单位的当前时间。
2. public static void arraycopy(object src,int srcPos,object dest,int destPos,int length):将数组中的指定的数据拷贝到另一个数组中。
3. public static void gc():通过垃圾回收器回收垃圾（没有引用指向的对象）
4. public static void exit(int status):退出JVM，终止程序运行。
5. public static Propertiess getProperties():获取当前操作系统的所有属性：包括操作系统名。

public class SystemDemo {
    public static void main(String[] args) {
        //获取当前时间的毫秒值
        System.out.println(System.currentTimeMillis());//1532876589162
    }
}

/*
    验证for循环打印数字1-9999所需要使用的时间（毫秒）
 */
public class SystemDemo02 {
    public static void main(String[] args) {
        long start=System.currentTimeMillis();

        for (int i = 0; i <10000; i++) {
            System.out.println(i);
        }

        long end=System.currentTimeMillis();
        System.out.println("共耗时毫秒："+(end-start));//共耗时毫秒：219
    }
}

3.2 arraycopy方法

• public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) ：将 数组中指定的数据拷贝到另一个数组中。
• 数组的拷贝动作 是系统级的，性能很高。System.arraycopy方法具有5个参数，含义如下：

参数序列	参数名称	参数类型	参数含义
1	src	Object	源数组
2	srcPos	int	源数组索引起始位置
3	dest	Object	目标数组
4	destPos	int	目标数组索引起始位置
5	length	int	复制元素个数

/*
    将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 Demo11SystemArrayCopy {
    public static void main(String[] args) {
        int [] src={1,2,3,4,5};
        int [] dest={6,7,8,9,10};

       System.arraycopy(src,0,dest,0,3);
    }
}

• 贴士：finalize()是Object类的方法，该方法是由JVM自动调用的，当该对象被垃圾回收器回收时，JVM会自动 调用该对象的方法，可以在该方法中执行清理资源的相关操作。但JVM并不能保证对象在回收时一定会执行 到该方法。  

/*
    public static void gc() ：通知垃圾回收器收回垃圾对象(没有引用指向的对象)
 */
public class SystemDemo03 {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            //创建Person对象
            Person p=new Person();
            System.gc();
        }
    }
}
class Person{
    @Override
    protected  void finalize() throws Throwable{
        System.out.println("被回收了吗");
    }

/*
    public static void exit(int status) ：退出JVM，终止程序运行。
 */
public class SystemDemo04 {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            if(i == 5){
                System.exit(0);
            }
            System.out.println("i="+i);
        }
    }
}

/*
输出结果
i=0
i=1
i=2
i=3
i=4
*/

• 总结：

1. public static long currentTimeMillis()：获得当前时间的毫秒值。
2. public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) ：数组复制

• src：源数组
• srcPos：源数组的起始索引
• dest：目标数组
• destPos：目标数组的起始索引
• length：要拷贝的元素个数

   3.public static void gc() ==> garbage collect 垃圾回收器 

• 通知垃圾回收器回收垃圾对象。 
• 对象没有任何引用变量指向时就会变成垃圾对象。 
• public static void exit(int status) ：退出JVM，终止程序运行 

1. status：退出状态 
2.   0：正常退出 
3.   ‐1：异常退出 

• public static Properties getProperties() ： 获得操作系统的属性信息，比如操作系统名称

package Test13;

import Test02.Student;

import java.util.Arrays;
import java.util.Properties;

public class SystemDemo01 {
    public static void main(String[] args) {
        test01();
        test02();
        test03();
        test04();
    }
    /*
       public static void arraycopy(Object src, int srcPos,
        Object dest, int destPos, int length)
        数组复制
        src：源数组
        srcPos：源数组的起始索引
        dest：目标数组
        destPos：目标数组的起始索引
        length：要拷贝的元素个数
     */
    public static void test01(){
        // 定义一个整型数组：源数组
        int [] src={1,2,3,4,5,6,7};
        //定义一个整型数组：目标数组
        int [] desc=new int[7];
        // 数组拷贝
        System.arraycopy(src,1,desc,2,5);
        System.out.println(Arrays.toString(desc));
    }

    /*
      public static void exit(int status)
      退出JVM，终止程序运行
     */
    public static void test02(){
        for (int i = 0; i < 10; i++) {
            if(i == 5){
                System.exit(0);
            }
            System.out.println("i="+i);
        }
    }

    /*
         public static void gc() ==> garbage collect 
          垃圾回收器
         通知垃圾回收器回收垃圾对象。         
          对象没有任何引用变量指向时就会变成垃圾对象。
     */ 
    private static void test03(){
        for (int i = 0; i < 10; i++) {
            //创建学生对象
            new Student();
            //通知垃圾回收器回收垃圾对象
            System.gc();
        }
    }
    /*
         public static Properties getProperties()
         获得操作系统的属性信息，比如操作系统名称
     */
    private static void test04(){
        Properties info=System.getProperties();
        //获取操作系统的名字
        System.out.println(info.getProperty("os.name"));
    }


}

 4.1 StringBuilder类

• 字符串拼接问题：由于String类的对象内容不可改变，所以每当进行字符串拼接时，总是会在内存中创建一个新的对象。

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

•  StringBuilder概述 ：查阅 java.lang.StringBuilder 的API，StringBuilder又称为可变字符序列，它是一个类似于 String 的字符串缓冲 区，通过某些方法调用可以改变该序列的长度和内容。原来StringBuffer是个字符串的缓冲区，即就是它是一个容器，容器中可以装很多字符串。并且能够对其中的字符 串进行各种操作。
  它的内部拥有一个数组用来存放字符串内容，进行字符串拼接时，直接在数组中加入新内容。StringBuilder会自动 维护数组的扩容。原理如下图所示：(默认16字符空间，超过自动扩充)
• 构造方法：根据StringBuilder的API文档，常用构造方法有2个：
•  public StringBuilder() ：构造一个空的StringBuilder容器。 
• public StringBuilder(String str) ：构造一个StringBuilder容器，并将字符串添加进去。

public class StringBuilderDemo {
    public static void main(String[] args) {
        StringBuilder sb1=new StringBuilder();
        System.out.println(sb1);

        //使用带参构造
        StringBuilder sb2=new StringBuilder("HelloWorld");
        System.out.println(sb2);
    }
}

• StringBuilder常用的方法有2个：
• public StringBuilder append(...) ：添加任意类型数据的字符串形式，并返回当前对象自身。 
• public String toString() ：将当前StringBuilder对象转换为String对象。 
• append方法具有多种重载形式，可以接收任意类型的参数。任何数据作为参数都会将对应的字符串内容添加到 StringBuilder中。例如： 

public class Demo02StringBuilder {
    public static void main(String[] args) {
        //创建对象
        StringBuilder builder=new StringBuilder();
        //public StringBuilder append(任意类型)
        StringBuilder builder2=builder.append("hello");

        //对比一下
        System.out.println("builder:"+builder);
        System.out.println("builder2:"+builder2);
        System.out.println(builder == builder2);

        builder.append("hello");
        builder.append("world");
        builder.append(true);
        builder.append(100);

        //在我们开发中，会遇到调用一个方法后，返回一个对象的情况。然后使用返回的对象继续调用方法。
        //这种时候，我们就可以把代码现在一起，如append方法一样，代码如下
        //链式编程
        builder.append("hello").append("world").append(true).append(100);
        System.out.println("builder:"+builder);
    }
}

/*
    通过toString方法，StringBuilder对象将会转换为不可变的String对象。如：
 */
public class Demo16StringBuilder {
    public static void main(String[] args) {
        //链式创建
        StringBuilder sb=new StringBuilder("hello").append("world").append("java");
        //调用方法
        String str=sb.toString();
        System.out.println(str);//helloworldjava
    }
}

5.1 包装类

• 一个可以将基本数据类型封装成对象的类则称为包装类。