Tips:样式蚂蚁森林浇水get

java进阶——day01-1 Object类、常用API

Object类

概述

　　java.lang.Object类，是java语言中的根类，即所有类的父类。在对象实例化的过程，最终找到的父类是Object。

　　如果一个类，没有指定父类，那么默认继承Object类。

例如：

　　public class MyClass /*extends Object*/{

　　//****}

　　Object包含的十一个方法

toString方法　　

方法摘要

　　public String toString()：返回该对象的字符串表示。

　　public String toString()：返回该对象的字符串表示，其实返回的是对象的类型+@+内存地址值。

　　由于toString方法返回的结果是内存地址，但在开发中经常需要按照对象的属性，得到相应的字符串表现形式，因此有时候就需要重写toString()方法。

覆盖重写

　　如果不希望使用toString方法的默认行为，可以对它进行覆盖重写，例如：

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
Person类-重写toString
package day01;

public class demo {
    public static void main(String[] args) {
        Person person = new Person("张子枫",18);
        System.out.println(person);//未重写的toString 其返回的是一个地址值 day01.Person@452b3a41
        //重写toString后返回的结果 Person{name='张子枫', age=18}

    }
}
main

equals方法

方法摘要：

　　public boolean equals(Object obj)：指示其他某个对象是否与此对象"相等"

　　调用成员方法equals并指定参数为另一个对象，则可以判断这两个对象是否相同。

　　这里的"相等"有默认和自定义两种方式。

默认地址比较：

　　如果没有覆盖重写equals方法，那么Object类中默认进行 == 运算符的对象地址比较，只要不是同一个对象，结果返回false。

　　例如：

package day01;

public class Person {
    //成员变量
    private String name;
    private int age;

    //构造方法
    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    //重写toString

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

    //get & set
    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;
    }
}
Person类
package day01;

public class demo {
    public static void main(String[] args) {
        Person p1 = new Person("张子枫",18);
        Person p2 = new Person("赵丽颖",18);
        //调用 constratPerson()方法 判断
        contrastPerson(p1,p2);
        System.out.println("================================");
        //定义p3 = p1
        Person p3 = p1;
        //对比 p1 和 p3
        contrastPerson(p1,p3); //对比结果 为同一个人

        //利用== 运算符对比
        if(p1 == p2){
            System.out.println("true");
        }else {
            System.out.println("false"); //其返回false
        }
    }
    //定义判断的方法
    public static void contrastPerson(Person p1,Person p2){
        if(p1.equals(p2)){
            System.out.println("他们是同一个人哦");
        }else {
            System.out.println("怎么回事？他们不是同一个人啊！");
        }
    }
}
equals默认地址比较

对象内容比较：

　　如果希望进行对象内容的比较，即 所有或指定的部分成员变量相同就判定两个对象相同，则可以重写equals方法。

　　例如：

package day01;

import java.util.Objects;

public class Person {
    //成员变量
    private String name;
    private int age;

    //构造方法
    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //重写equals方法
    @Override
    public boolean equals(Object o) {
        //使用向下转型 把object类 转为person类
        Person person = (Person)o;
        //比较两个对象的 属性
        boolean  flag = this.name.equals(person.name)&&this.age == person.age;
        return flag;
    }


    //get & set
    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;
    }
}
重写equals方法 --Person
package day01;

public class demo01 {
    public static void main(String[] args) {
        Person p = new Person("周杰伦",30);
        Person p1 = new Person("陈冠希",26);
        Person p2 = new Person("陈冠希",26);
        //equals默认对比
        /*System.out.println("p"+p);  //返回的地址值为：pday01.Person@681a9515
        System.out.println("p1"+p1); //返回的地址值为：p1day01.Person@3af49f1c
        System.out.println(p.equals(p1));//equals默认判断地址值，因为地址值不一样 所以返回false*/

        //重写equals后对比
        System.out.println(p.equals(p1));//姓名和年龄不一样 就返回false

        System.out.println(p1.equals(p2)); //返回true 且不关乎地址值
        System.out.println("p1"+p1);//地址值：p1day01.Person@19469ea2
        System.out.println("p2"+p2);//地址值：p2day01.Person@13221655


    }
}
main

