菜鸡学习day12_Object类&Objects类&DateFormat类&Calender类&System类&String类&StringBuilder类&包装类

菜鸡学习day12

package day12;
/*
java.lang.Object
Object类
是根层次结构的超类
1.toString
    直接打印对象名=调用对象的toString
    若没有重写，则打印地址值
2.equals            源码：public boolean equals（Object obj）{
                                return（this == obj）
                          }//this为该方法对应的对象
    默认比较对象地址值

java.lang.Object
Objects类
防止空指针异常，调用返回发可以写空指针null

java.util.Date（表示日期和时间的类）
Date类
（表示特定的瞬间，精确到毫秒）1/1000s      2088-08-08 09：55：33：333瞬间
毫秒值的作用：可对日期和时间进行计算
            把日期转换为毫秒，再换回
            1.日转秒：计算当前日期到时间原点之间毫秒
                                   时间原点：1970.0101.00：00：00

DateFormat类（是日期/时间格式化子类的抽象类）
日期格式化
成员方法：String format（Date date）将日期转为字符串
         Date parse（String source）将字符串解析为日期 **处理异常throws？
为抽象类，无法直接创建对象，可以使用DateFormat的子类SimpleDateFormat
构造方法：SimpleDateFormat(String pattern)
        用给定的模式和默认语言环境的日期格式符号构造 SimpleDateFormat。
        String pattern：传递指定的模式      y年M月d日H时m分s秒
        写对应的模式，会把模式替换为对应的日期“yyyy-MM-dd HH:mm：ss”
        字母不可改，连接符可改

Calender类（日历）
抽象类，无法直接创建对象，使用子类GregorianCalender
Calendar.getInstance() 使用默认时区和语言环境获得一个日历
成员方法：public int get(int field)返回指定字段值
         public void set(int field,int value)设置某字段值
         public abstract void add（int field，int amount）增减时间量
         public Date getTime（）日历转日期

System类（静态方法，获取与系统相关的信息或系统及操作）
public static long scrrentTimeMills();返回一毫秒为单位的当前时间（测试程序效率）
public static void arraycopy(源array,位置,目标array,位置,length) 将源数组的某段数据赋值到另一数组（非null）

String类
字符串的底层时一个被final修饰的数组，private final byte【】 value创建后不可改变
字符串相加，内存中产生多个字符串，占用空间多效率低下 a+b+c  a，b，c，ab，abc

StringBuilder类
字符串缓冲区，可提高字符串操作效率（相当于可改变长度的字符串）
底层也是数组（无final） byte【】 value = new byte【16】
内存中始终是一个数组，占用空间少 a+b+c   abc
若超出了容量会自动扩容（初始容量为16）
构造方法
StringBuilder()空字符串生成器
StringBuilder(str)字符串生成器
常用方法
public StringBuilder append(...);添加任意字符串形式，返回给对象本身
;StringBuilder与String相互转化
1.StringBuilder(str1)           String->StringBuilder
2.toString()                    StringBuilder->String

包装类

装箱与拆箱
1.装箱：基本类型数据转换成包装类
构造方法
Integer(int value)      构造方法（划线，已过时），重新写了toString方法
Integer(String value)
静态方法
static Inetger valueOf(int value)
static Inetger valueOf(String value)
2.拆箱：反之
成员方法
int intValue()  以int返回Integer值

自动装箱与拆箱(自动相互转换)
        //自动装箱
        Integer in4 = 1;
        //自动拆箱（in4 + 2 相当于in4.untVale()+2 = 3）再自动装箱 in4 = 3
        in4 = in4 + 2;
        ArrayList的set/get也是自动转换
基本类型与字符串的相互转换
基本类型->字符串
    1.基本类型值+“str”
    2.包装类的静态方法 static String toString(参数)
    3.String类的静态方法 static String valueof(参数)
字符串->基本类型
    包装类的静态方法
        Integer类：static int parseInt(str)
        Double类：static double parseDouble(str)
 */
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Date;
import java.util.Objects;

public class D1201 {
    public static void main(String[] args) throws ParseException {
        Person person = new Person("张三",18);
        String str = person.toString();
        System.out.println(str);
        System.out.println(person);//两者相等（直接打印对象名=调用对象的toString）

        Person p1 = new Person("小明",12);
        Person p2 = new Person("小红",13);
        boolean a = p1.equals(p2);//比较地址//equals重写后比较内容
        System.out.println(a);//false

        boolean b = Objects.equals(p1,p2);//Objects类
        System.out.println(b);
        boolean c = Objects.equals(null,p2);//调用方法可以写空指针
        System.out.println(c);

        System.out.println(System.currentTimeMillis());//获取当前时间到
                                    // 1970.0101.00：00：00经历了多少毫秒
        demo01();//Date空参数构造方法
        demo02();//Date带参数构造方法
        demo03();//Date成员方法，date.getTime() 日转毫秒
        demo04();//解析与格式化

        Calendar calendar = Calendar.getInstance();//使用默认时区和语言环境获得一个日历
        System.out.println(calendar);

        demo05();//传递指定的日历字段
        demo06();
        demo07();
        demo08();

        system01();
        system02();

        stringBuilder01();//构造方法，字符串生成器
        stringBuilder02();//添加任意字符串形式，返回给对象本身
        stringbuilder03();//StringBuilder与String相互转化
        baozhuang01();//装箱与拆箱，自动装箱与拆箱
        zhuanhuan01();//基本类型与字符串的相互转换

    }
    //Date空参数构造方法
    //Date（）获取当前时间
    private static void demo01(){
        Date date = new Date();
        System.out.println(date);
    }
    //Date带参数构造方法
    //Date（long date）毫秒转日
    private static void demo02(){
        Date date = new Date(0L);
        System.out.println(date);
    }
    //Date成员方法
    //date.getTime() 日转毫秒，相当于System.currentTimeMillis()
    private static void demo03(){
        Date date = new Date();
        long time = date.getTime();
        System.out.println(time);
    }

