Object
Object类的toString方法
toString方法默认打印的就是对象的地址值没有意义,我们就要重写toString方法,可以自动生成:
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
equals方法
Person类默认继承了Object类,所以可以使用Object类的equals方法
boolean equals(Object obj) 指示其他某个对象是否与此对象“相等”。
equals方法源码:
public boolean equals(Object obj) {
return (this == obj);
}
参数:
Object obj:可以传递任意的对象
== 比较运算符,返回的是一个布尔值 true false
基本数据类型:比较的是值
引用数据类型:比较的是两个对象的地址值
this是谁?那个对象调用的方法,方法中的this就是那个对象;p1调用的equals方法所以this就是p1
obj是谁?传递过来的参数p2
this==obj -->p1==p2
重写Object类的equals方法
Object类的equals方法,默认比较的是两个对象的地址值,没有意义
所以我们要重写equals方法,比较两个对象的属性(name,age)
问题:
隐含着一个多态
多态的弊端:无法使用子类特有的内容(属性和方法)
Object obj = p2 = new Person(“古力娜扎”,19);
解决:可以使用向下转型(强转)把obj类型转换为Person
运用快捷方法重写equals方法
@Override
public boolean equals(Object o) {
if (this == o) return true;
//getClass() != o.getClass() 使用反射技术,判断o是否是Person类型 等效于 obj instanceof Person
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age &&
Objects.equals(name, person.name);
}
Objects类的equals方法
Objects类的equals方法:对两个对象进行比较,防止空指针异常
public static boolean equals(Object a, Object b) {
return (a == b) || (a != null && a.equals(b));
}
Object类&Objects类的总结
Object类
是所有类的父类。
toString()方法
作用:
打印对象的信息
重写前:打印的是包名类名@地址值
重写后:打印的是对象中的属性值
String 已经重写了toString
重写就用快捷键重写
equals()方法
作用:
比较两个对象的
重写前:比较的是对象的地址值
重写后:比较的是对象中的属性值
重写就用快捷键
Objects类
equals()方法
比较两个对象是否相同,但是加了一些健壮性的判断! 例如空指针时的情况。
Date
java.util.Date:表示日期和时间的类
类 Date 表示特定的瞬间,精确到毫秒。
毫秒:千分之一秒 1000毫秒=1秒
特定的瞬间:一个时间点,一刹那时间
毫秒值的作用:可以对时间和日期进行计算
2099-01-03 到 2088-01-01 中间一共有多少天
可以日期转换为毫秒进行计算,计算完毕,在把毫秒转换为日期
把日期转换为毫秒:
当前的日期:2088-01-01
时间原点(0毫秒):1970 年 1 月 1 日 00:00:00(英国格林威治)
就是计算当前日期到时间原点之间一共经历了多少毫秒 (3742767540068L)
注意:
中国属于东八区,会把时间增加8个小时
1970 年 1 月 1 日 08:00:00
把毫秒转换为日期:
1 天 = 24 × 60 × 60 = 86400 秒 = 86400 x 1000 = 86400000毫秒
public class Demo01Date {
public static void main(String[] args) {
System.out.println(System.currentTimeMillis());//获取当前系统时间到1970 年 1 月 1 日 00:00:00经历了多少毫秒
}
}
Date类的构造方法和成员方法
Date类的空参数构造方法
Date() 获取当前系统的日期和时间
private static void demo01() {
Date date = new Date();
System.out.println(date);
}
}
Date类的带参数构造方法
Date(long date) :传递毫秒值,把毫秒值转换为Date日期
private static void demo02() {
Date date = new Date(0L);
System.out.println(date);// Thu Jan 01 08:00:00 CST 1970
date = new Date(3742767540068L);
System.out.println(date);// Sun Aug 08 09:39:00 CST 2088
}
Date类的成员方法
long getTime() 把日期转换为毫秒值(相当于System.currentTimeMillis()方法)
返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
private static void demo03() {
Date date = new Date();
long time = date.getTime();
System.out.println(time);//3742777636267
}
DateFormat类&SimpleDateFormat类的介绍
java.text.DateFormat:是日期/时间格式化子类的抽象类
作用:
格式化(也就是日期 -> 文本)、解析(文本-> 日期)
成员方法:
String format(Date date) 按照指定的模式,把Date日期,格式化为符合模式的字符串
Date parse(String source) 把符合模式的字符串,解析为Date日期
DateFormat类是一个抽象类,无法直接创建对象使用,可以使用DateFormat类的子类
java.text.SimpleDateFormat extends DateFormat
构造方法:
SimpleDateFormat(String pattern)
用给定的模式和默认语言环境的日期格式符号构造 SimpleDateFormat。
参数:
String pattern:传递指定的模式
模式:区分大小写的
y 年
M 月
d 日
H 时
m 分
s 秒
写对应的模式,会把模式替换为对应的日期和时间
"yyyy-MM-dd HH:mm:ss"
注意:
模式中的字母不能更改,连接模式的符号可以改变
"yyyy年MM月dd日 HH时mm分ss秒"
DateFormat类的方法 format和parse
使用DateFormat类中的方法format,把日期格式化为文本
使用步骤:
1.创建SimpleDateFormat对象,构造方法中传递指定的模式
2.调用SimpleDateFormat对象中的方法format,按照构造方法中指定的模式,把Date日期格式化为符合模式的字符串(文本)
private static void demo01() {
//1.创建SimpleDateFormat对象,构造方法中传递指定的模式
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
//2.调用SimpleDateFormat对象中的方法format,按照构造方法中指定的模式,把Date日期格式化为符合模式的字符串(文本)
//String format(Date date) 按照指定的模式,把Date日期,格式化为符合模式的字符串
Date date = new Date();
String d = sdf.format(date);
System.out.println(date);//Sun Aug 08 15:51:54 CST 2088
System.out.println(d);//2088年08月08日 15时51分54秒
}
}
使用DateFormat类中的方法parse,把文本解析为日期
使用步骤:
1.创建SimpleDateFormat对象,构造方法中传递指定的模式
2.调用SimpleDateFormat对象中的方法parse,把符合构造方法中模式的字符串,解析为Date日期
注意:
public Date parse(String source) throws ParseException
parse方法声明了一个异常叫ParseException
如果字符串和构造方法的模式不一样,那么程序就会抛出此异常
调用一个抛出了异常的方法,就必须的处理这个异常,要么throws继续抛出这个异常,要么try catch自己处理
private static void demo02() throws ParseException {
//1.创建SimpleDateFormat对象,构造方法中传递指定的模式
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
//2.调用SimpleDateFormat对象中的方法parse,把符合构造方法中模式的字符串,解析为Date日期
//Date parse(String source) 把符合模式的字符串,解析为Date日期
Date date = sdf.parse("2088年08月08日 15时51分54秒");
System.out.println(date);
}
练习
练习:
请使用日期时间相关的API,计算出一个人已经出生了多少天。
分析:
1.使用Scanner类中的方法next,获取出生日期
2.使用DateFormat类中的方法parse,把字符串的出生日期,解析为Date格式的出生日期
3.把Date格式的出生日期转换为毫秒值
4.获取当前的日期,转换为毫秒值
5.使用当前日期的毫秒值-出生日期的毫秒值
6.把毫秒差值转换为天(s/1000/60/60/24)
public class Demo02Test {
public static void main(String[] args) throws ParseException {
//1.使用Scanner类中的方法next,获取出生日期
Scanner sc = new Scanner(System.in);
System.out.println("请输入您的出生日期,格式:yyyy-MM-dd");
String birthdayDateString = sc.next();
//2.使用DateFormat类中的方法parse,把字符串的出生日期,解析为Date格式的出生日期
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Date birthdayDate = sdf.parse(birthdayDateString);
//3.把Date格式的出生日期转换为毫秒值
long birthdayDateTime = birthdayDate.getTime();
//4.获取当前的日期,转换为毫秒值
long todayTime = new Date().getTime();
//5.使用当前日期的毫秒值-出生日期的毫秒值
long time = todayTime-birthdayDateTime;
//6.把毫秒差值转换为天(s/1000/60/60/24)
System.out.println(time/1000/60/60/24);
}
}
Calendar类 日历类
java.util.Calendar类:日历类
Calendar类是一个抽象类,里边提供了很多操作日历字段的方法(YEAR、MONTH、DAY_OF_MONTH、HOUR )
Calendar类无法直接创建对象使用,里边有一个静态方法叫getInstance(),该方法返回了Calendar类的子类对象
static Calendar getInstance() 使用默认时区和语言环境获得一个日历。
public class Demo01Calendar {
public static void main(String[] args) {
Calendar c = Calendar.getInstance();//多态
System.out.println(c);
}
}
Calendar类常用的成员方法
Calendar类的常用成员方法:
public int get(int field):返回给定日历字段的值。
public void set(int field, int value):将给定的日历字段设置为给定值。
public abstract void add(int field, int amount):根据日历的规则,为给定的日历字段添加或减去指定的时间量。
public Date getTime():返回一个表示此Calendar时间值(从历元到现在的毫秒偏移量)的Date对象。
成员方法的参数:
int field:日历类的字段,可以使用Calendar类的静态成员变量获取
public static final int YEAR = 1; 年
public static final int MONTH = 2; 月
public static final int DATE = 5; 月中的某一天
public static final int DAY_OF_MONTH = 5;月中的某一天
public static final int HOUR = 10; 时
public static final int MINUTE = 12; 分
public static final int SECOND = 13; 秒
public int get(int field):返回给定日历字段的值。
参数:传递指定的日历字段(YEAR,MONTH…)
返回值:日历字段代表的具体的值
private static void demo01() {
//使用getInstance方法获取Calendar对象
Calendar c = Calendar.getInstance();
int year = c.get(Calendar.YEAR);
System.out.println(year);
int month = c.get(Calendar.MONTH);
System.out.println(month);//西方的月份0-11 东方:1-12
//int date = c.get(Calendar.DAY_OF_MONTH);
int date = c.get(Calendar.DATE);
System.out.println(date);
}
}
public void set(int field, int value):将给定的日历字段设置为给定值。
参数:
int field:传递指定的日历字段(YEAR,MONTH…)
int value:给指定字段设置的值
private static void demo02() {
//使用getInstance方法获取Calendar对象
Calendar c = Calendar.getInstance();
//设置年为9999
c.set(Calendar.YEAR,9999);
//设置月为9月
c.set(Calendar.MONTH,9);
//设置日9日
c.set(Calendar.DATE,9);
//同时设置年月日,可以使用set的重载方法
c.set(8888,8,8);
int year = c.get(Calendar.YEAR);
System.out.println(year);
int month = c.get(Calendar.MONTH);
System.out.println(month);//西方的月份0-11 东方:1-12
int date = c.get(Calendar.DATE);
System.out.println(date);
}
public abstract void add(int field, int amount):根据日历的规则,为给定的日历字段添加或减去指定的时间量。
把指定的字段增加/减少指定的值
参数:
int field:传递指定的日历字段(YEAR,MONTH…)
int amount:增加/减少指定的值
正数:增加
负数:减少
private static void demo03() {
//使用getInstance方法获取Calendar对象
Calendar c = Calendar.getInstance();
//把年增加2年
c.add(Calendar.YEAR,2);
//把月份减少3个月
c.add(Calendar.MONTH,-3);
int year = c.get(Calendar.YEAR);
System.out.println(year);
int month = c.get(Calendar.MONTH);
System.out.println(month);//西方的月份0-11 东方:1-12
//int date = c.get(Calendar.DAY_OF_MONTH);
int date = c.get(Calendar.DATE);
System.out.println(date);
}
public Date getTime():返回一个表示此Calendar时间值(从历元到现在的毫秒偏移量)的Date对象。
把日历对象,转换为日期对象
private static void demo04() {
//使用getInstance方法获取Calendar对象
Calendar c = Calendar.getInstance();
Date date = c.getTime();
System.out.println(date);
}
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 long currentTimeMillis():返回以毫秒为单位的当前时间。
用来程序的效率
验证for循环打印数字1-9999所需要使用的时间(毫秒)
private static void demo01() {
//程序执行前,获取一次毫秒值
long s = System.currentTimeMillis();
//执行for循环
for (int i = 1; i <=9999 ; i++) {
System.out.println(i);
}
//程序执行后,获取一次毫秒值
long e = System.currentTimeMillis();
System.out.println("程序共耗时:"+(e-s)+"毫秒");//程序共耗时:57毫秒
}
}
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length):将数组中指定的数据拷贝到另一个数组中。
参数:
src - 源数组。
srcPos - 源数组中的起始位置(起始索引)。
dest - 目标数组。
destPos - 目标数据中的起始位置。
length - 要复制的数组元素的数量。
练习:
将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]
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把源数组的前3个元素复制到目标数组的前3个位置上
System.arraycopy(src,0,dest,0,3);
System.out.println("复制后:"+ Arrays.toString(dest));
}
StringBuilder类
StringBuilder类的构造方法
java.lang.StringBuilder类:字符串缓冲区,可以提高字符串的效率
构造方法:
StringBuilder() 构造一个不带任何字符的字符串生成器,其初始容量为 16 个字符。
StringBuilder(String str) 构造一个字符串生成器,并初始化为指定的字符串内容。
public class Demo01StringBuilder {
public static void main(String[] args) {
//空参数构造方法
StringBuilder bu1 = new StringBuilder();
System.out.println("bu1:"+bu1);//bu1:""
//带字符串的构造方法
StringBuilder bu2 = new StringBuilder("abc");
System.out.println("bu2:"+bu2);//bu2:abc
}
}
append方法
StringBuilder的常用方法:
public StringBuilder append(…):添加任意类型数据的字符串形式,并返回当前对象自身。
public class Demo02StringBuilder {
public static void main(String[] args) {
//创建StringBuilder对象
StringBuilder bu = new StringBuilder();
//使用append方法往StringBuilder中添加数据
//append方法返回的是this,调用方法的对象bu,this==bu
//StringBuilder bu2 = bu.append("abc");//把bu的地址赋值给了bu2
//System.out.println(bu);//"abc"
//System.out.println(bu2);//"abc"
//System.out.println(bu==bu2);//比较的是地址 true
//使用append方法无需接收返回值
// bu.append("abc");
// bu.append(1);
// bu.append(true);
// bu.append(8.8);
// bu.append('中');
// System.out.println(bu);//abc1true8.8中
/*
链式编程:方法返回值是一个对象,可以继续调用方法,这里返回的就是bu
*/
System.out.println("abc".toUpperCase().toLowerCase().toUpperCase().toLowerCase());
bu.append("abc").append(1).append(true).append(8.8).append('中');
System.out.println(bu);//abc1true8.8中
}
}
toString方法
StringBuilder和String可以相互转换:
String->StringBuilder:可以使用StringBuilder的构造方法
StringBuilder(String str) 构造一个字符串生成器,并初始化为指定的字符串内容。
StringBuilder->String:可以使用StringBuilder中的toString方法
public String toString():将当前StringBuilder对象转换为String对象。
public class Demo03StringBuilder {
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);
}
}
System类和StringBuilder类的总结
System类
currentTimeMillis()方法
作用:获取当前系统毫秒值时间
//获取当前系统毫秒时间
long time =System.currentTimeMillis();
sout(time);
arraycopy()方法
作用:复制数组
参数:
src - 源数组。
srcPos - 源数组中的起始位置(起始索引)。
dest - 目标数组。
destPos - 目标数据中的起始位置。
length - 要复制的数组元素的数量。
StringBuilder类
1.构造方法
StringBuilder(); 创建一个空的字符串缓冲区对象
StringBuilder(String s); 根据传入的内容创建一个字符串缓冲区对象
2.成员方法
StringBuilder append(Object obj)添加内容
StringBuilder sb=new StringBuilder();
sb.qppend("java").append("nice").append("easy");
StringBuilder reverse(); 反转内容
每一个字母都反转顺序入上面程序应该的结果应该是:yseaecinavaj;
String toString(); 将缓冲区的内容转为字符串
包装类
概述
装箱和拆箱
装箱:把基本类型的数据,包装到包装类中(基本类型的数据->包装类)
构造方法:
Integer(int value) 构造一个新分配的 Integer 对象,它表示指定的 int 值。
Integer(String s) 构造一个新分配的 Integer 对象,它表示 String 参数所指示的 int 值。
传递的字符串,必须是基本类型的字符串,否则会抛出异常 “100” 正确 “a” 抛异常
//装箱:把基本类型的数据,包装到包装类中(基本类型的数据->包装类)
//构造方法
Integer in1 = new Integer(1);//方法上有横线,说明方法过时了
System.out.println(in1);//1 重写了toString方法
Integer in2 = new Integer("1");
System.out.println(in2);//1
静态方法:
static Integer valueOf(int i) 返回一个表示指定的 int 值的 Integer 实例。
static Integer valueOf(String s) 返回保存指定的 String 的值的 Integer 对象。
//静态方法
Integer in3 = Integer.valueOf(1);
System.out.println(in3);
//Integer in4 = Integer.valueOf("a");//NumberFormatException数字格式化异常
Integer in4 = Integer.valueOf("1");
System.out.println(in4);
拆箱:在包装类中取出基本类型的数据(包装类->基本类型的数据)
成员方法:
int intValue() 以 int 类型返回该 Integer 的值。
//拆箱:在包装类中取出基本类型的数据(包装类->基本类型的数据)
int i = in1.intValue();
System.out.println(i);
自动装箱与自动拆箱
自动装箱与自动拆箱:基本类型的数据和包装类之间可以自动的相互转换
自动装箱:直接把int类型的整数赋值包装类
/*
Integer in = 1; 就相当于 Integer in = new Integer(1);
*/
Integer in = 1;
自动拆箱:in是包装类,无法直接参与运算,可以自动转换为基本数据类型,在进行计算
/*
in+2;就相当于 in.intVale() + 2 = 3
in = in.intVale() + 2 = 3 又是一个自动装箱
*/
in = in+2;
例子:
ArrayList<Integer> list = new ArrayList<>();
/*
ArrayList集合无法直接存储整数,可以存储Integer包装类
*/
list.add(1); //-->自动装箱 list.add(new Integer(1));
int a = list.get(0); //-->自动拆箱 list.get(0).intValue();
基本类型和字符串类型之间的相互转换
基本类型->字符串(String)
1.基本类型的值+"" 最简单的方法(工作中常用)
2.包装类的静态方法toString(参数),不是Object类的toString() 重载
static String toString(int i) 返回一个表示指定整数的 String 对象。
3.String类的静态方法valueOf(参数)
static String valueOf(int i) 返回 int 参数的字符串表示形式。
//基本类型->字符串(String)
int i1 = 100;
String s1 = i1+"";
System.out.println(s1+200);//100200
String s2 = Integer.toString(100);
System.out.println(s2+200);//100200
String s3 = String.valueOf(100);
System.out.println(s3+200);//100200
字符串(String)->基本类型
使用包装类的静态方法parseXXX(“字符串”);
Integer类: static int parseInt(String s)
Double类: static double parseDouble(String s)
//字符串(String)->基本类型
int i = Integer.parseInt(s1);
System.out.println(i-10);
int a = Integer.parseInt("a");//NumberFormatException
System.out.println(a);
包装类总结
1.基本数据类型对应的包装类
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
2.数字转为字符串
int num =50;
String s=num+"";
3.字符串转为数字
4.自动拆装箱