　　通过对比可以发现 重写equals后 不再以对象的地址值进行判断 而是根据成员属性来判断两个对象是否相等

　　注意：ide alt+insert有重写equals方法的快捷方式

日期时间类

Date类

　　1、概述

　　java.util.Date类 表示特定的瞬间，精确到毫秒(1000ms = 1s)

　　2.格式

　　Date 对象名 = new Date();

package day01.dateTest;

import java.util.Date;

public class demo01 {
    public static void main(String[] args) {
       Date date = new Date();
        System.out.println(date); //返回：Fri Mar 12 22:02:28 CST 2021
    }
}
Data

　　注意：在使用println方法时，会自动调用Date类中的toString方法。

常用方法

　　Date类中的多数方法已经过时，常用的方法：

　　getTime()

　　用途：将日期对象 转换为 对应的时间毫秒值

　　例如：

package day01.dateTest;

import java.util.Date;

public class demo01 {
    public static void main(String[] args) {
       Date date = new Date();
        System.out.println(date.getTime());//返回从1970年1月1日00:00:00 GMT至今 = 1615558162996
    }
}
getTime()

DateFormat类

　　1、概述

　　java.text.DateFormat是日期/时间格式化子类的抽象类。我们通过这个类可以帮助我们完成日期和文本的转换。

　　格式化：按照指定格式，将Date对象 转换为 String对象

　　解析：按照指定格式，从String对象 转换为 Date对象

　　2、常用方法

　　public String format(Date date); 　　//将Date格式化为字符串

　　public Date parse(String str);　　　  //将字符串转换为Date对象

　　3.SimpleDateFormat

　　DateFormat类是抽象类，不能直接使用，所以需要用其子类---SimpleDateFormat.这个类需要一定的格式来指定格式化标准。

　　格式：

　　DateFormat 对象名 = new SimpleDateFormat(String pattern);

　　参数pattern是一个字符型，代表日期时间的自定义格式。

　　格式规则：

 　　例如：

　　将当前日期和时间 格式化为：年 月 日 时 分 秒

package day01.dateTest;
//导包
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;

public class DateFormat_1 {
    public static void main(String[] args) {
        Date date = new Date();//创建Date对象
        DateFormat Fmt = new SimpleDateFormat("yyyy年MM月dd日");//将时间格式转换为年月日
        System.out.println(Fmt.format(date)); //2021年03月14日

        //将时间转换为 年 月 日 时 分 秒 格式
        DateFormat Fmt2 = new SimpleDateFormat("yyyy年MM月dd日 HH时:mm分:ss秒");
        System.out.println(Fmt2.format(date));
    }
}
SimpleDateFormat

　　4、parse方法

　　该方法也是属于SimpleDateFormat类，用于将String类型的对象 转换为 Date对象

　　格式：

　　SimpleDateFormat对象名.parse(source);

　　source标识 需要格式化的字符串

　　例如：　

package day01.dateTest;

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

public class parse_01 {
    public static void main(String[] args) throws ParseException {
        //将字符串转换为Date对象
        String str = "2021年03月14日 10时:28分:40秒";
        //创建DateFormat对象
        DateFormat Fmt = new SimpleDateFormat("yyyy年MM月dd日 HH时:mm分:ss秒");
        //创建Date对象 接收 转换的对象
        Date date = Fmt.parse(str);
        System.out.println(date);   //Sun Mar 14 10:28:40 CST 2021


    }
}
SimpleDateFormat.parse()

练习：

　　问题：计算一个人已经出生了多少天

　　1天 = 

package day01.dateTest;

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

