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)
- 用来比较两个对象是否相同,相同则返回true,否则false
- 默认是通过比较两个对象的地址值判断两个对象是否相同
重写equals方法的目的:
- 在比较两个对象是否相同时不希望通过比较地址值判断,因为比较地址值没有任何意义。而是希望通过比较两个对象的成员变量值来判断两个对象是否相同。
- 示例代码
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方法的调用时机
- 直接调用:通过对象名调用
- 直接打印对象到控制台,系统会自动调用该对象的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)
- 比较对象a和对象b是否相同,相同则返回true,否则false
- 底层依赖于对象的equals方法,如果对象没有重写equals方法则是通过比较地址判断
- public static Object requireNonNull(Object obj)
- 判断对象是否不为null,如果是则返回obj本身,否则抛出异常
- public static boolean nonNull(Object obj)
- 判断对象obj是否不为null,是返回true,否则返回false
- public static boolean isNull(Object obj)
- 判断对象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)以来的指定毫秒数。
- 由于我们处于东八区,所以我们的基准时间为1970年1月1日8时0分0秒。
- 简单来说,使用无参构造,可以自动设置当前系统时间的毫秒时刻;指定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类构造方法
- Date()获取当前系统时间日期对象
- Date(long date)根据指定的毫秒值创建日期对象
- Date类成员方法
- long getTime():获取当前时间的毫秒值
- 毫秒值概述
- 1秒==1000毫秒
- 时间零点
- 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。这个类需要一个模式(格式)来指定格式化或解析的标准。构造方法为:
- public simpleDateFormat(String pattern):用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat。参数pattern是一个字符串,代表日期时间的自定义格式。
标识字母(区分大小写) | 含义 |
y | 年 |
M | 月 |
d | 日 |
H | 时 |
m | 分 |
s | 秒 |
- 更详细的格式规则,可以参考SimpleDateFormat类的API文档。
总结:
- DateFormat类概述:是一个日期格式类,抽象类,不能直接创建该类的对象,只能创建子类对象。
- DateFormat类常用子类:SimpleDateFormat
- DateFormat类常见操作:
- 将日期对象转换为字符串:Date==>String
- 将日期字符串转换为日期对象:String==>Date
- SimpleDateFormat类的构造方法
- SimpleDateFormat():创建日期格式化对象,使用默认的日期模式
- SimpleDateFormat(String patte):指定日期模式创建日期格式化对象
- SimpleDateFormat类的常用方法
- String format(Date date):将日期对象格式化为字符串:Date == >String
- void applyPattern(String pattern):修改日期模式
- Date parse(String str):将日期转换为日期对象:String==>Date
日期模式
- yyyy 年
- MM 月
- dd 日
- HH 时 HH:24小时制 hh:12小时制
- mm 分
- ss 秒
- 日期转换字符串的步骤
- 创建日期对象
- 创建日期格式化对象并制定日期模式
- SimpleDateFormat sdf=new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
- 调用日期格式化对象format方法并将日期转换为字符串
- 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类常用方法:
- int get(int field):根据日历字段获得对应的值。常见的日历字段:年月日时分秒
- void set(int field,int value):修改指定日历字段的值为value
- void add(int field,int value):将指定日历字段的值在此基础上偏移一个值value(value:正数,向后偏移;value:负数,向前偏移)
- long getTimeInMillis():获取当前时间的毫秒值
- Date getTime():获取日期对象
- void set(int year,int month,int date):修改年月日
- Date和Calendar如何选择
- Date是不支持国际化的
- Calendar是支持国际化的
- 如果项目需要支持国际化,则选择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文档中,常用的方法有:
- public static long currentTimeMillis():返回以毫秒为单位的当前时间。
- public static void arraycopy(object src,int srcPos,object dest,int destPos,int length):将数组中的指定的数据拷贝到另一个数组中。
- public static void gc():通过垃圾回收器回收垃圾(没有引用指向的对象)
- public static void exit(int status):退出JVM,终止程序运行。
- 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
*/
- 总结:
- public static long currentTimeMillis():获得当前时间的毫秒值。
- 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,终止程序运行
- status:退出状态
- 0:正常退出
- ‐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 包装类
- 一个可以将基本数据类型封装成对象的类则称为包装类。