    private static void demo04() throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat();
        Date date = new Date();
        String str = sdf.format(date);//格式化
        System.out.println(str);
        Date date01 = new Date();
        date01 = sdf.parse(str);//解析
        System.out.println(date01);
    }

    //传递指定的日历字段
    private static void demo05(){
        Calendar c = Calendar.getInstance();//使用默认时区和语言环境获得一个日历
        int year = c.get(Calendar.YEAR);//获取年2020
        System.out.println(year);

    }

    private static void demo06(){
        Calendar c = Calendar.getInstance();
        c.set(Calendar.YEAR,2000);//将year改为2000
        System.out.println(c);
    }

    private static void demo07(){
        Calendar c = Calendar.getInstance();
        c.add(Calendar.YEAR,10);//year+10
        System.out.println(c);
    }

    private static void demo08(){
        Calendar c = Calendar.getInstance();
        Date date = c.getTime();//日历转日期
        System.out.println(date);
    }

    private static void system01(){
        long time = System.currentTimeMillis();
        for (int i = 0; i < 9999; i++) {
            System.out.print(i);
        }
        long time1 = System.currentTimeMillis();
        System.out.println("共耗时" + (time1 -time));
    }

    private static void system02(){
        int[] array1 = {1,2,3,4,5};
        int[] array2 = {6,7,8,9,10};
        System.arraycopy(array1,0,array2,0,3);
        System.out.println(Arrays.toString(array1));
        System.out.println(Arrays.toString(array2));
    }

    private static void stringBuilder01(){//构造方法，字符串生成器
        StringBuilder bu1 = new StringBuilder();//空参数构造
        System.out.println(bu1);

        StringBuilder bu2 = new StringBuilder("abc");//字符串构造
        StringBuilder bu3 = new StringBuilder("abc");
        System.out.println(bu2);
    }

    private static void stringBuilder02(){//添加任意字符串形式，返回给对象本身
        StringBuilder bu = new StringBuilder();
        StringBuilder bu1 = bu.append("abc");
        System.out.println(bu);
        System.out.println(bu1);
        System.out.println(bu == bu1);//比较地址，true
        //atend无需接收返回值
        bu.append(123);
        bu.append("aaa");
        bu.append(true);
        //链式（返回值是一个对象，可以继续调用方法）
        bu.append(11).append("aa").append(false);
        System.out.println(bu);
    }

    private static void stringbuilder03(){//StringBuilder与String相互转化
        String str1 = "hello";
        System.out.println(str1);
        StringBuilder bu = new StringBuilder(str1);//String->StringBuilder
        System.out.println(bu);
        bu.append("world");
        System.out.println(bu);

        String str2 = bu.toString();//StringBuilder->String
        System.out.println(str2);
    }

    private static void baozhuang01(){
        //装箱
        Integer in1 = new Integer(1);//构造方法（划线，已过时）
        System.out.println(in1);           //重新写了toString方法
        Integer in2 = new Integer("1");
        System.out.println(in2);

        Integer in3 = Integer.valueOf(1);//静态方法
        System.out.println(in3);
        Integer in4 = Integer.valueOf("1");
        System.out.println(in4);
        //拆箱
        int i = in1.intValue();//成员方法
        System.out.println(i);

        //自动装箱
        Integer in5 = 1;
        //自动拆箱（in4 + 2 相当于in4.untVale()+2 = 3）再自动装箱 in4 = 3
        in5 = in5 + 2;
    }

    private static void zhuanhuan01(){
        //基本类型->字符串
        int i1 = 123;
        String str1 = i1 + "456";//直接转换
        System.out.println(str1);

        String str2 = Integer.toString(123);//包装类的toString
        System.out.println(str2 + 456);

        String str3 = String.valueOf(123);//String类的valueOf
        System.out.println(str3 + 456);

        //字符串->基本类型
        int i2 = Integer.parseInt(str1);//int
        System.out.println(i2 + 10);

        double i3 = Double.parseDouble(str1);//double
        System.out.println(i3 + 0.5);
    }
}

package day12;

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

/*    //重写toString，返回内容
    @Override
    public String toString() {
        return name + "," + age;
    }

    public String getName() {
        return name;
    }*/

    @Override//重写toString，使其打印内容
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
/*
        @Override
        public boolean equals(java.lang.Object obj) {
            //使用向下转型，使obj变成Person
            if(obj == this){
                return true;
            }
            if(obj == null){//为空，直接返回false，提高程序转换效率
                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;
        }
*/


    @Override//自动重写有问题，修改了参数（原来为Object o）可能需要重新下一个idea
    public boolean equals(java.lang.Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Person person = (Person) obj;//向下转型
        return age == person.age &&
                Objects.equals(name, person.name);
    }//使用了反射技术getClass() != obj.getClass()，=if(obj instanceof Person)
    // 判断obj是否为Person类型

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}