public class Birth_Day {
    //计算一个人 出生至今多少天
    public static void main(String[] args) throws ParseException {
        //获取出生日期
        String birth = getBir();
        //将字符串转换为Date对象 并用Date接收
        DateFormat Fmt = new SimpleDateFormat("yyyy年MM月dd日");
        Date birthday = Fmt.parse(birth);
        //将生日转换为毫秒值
        long birHM = birthday.getTime();

        //获取当前日期
        Date NowDate = new Date();
        long NowDateHM = NowDate.getTime();

        //当前日期减去现在日期
        long result = NowDateHM - birHM;

        //判断
        if(result <= 0){
            System.out.println("还未出生-----");
        }else {
            //将毫秒 转为 天
            long secone = result/1000/60/60/24;
            System.out.println("您已在世"+secone+"天了");
        }
    }
    //创建获取生日的方法
    public static String getBir(){
        String birth;
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入出生的年份：");
        String Y= sc.next();
        System.out.print("月：");
        String M= sc.next();
        System.out.print("日：");
        String D = sc.next();
        birth = Y+"年"+M+"月"+D+"日";
        return birth;
    }
}
answer

Calender类

概述

　　java.util.Calender是日历类，在Date之后出现，替换了许多Date方法。该类将所有可能用到的时间信息封装为静态成员变量，方便获取。

　　日历类就是方便获取各个时间属性的。

获取方式

　　注意：Calender为抽象类；该类不能直接创建对象，而是通过静态方法创建，返回其子类对象。

1.Calender静态方法：

　　public static Calender getInstance();

　　使用默认时区和语言环境获取一个日历

2.格式：

　　Calender 对象名 = Calender.getInstance();  //多态

常用方法

　　int filed：表示日历类的字段，可以使用calender类的静态成员变量

　　静态变量：

　　1（Year）年　　2(Month)月　　 5(Date)月中的某一天

　　10（Hour）时　12（Minute）分  13（second）秒

　　1.get(int filed)：返回给定日历字段的值

package day01.dateTest;

import java.util.Calendar;

public class Calender_test {
    public static void main(String[] args) {
        //通过get方法 输出完整的年月日 时分秒
        Calendar calendar = Calendar.getInstance();
        //调用自定义的方法
        System.out.println(getMethod(calendar));//2021年2月14日3时37分53秒

    }

    /**
     * 参数：指定日历的字段
     * 返回值：日历字段代表具体的值
     */
    public static String getMethod(Calendar calendar){
        int Y = calendar.get(1);//获取年份
        int M = calendar.get(2)+1;//获取月份 西方月份0-11 所以需要加1
        int D = calendar.get(5);//天
        int H = calendar.get(10);//时
        int m = calendar.get(12);//分
        int s = calendar.get(13);//秒
        return Y+"年"+M+"月"+D+"日"+H+"时"+m+"分"+s+"秒";
    }
}
calender.get()

　　注意：西方月份0-11 所以需要+1

　　2.set(int filed,int value)：将给定的日历字段设置为给定值。

package day01.dateTest;

import java.util.Calendar;

public class Calender_test {
    public static void main(String[] args) {
        //创建Calder对象
        Calendar calendar = Calendar.getInstance();
        //调用自定义的方法
        //调用修改方法
        System.out.println(setMethod(calendar));//2088年2月14日
    }

    /**
     * 参数：指定日历的字段
     * 返回值：日历字段代表具体的值
     */
    public static String getMethod(Calendar calendar){
        int Y = calendar.get(1);//获取年份
        int M = calendar.get(2)+1;//获取月份 西方月份0-11 所以需要加1
        int D = calendar.get(5);//天
        int H = calendar.get(10);//时
        int m = calendar.get(12);//分
        int s = calendar.get(13);//秒
        return Y+"年"+M+"月"+D+"日"+H+"时"+m+"分"+s+"秒";
    }
    public static String setMethod(Calendar calendar){
        calendar.set(Calendar.YEAR,2088);
        int Y = calendar.get(Calendar.YEAR);
        int M = calendar.get(Calendar.MONTH)+1;
        int D = calendar.get(Calendar.DAY_OF_MONTH);
        String str = Y+"年"+M+"月"+D+"日";
        return str;
    }
}
calender.set(int filed,int value)
package day01.dateTest;

import java.util.Calendar;

public class Calender_test {
    public static void main(String[] args) {
        //创建Calder对象
        Calendar calendar = Calendar.getInstance();
        //调用自定义的方法
        //调用修改方法
        System.out.println(setMethod(calendar));//2088年2月14日
    }

    
    public static String setMethod(Calendar calendar){
        //重载方法 直接设定 年月 日
        calendar.set(6666,6,6);
        int Y = calendar.get(Calendar.YEAR);
        int M = calendar.get(Calendar.MONTH);
        int D = calendar.get(Calendar.DAY_OF_MONTH);
        String str = Y+"年"+M+"月"+D+"日";
        return str;
    }
}
利用重载 同时设置

