Object类：
java.lang.Object
类Object是类层次结构的根（父）类。
每个类（person,Student…)都使用Object作为超类（父类）。
所有类都能使用这个类中的方法
toString方法：
String s = per.toString
1.s存放的是对象在堆内存中的地址值
2.直接打印对象名称，其实就是调用了toString方法，打印地址值
3.可以自己在类里重写toString方法。这样就不会打印地址值了
4.判断一个类是否重写toString方法，就打印对象名，如果是地址值就没有重写。如果不是，就重写
import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;
public class Str {
public static void main(String[] args) {
Person per = new Person("张三", 30);
//Person类继承Object类，其可以使用Object类中的所有方法
String s = per.toString();//调用toString方法，返回地址值
System.out.println(s);//javalei.Object.String.Person@b4c966a//aaa//Person{name='张三', ages=30}
//直接打印对象名，就是调用对象的toString方法，返回地址值//aaa//Person{name='张三', ages=30}
System.out.println(per);
//看一个类是否重写toString方法，直接打印对象名，重写：不是地址值。没重写：打印地址值
Random r = new Random();
System.out.println(r);//java.util.Random@4e50df2e //没有重写toString方法
Scanner sc = new Scanner(System.in); //重写
System.out.println(sc); //java.util.Scanner[delimiters=\p{javaWhitespace}+][position=0][match valid=false]
// [need input=false][source closed=false][skipped=false][group separator=\x{2c}][decimal separator=\x{2e}]
// [positive prefix=][negative prefix=\Q-\E][positive suffix=][negative suffix=][NaN string=\QNaN\E][infinity string=\Q∞\E]
ArrayList<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
System.out.println(list); //[1, 2] //重写了toString方法。
}
}
public class Person {
private String name;
private int ages;
//下面两个是Person类重写toString方法
/*public String toString(){
return "aaaa";
}*/
/*@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", ages=" + ages +
'}';
}
*/
public Person() {
}
public Person(String name, int ages) {
this.name = name;
this.ages = ages;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAges() {
return ages;
}
public void setAges(int ages) {
this.ages = ages;
}
}
=======================================================
Object类中的equals方法
Person类默认继承了Object类，所以Person的对象可以使用Object类中的equals方法
boolean equals(Object obj)表示其他对象是否与此对象相等
equals方法源码：
public boolean equals（Object obj){
return (this==obj);
}
参数：Object obj：可以传递任何对象
==比较运算符，返回是一个布尔值 ture false
基本类型 ：比较的是值
引用类型 ：比较的是两个对象的地址值
this是谁？ 那个对象调用的方法，方法中的this就是哪个对象；p1调用的equals方法，所以thisjiuship1
obj是谁？ 传递过来的参数p2
this==obj --> p1==p2
public class Equ {
public static void main(String[] args) {
Person p1 = new Person("张三",30);
Person p2 = new Person("李四",28);
System.out.println(p1);//javalei.Object.equals.Person@b4c966a
System.out.println(p2);//javalei.Object.equals.Person@2f4d3709
boolean b=p1.equals(p2);
System.out.println(b);//false
p1=p2;
boolean c=p1.equals(p2);
System.out.println(c);//true
}
}
==============================================
重写equals方法
如果不重写，只会比较地址值。
可以重写让它比较属性（name，age）
问题：
隐含这一个多态
多态弊端：无法使用子类特有内容（属性和方法）
Object obj = p2 = new Person(“古力娜扎”,19);
解决：向下强转，把obj类型转化为Person类型
Person p = (Person)obj;
public class Person {
private String name;
private int age;
@Override//重写了equals方法
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age &&
Objects.equals(name, person.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public Person() {
}
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;
}
}
public class Equ {
public static void main(String[] args) {
Person p1 = new Person("张三",30);
Person p2 = new Person("李四",28);
System.out.println(p1);//javalei.Object.equals.Person@b4c966a
System.out.println(p2);//javalei.Object.equals.Person@2f4d3709
boolean b=p1.equals(p2);
System.out.println(b);//false
ArrayList<String> list = new ArrayList<>();
boolean c = p1.equals(list);//不同类型比较，属性必然不同
System.out.println(c);
}
}
也可以自己亲自写：
public boolean equals(Object obj){
//首先判断是不是本身
if(obj==this){
return true;
}
//是否为null
if(obj==null)
return false;
//强制转换
if(obj instanceof Person){
Person p=(Person)obj;
boolean b = this.name.equals(p.name)&&this.age==p.age;
return b;
}
return false;
}
=====================================
Objects类的equals方法
对两个对象进行比较，防止空指针异常
源码：
public static boolean equals(Object a,Object b){
return (a==b)||(a!=null&&a.equals(b));
}
import java.util.Objects;
public class Objs {
public static void main(String[] args) {
String a = "abc";
String b = null;
//boolean c = b.equals(a); //NullPointerException 空指针异常
boolean d = Objects.equals(a,b);
System.out.println(d);//false
}
=======================================================
Date类
java.util.Date:表示时间和日期的类
类Date 表示特定的时间，精确到毫秒（千分之一秒）
毫秒值作用：对时间和日期进行计算
2088-01-01到2099-01-01中间一共多少天
可以把日期转换为毫秒，再把毫秒转化为日期
把日期转化为毫秒：
时间原点（0毫秒）1970 - 1- 1- 00：00：00
把毫秒转换成日期：
1天=86400000毫秒
构造方法：
1.Date() :获取当前时间
2.Date(long) :传递毫秒值，把毫秒值转化成日期
成员方法：
1.Date date = new Date();
long l = date.getTime();
从零毫秒到现在日期的毫秒
public class Dat {
public static void main(String[] args) {
mod1();
mod2();
mod3();
}
//无参构造方法 Date（）：
public static void mod1(){
Date date = new Date();
System.out.println(date);//Mon Sep 21 21:37:18 CST 2020
//直接打印对象名，没有出来地址，说明重写了toString类
}
//有参构造方法 Date(long )：
public static void mod2(){
Date date = new Date(0L);
System.out.println(date);//Thu Jan 01 08:00:00 CST 1970
}
//成员方法 long getTime（） 把日期转换成毫秒值
//从0毫秒开始，到现在
public static void mod3(){
Date date = new Date();
long l = date.getTime();
System.out.println(l);//1600696036510
}
}
===========================================================
java.text.DateFormat:
日期/时间格式化子类的抽象类
作用：
格式化：（日期->文本）、解析：（文本->日期）
成员方法：
String format(Date date按照指定的模式，把Date日期格式化符合模式的字符串
Date parse(String source) 把符合模式的字符串，解析为Date日期
DateFormat是一个抽象类，无法直接创建对象使用，用DateForme的子类SimpleDateFormat
java.text.SimpleDateFormat extends DateFormat
构造方法：
SimpleDateFormat(String pattern)
参数传递指定模式：y 年
M 月
d 日
H 时
m 分
s 秒
yyyy-MM-dd HH:mm:ss
format方法：（把日期转化为文本）
1.创建SimpleDateFormat对象，构造方法中传递指定模式
2.调用SimpleDateFormat对象的方法format，按照指定的模式，把Date日期格式化符合模式的字符串
public class Demo {
public static void main(String[] args) throws ParseException {
demo1();
demo2();
}
public static void demo1(){
SimpleDateFormat sim = new SimpleDateFormat("yyyy年MM月dd日");
Date date = new Date();
String s = sim.format(date);
System.out.println(s);//2020年09月22日
}
public static void demo2() throws ParseException {
SimpleDateFormat sim = new SimpleDateFormat("yyyy年MM月dd日");
Date date= sim.parse("2020年9月21日");
System.out.println(date);//Mon Sep 21 00:00:00 CST 2020
}
}
============================================
计算从出生到现在天数出生
public class HowDay {
public static void main(String[] args) throws ParseException {
//用Scanner类中的next方法，写入出生日期
Scanner scanner = new Scanner(System.in);
System.out.println(("请输入出生日期:yyyy-MM-dd"));
String s = scanner.next();
//把字符串的出生日期转化为date类型的出生日期
SimpleDateFormat sim = new SimpleDateFormat("yyyy-MM-dd");
Date date = sim.parse(s);
//把date格式的出生日期转化为毫秒值
long ss = date.getTime();
//获取当前日期并且转化为毫秒
long sss = new Date().getTime();
//打印天数
System.out.println("天数为："+(sss-ss)/1000/60/60/24);
}
}
=
===============================================
类Calendar
java.util.Calendar :日历类
Calendar 类是一个抽象类，提供了很多操作日历字段的方法（ YEAR、MONTH、DAY_OF_MONTH、HOUR ）
并为操作日历字段（例如获得下星期的日期）提供了一些方法
Calendar类无法直接创建对象使用，里面有一个静态方法叫getInstance（），
该方法返回了Calendar类的子类对象
static Calendar getInstance()使用默认时区和语言环境获得一个日历
public class Demo {
public static void main(String[] args) {
Calendar c = Calendar.getInstance();//多态
System.out.println(c);//java.util.GregorianCalendar
// [time=1600774851398,areFieldsSet=true,areAllFieldsSet=true,
// lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",
// offset=28800000,dstSavings=0,useDaylight=false,transitions=31,
// lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2020,
// MONTH=8,WEEK_OF_YEAR=39,WEEK_OF_MONTH=4,DAY_OF_MONTH=22,DAY_OF_YEAR=266,DAY_OF_WEEK=3,
// DAY_OF_WEEK_IN_MONTH=4,AM_PM=1,HOUR=7,HOUR_OF_DAY=19,MINUTE=40,SECOND=51,MILLISECOND=398,
// ZONE_OFFSET=28800000,DST_OFFSET=0]
//打印的不是地址，说明这个类重写了toString类
}
}
====================================================
Calendar类的常用成员方法
public int get(int field):返回给定日历字段的值
public void set (int field,int value):将给定的日历字段设置为给定值
public obstract void add (int field,int omount):根据日历规则，为给定日历字段添加或减去指定时间量
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 static final int
int value :给指定字段设置的值
int omount :增加/减少指定的值
public class MAIN {
public static void main(String[] args) {
mode1(); //public int get(int field):返回给定日历字段的值
mode2(); //public void set (int field,int value):将给定的日历字段设置为给定值
mode3(); //public obstract void add (int field,int omount):根据日历规则，为给定日历字段添加
mode4(); //public Date getTime ():返回一个表示Calendar时间值的Date对象
}
private static void mode4() {
Calendar cal = Calendar.getInstance();
Date date = cal.getTime();
System.out.println(date);//Tue Sep 22 20:21:36 CST 2020
}
private static void mode3() {
Calendar cal = Calendar.getInstance();
cal.add(Calendar.YEAR,4);
cal.add(Calendar.MONDAY,-3);
int y = cal.get(Calendar.YEAR);
System.out.println(y);//2024
int m = cal.get(Calendar.MONDAY);
System.out.println(m);//5
}
private static void mode2() {
Calendar cal = Calendar.getInstance();
cal.set(Calendar.YEAR,9999);
cal.set(Calendar.MONDAY,9);
cal.set(Calendar.DATE,8);
int y = cal.get(Calendar.YEAR);
System.out.println(y);//9999
int m = cal.get(Calendar.MONDAY);
System.out.println(m);//9
}
private static void mode1() {
Calendar cal = Calendar.getInstance();
int y = cal.get(Calendar.YEAR);
System.out.println(y);//2020
int m = cal.get(Calendar.MONDAY);
System.out.println(m);//8
}
}
=====================================================
System类
java.lang.System 类中提供了大量静态方法，可以获取与系统相关的信息和系统操作
public static long currentTimeMillis();:返回以毫秒为单位的当前的时间
public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length);
//将数组中指定数据拷贝到另一个数组中
public static long currentTimeMillis()；用来测试程序的效率
public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length);
src - 源数组。
srcPos - 源数组中的起始位置。
dest - 目标数组。
destPos - 目标数据中的起始位置。
length - 要复制的数组元素的数量。
public class Sys {
public static void main(String[] args) {
mod1(); //用来测试程序的效率
mod2(); //将数组中指定数据拷贝到另一个数组中
}
private static void mod2(){
int [] list={
1,2,3,4,5};
int [] dest={
6,7,8,9,10};
System.out.println("list 复制前"+ Arrays.toString(list));
System.out.println("dest 复制前"+ Arrays.toString(dest));
System.arraycopy(list,0,dest,0,3);
System.out.println("list 复制后"+ Arrays.toString(list));
System.out.println("dest 复制后"+ Arrays.toString(dest));
}
private static void mod1() {
long s1=System.currentTimeMillis();
for(int i=0;i<1000;i++){
System.out.println(i);
}
long s2=System.currentTimeMillis();
System.out.println("耗时"+(s2-s1));
}
}
============================================================
StringBuilder类
字符串缓冲区
String类
字符串是常量：他们的值在创建后不能修改
字符串底层是一个被final修饰的数组，不能被改变的常量
private final byte[] value;
进行字符串的相加，内存中就会有多个字符串，占用空间多，效率低下
String = “a”+“b”+“c”=“abc”;
步骤："a" "b" "c" 三个字符串
"a"+"b" 一个字符串
"ab"+"c" "abc" 一个字符串
StringBuilder类
字符串缓冲区，可以提高字符串的操作效率（看成一个长度可以变化的字符串）
底层也是一个数组，但是没有被final修饰，可以改变长度
byte[] value = new byte[16];
初始内存16个
StringBuilder在内存中始终是一个数组，占用一个数组，效率高
如果超过了StringBuilder的容量，会自动的扩容
================================================================
StringBuilder的构造方法
构造方法：
==StringBuilder( )==构造一个不带任何字符串的字符串生成器，初始容量为16个字符。
StringBuilder(String str) 构造一个字符串生成器，并初始化为指定的字符串内容
public class Demo {
public static void main(String[] args) {
//空参数构造方法
StringBuilder bui = new StringBuilder();//就是"",空字符串。
System.out.println(bui);
//有参
StringBuilder bui1 = new StringBuilder("abc");
System.out.println(bui1);//abc
}
}
============================================================================
StringBuilder常用成员方法
public StringBuilder append(…):添加任意类型字符串形式，并返回当前对象本身
public class Oppend {
public static void main(String[] args) {
//创建对象
StringBuilder bui = new StringBuilder();
//使用append方法往StringBuilder中添加数据
//append方法返回的是this，调用方法的对象bui，this==bui；
StringBuilder bui1=bui.append("abc");//把bui的地址赋值给了bui1
System.out.println(bui);//"abc"
System.out.println(bui1);//"abc"
System.out.println(bui==bui1);//比较的是地址ture
//使用append方法无需接受返回值
}
}
================================
StringBuilder 与 String相互转化
STring->StringBuilder:使用构造方法
StringBuilder（String str）构造一个字符串生成器，并初始化为指定字符串内容
StringBuilder->String :可以使用StringBuilder中的toString方法
public class Change{
public static void main(String[] args) {
String str = "hello";
System.out.println("str:"+str);
//String->StringBuilder;
StringBuilder bui = new StringBuilder(str);
//往StringBuilder中添加数据
bui.append("world");
System.out.println("bui:"+bui);
//StringBuilder->String
String s= bui.toString();
System.out.println("s:"+s);
}
}