　　3.add(int filed,int amount)：根据日历的规则，为给定的日历字段添加或减去指定的时间量

　　传递正数：增加

　　传递负数：减少

package day01.dateTest;

import java.util.Calendar;

public class Calender_test {
    public static void main(String[] args) {
        //创建Calder对象
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.get(2));//直接获取的值：2月

        calendar.add(Calendar.MONTH,1);
        System.out.println(calendar.get(2));//修改后获取的值：3月

        calendar.add(Calendar.YEAR,-1);//减少1年
        System.out.println(calendar.get(1));//2020
    }
}
canlender.add()

　　4.getTime()：返回一个表示此Calender的时间值(从历元到现在的毫秒偏移值)的Date对象。

 

package day01.dateTest;

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

public class get_Time {
    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();
        Date date = calendar.getTime(); //将日历转换为日期
        System.out.println(date);//返回值 Sun Mar 14 15:59:46 CST 2021
        DateFormat Fmt = new SimpleDateFormat("yyyy年MM月dd日");//格式化
        System.out.println(Fmt.format(date));//2021年03月14日
    }
}
getTime()

System类

概述：

　　System类是一些与系统相关的属性和方法的集合，而且在System类中所有的属性都是静态的，要想引用这些属性和方法，直接使用System类调用即可。

常用方法　　

1、currentTimeMillis方法：

　　返回以毫秒为单位的当前时间

package day01.dateTest;

import java.util.Properties;

public class system_demo {
    public static void main(String[] args) {
        System.out.println(System.currentTimeMillis());//1615710740558
    }
}
currentTimeMillis()

　　注意：实际上currentTimeMillis()方法，是获取当前系统时间与1970年1月01日00:00点之间的毫秒差值

　　练习：

　　验证for循环打印数字1-999所使用的时间(毫秒值)

package day01.dateTest;

import java.util.Properties;

public class system_demo {
    public static void main(String[] args) {
        long start = System.currentTimeMillis();//获取开始时间
        for (int i = 0; i < 999; i++) {
            System.out.println(i);
        }
        long end = System.currentTimeMillis();//获取结束时间
        long result = end - start;
        System.out.println("共耗时："+result+"毫秒");
    }
}
practice

2、arraycopy()方法：

　　功能：将数组中指定的数值，拷贝到另一个数组中

　　格式：　　

　　public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
　　解析：

　　其中5个参数的含义

　　

 

 

　　例如：

　　将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] 

package day01.dateTest;

public class System_demo01 {
    public static void main(String[] args) {
        int[] src = {1,2,3,4,5};
        int[] des = {6,7,8,9,10};
        System.arraycopy(src,0,des,0,3);
        for (int i = 0; i < src.length; i++) {
            System.out.print(src[i]);
        }
        System.out.println();//12345
        for (int i = 0; i < des.length; i++) {
            System.out.print(des[i]);//123910
        }
    }
}
for_example

StringBuilder类

字符串拼接问题

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

　　例如：

public class StringDamo {
    public static void main(String[] args) {
        String str = "abc";
        str+="Hello";
        System.out.println(str);
    }
}

　　解析：

　　字符串是常量，他们的值在创建后不能被改变。

　　所以上述代码总共产生了三个字符串：abc　Hello　abeHello

　　由此可知，如果对字符串进行拼接操作，每次拼接都会构建一个新的String对象，耗时耗力。

StringBuilder

　　1、概述　　

　　StringBuilder又称为可变字符串，它是一个类似于String的字符串缓冲区(可以提高效率)，通过某些方法可以改变该序列的长度和内容。

　　2、解析

　　StringBuilder的内部拥有一个数组用来存放字符串内容，进行字符串拼接时，直接在数组中加入新内容（StringBuider是一个动态数组，长度可变）

　　3、原理图

　　StringBuilder始终是一个数组，只占用一个空间(默认16字符空间，超过自动扩容)

　　

两个常用构造方法

1、构造空容器

　　public StringBuilder();：构造一个空的StringBuilder容器。　　

public class SB_demo {
    public static void main(String[] args) {
        //构造空白SB容器
        StringBuilder str = new StringBuilder();
        System.out.println(str);
    }
}

2、构造带参容器

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

public class SB_demo {
    public static void main(String[] args) {
        //使用带参构造方法
        StringBuilder sb = new StringBuilder("Fighting");
        System.out.println(sb);
    }
}

两个常用方法

1、添加/追加—append()

　　概述：

　　append方法具有多种重载形式，可以接收任意类型的参数。任何数据作为参数都会将对应的字符串内容添加到SB容器中。

　　例如：

package day02;

public class SB_demo01 {
    public static void main(String[] args) {
        //创建空参SB容器
        StringBuilder sb = new StringBuilder();
        //再次创建一个对象 通过append()方法 往SB容器中添加内容
        StringBuilder sb1 = sb.append("Hello");
        //对比
        System.out.println("sb"+sb);    //sbHello
        System.out.println("sb1"+sb1);  //sb1Hello
        System.out.println(sb == sb1);  //true
        //添加各种类型 测试
        sb.append(10);
        sb.append(" world ");
        sb.append(false);
        System.out.println(sb);//Hello10 world false 照单全收
        //链式添加
        sb1.append(10).append(" str ").append(true); //照单全收
        System.out.println(sb1);

    }
}
StringBuilder[append()]

　　注意：

　　StringBuilder已经覆盖重写了Object当中的toString方法。2　　

2、toString方法

　　概述：

　　通过toString方法，SB对象将会转为不可以变的String对象。

　　例如：

package day02;

public class SB_demo02 {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("hello word");
        sb.append("!");
        String str = sb.toString();
        System.out.println(str);
    }
}
toString

3、reverse方法--反转

　　概述：

　　通过reverse方法，SB容器中的内容会反转

　　例如：

package day02;

public class SB_demo02 {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("hello word");
        sb.reverse();
        //反转字符串
        System.out.println(sb);
    }
}
reverse()--反转

　　注意：　　

　　String类 没有反转的方法，所以这是重点

包装类

概述

　　java提供了两种数据类型：基本类型 和 引用类型，使用基本类型在于效率，然更多情况，会创建对象时使用，因为对象可以做更多的功能。

　　如果想要将基本类型像对象一样操作，就可以使用基本类型的包装类，例如：

 

装箱与拆箱

　　基本类型与对应的包装类之间，来回转换的过程称为“装箱”和“拆箱”

 　　装箱：从基本类型转换为对应的包装类对象

　　 拆箱：从包装类对象转换为对应的基本类型

　　例如：

　　用Integer包装类对象 转换为 int对象

　　基本数据类型---->包装类对象

　　格式：Integer 对象名 = Integer.Valueof(Integer num)

package day02;
import java.lang.*;
public class BZ {
    public static void main(String[] args) {
        //装箱
        Integer i = Integer.valueOf(10);
        System.out.println(i);
    }
}
装箱--Integer

　　包装类对象---->基本数据类型

　　格式：int 变量名 = 包装对象.intValue();

package day02;
import java.lang.*;
public class BZ {
    public static void main(String[] args) {
        //装箱
        Integer i = Integer.valueOf(10);
        //拆箱
        int num = i.intValue();
        System.out.println(num);
    }
}
拆箱--int

自动装箱与拆箱

　　概述：由于我们经常需要做基本类型和包装类的转换，从Java5开始，基本类型与包装类的装箱、拆箱动作可以自动完成。

　　例如：

package day02;

public class BZ_demo {
    public static void main(String[] args) {
        Integer i = 5;  //自动装箱 == Integer i = Integer.valueOf(5)
        i+=5;   //等号右边：拆箱 将i对象 转换成基本数值 == i.intValue()+5
        //加法运算完成后 再次装箱 把基本数值转换为对象
        System.out.println(i);
    }
}
自动装箱、拆箱(JDK5+)
posted @ 2021-03-13 00:15  心岛未晴  阅读(80)  评论(0)    收藏  举报