JAVA基础学习总结，day12(Object、Objects工具类、Date类、DateFormat类、 SimpleDateFormat类、Calendar类、System类、可变字符串、包装类)

2023-02-22 22:27:10

Object类：

概述：java.lang.Object 类是Java语言中的根类，即所有类的父类
object类里面定义的方法，所有类的对象都可以使用
所有类都是直接或者间接继承object类
在对象实例化的时候，最终找的父类就是object

构造方法：

  • object（）；

成员方法：

  • public String toString() ：返回该对象的字符串表示 （快捷键：alt+enter）
  1. 默认返回的字符串是：包名+类名+@+内存地址值
  2. 在开发中，经常打印对象，希望打印的是对象所有的属性对应字符串表现形式，就应该重写toString（）方法
  3. 因为打印对象的时候其实默认会调用对象的toString()方法

总结:所以以后打印对象名,如果想要使用默认规则进行打印,那么就不重写toString方法,如果想要打印对象名的时候指定规则打印,那么就 重写toString方法,然后在toString方法中定义打印规则

  • public boolean equals(Object obj) ：指示其他某个对象是否与此对象“相等”。比较两个对象是否相等比较的是地址值（快捷键：alt+enter）
  1. object类种的equals方法，默认比较的是2个对象的地址值是否相等
  2. 在开发中，往往认为2个对象的所有属性一致，我们就认为是2个相同的对象，所以需要重写equals方法来实现

总结:使用equals方法比较2个对象是否相等,如果没有没有重写equals方法,那么默认比较的是2个对象的地址值,如果想要按照自己指定的规则进行比较2个对象 那么就需要重写equals方法

 import java.util.Objects;
  public class Person {
   private String name;
     private int age;

 @Override
public boolean equals(Object o) {
        // 如果对象地址一样，则认为相同
        if (this == o)
            return true;
        // 如果参数为空，或者类型信息不一样，则认为不同
        if (o == null || getClass() != o.getClass())
            return false;
        // 转换为当前类型
        Person person = (Person) o;
        // 要求基本类型相等，并且将引用类型交给java.util.Objects类的equals静态方法取用结果         return age == person.age && Objects.equals(name, person.name);
    }
}

Objects类：

概述:在JDK7添加了一个Objects工具类，它提供了一些方法来操作对象，它由一些静态的实用方法组成，这些方法是 null-save（空指针安全的）或null-tolerant（容忍空指针的），用于计算对象的hashcode、返回对象的字符串表 示形式、比较两个对象。

成员方法：

  • public static boolean equals(Object a, Object b) :判断两个对象是否相等。

  • public static boolean equals(Object a, Object b) {
    return (a == b) || (a != null && a.equals(b));
    }

Date类：日期时间类

概述:表示时间对象，精确到毫秒

构造方法：

  • public Date() ：分配Date对象并初始化此对象，以表示分配它的时间（精确到毫秒）。//创建一个当前时间对象

  • public Date(long date) ：分配Date对象并初始化此对象，参数为毫秒值
    以表示自从标准基准时间（称为“历元 （epoch）”，即1970年1月1日00:00:00 GMT）以来的指定毫秒数。

tips:由于我们处于东八区，所以我们的基准时间为1970年1月1日8时0分0秒
long date:代码传递的毫秒数

import java.util.Date;
  public class Demo01Date {
    public static void main(String[] args) {
        // 创建日期对象，把当前的时间
        System.out.println(new Date()); // Tue Jan 16 14:37:35 CST 2018

        // 创建日期对象，把当前的毫秒值转成日期对象
        System.out.println(new Date(0L)); // Thu Jan 01 08:00:00 CST 1970

        //创建一个1970年1月1日7时0分0秒
        Date date=new Date(-1*60*60*1000L);//Thu Jan 01 07:00:00 CST 1970
    }
}

成员方法：

  • public long getTime() 把日期对象转换成对应的时间毫秒值 //获取date对象对应的毫秒数
import java.util.Date;
  public class Demo01Date {
    public static void main(String[] args) {
        // 获取当前的时间
        Date date=new Date();
        //计算当前时间对象对应的毫秒数（基准时间到当前date时间对象的毫秒值）
        long time = date.getTime();
        System.out.println(time);//基准时间 到 当前date时间对象 的毫秒值
        
        Date date1=new Date();
        long time1=date1.getTime();
        System.out.pringtln(time1);//0
    }
}

DateFormat类：日期格式化类

概述：java.text.DateFormat 是日期/时间格式化子类的抽象类，我们通过这个类可以帮我们完成日期和文本之间的转 换,也就是可以在Date对象与String对象之间进行来回转换。

作用:

  1. 把日期对象转换为字符串对象
  2. 把字符串对象转换为日期对象

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

由于DateFormat为抽象类，不能直接使用，所以需要常用的子类 java.text.SimpleDateFormat 。这个类需要一个 模式（格式）来指定格式化或解析的标准。

SimpleDateFormat类:

构造方法：

  • public SimpleDateFormat(String pattern) ：用给定的模式和默认语言环境的日期格式符号构造 SimpleDateFormat。 参数pattern是一个字符串，代表日期时间的自定义格式。

格式规则：

 常用的格式规则为：
      标识字母（区分大小写） 含义
           y                               年
           M                             月
           d                              日
           H                              时
           m                             分
           s                               秒

DateFormat中的成员方法 解析：

  • Date parse(String source) 从给定字符串的开始解析文本以生成日期
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
  把String转换成Date对象
*/
public class Demo04DateFormatMethod {
    public static void main(String[] args) throws ParseException {
        //创建日期格式对象
        DateFormat df = new SimpleDateFormat("yyyy年MM月dd日");

        String str = "2018年12月11日";
        Date date = df.parse(str);
        System.out.println(date); // Tue Dec 11 00:00:00 CST 2018
    }
}

DateFormat中的成员方法 格式化：

  • String format(Date date) 将日期格式化成日期/时间字符串
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
  把Date对象转换成String
*/
public class Demo03DateFormatMethod {
    public static void main(String[] args) {
        //创建当前时间日期对象
        Date date = new Date();
        // 创建日期格式化对象,在获取格式化对象时可以指定风格
        DateFormat df = new SimpleDateFormat("yyyy年MM月dd日");
        String str = df.format(date);
        System.out.println(str); // 2008年1月23日
    }
}

Calendar类:日历类

1.包:java.util 导包
2.Calendar类是一个抽象类,用来表示日历
3.创建Calendar日历对象是通过其静态方法来创建的

static Calendar getInstance() 使用默认时区和区域设置获取日历。

java.util.GregorianCalendar[time=1556357409224,areFieldsSet=true,areAllFieldsSet=true,
        lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",
        offset=28800000,dstSavings=0,useDaylight=false,transitions=19,lastRule=null],
        firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,
        YEAR=2019,MONTH=3,WEEK_OF_YEAR=17,WEEK_OF_MONTH=4,DAY_OF_MONTH=27,
        DAY_OF_YEAR=117,DAY_OF_WEEK=7,DAY_OF_WEEK_IN_MONTH=4,AM_PM=1,HOUR=5,
        HOUR_OF_DAY=17,MINUTE=30,SECOND=9,MILLISECOND=224,ZONE_OFFSET=28800000,DST_OFFSET=0]

     外国人的一个星期第一天是星期日,最后一天是星期六
     中国人的一个星期第一天是星期一,最后一个是星期日
4.获取日历对象身上的数据: Calendar日历类的成员方法
  • public int get(int field)：返回给定日历字段的值。
Calendar cal = Calendar.getInstance();
System.out.println(cal);

System.out.println(cal.get(Calendar.YEAR));//2019
  • public void set(int field, int value)：将给定的日历字段设置为给定值。
//修改为2018年
cal.set(Calendar.YEAR,2018);
System.out.println(cal.get(Calendar.YEAR));// 2018
  • public abstract void add(int field, int amount)：根据日历的规则，为给定的日历字段添加或减去指定的时间量。
// 为YEAR字段增加2年--->2020年
cal.add(Calendar.YEAR,2);
System.out.println(cal.get(Calendar.YEAR));// 2020
  • public Date getTime()：返回一个表示此Calendar时间值（从历元到现在的毫秒偏移量）的Date对象。
// 把日历对象转换为日期对象
Date date = cal.getTime();
System.out.println(date);// Mon Apr 27 17:49:38 CST 2020

Calendar类中的字段:

  • YEAR 年
  • MONTH 月
  • DAY_OF_MONTH 日
  • HOUR_OF_DAY 时
  • MINUTE 分
  • SECOND 秒

System类:

1.包:java.lang 不需要导包
2.java.lang.System类中提供了大量的静态方法，可以获取与系统相关的信息或系统级操作
3.静态成员方法:
  • public static long currentTimeMillis()：返回以毫秒为单位的当前时间。
long time = System.currentTimeMillis();
System.out.println(time);// 1556359766379
System.out.println(new Date().getTime());//1556359766381
  • public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：将数组中指定的数据拷贝到另一个数组中。
    src: 指的是源数组
    srcPos:源数组需要拷贝的元素的起始索引
    dest:目标数组
    destPos:目标数组元素的起始索引
    length:拷贝多少个元素
int[] arr1 = {10,20,30,40,50,60};
int[] arr2 = {100,200,300,400,500,600};

// 把arr1数组中的所有元素拷贝到arr2数组中
/*System.arraycopy(arr1,0,arr2,0,6);
System.out.println(Arrays.toString(arr2));// [10,20,30,40,50,60]*/

// 把arr1数组中的20,30,40拷贝到arr2数组中,使得arr2数组变成{100,20,30,40,500,600}
System.arraycopy(arr1,1,arr2,1,3);
System.out.println(Arrays.toString(arr2));// [100, 20, 30, 40, 500, 600]

String类:表示字符串,但是是不可变的
String字符串拼接会创建一个新的字符串

StringBuilder类:表示字符串,但是是可变的

1.包:java.lang 不需要导包
2.StringBuilder类:表示字符串,但是是可变的
3.StringBuilder可以解决String字符串拼接的问题
4.构造方法:
  • public StringBuilder()：构造一个空的StringBuilder容器。
  • public StringBuilder(String str)：构造一个StringBuilder容器，并将字符串添加进去。

StringBuilder sb = new StringBuilder(“Hello”);

5.成员方法:
  • StringBuilder append(String str) 将指定的字符串附加到此字符序列。
sb.append(" World");
sb.append(2019);

System.out.println(sb);//Hello World2019

        public String toString()：将当前StringBuilder对象转换为String对象。

String str = sb.toString();
System.out.println(str);//Hello World2019

        StringBuilder reverse()  导致该字符序列被序列的相反代替。

 // 对字符串进行反转
        String str2 = "abcdefg";

        System.out.println(new StringBuilder(str2).reverse().toString());//gfedcba
包装类:

概述:Java提供了两个类型系统，基本类型与引用类型，使用基本类型在于效率，然而很多情况，会创建对象使用，

因为对象可以做更多的功能，如果想要我们的基本类型像对象一样操作，就可以使用基本类型对应的包装类

规则:

  • byte Byte
  • short Short
  • int Integer
  • long Long
  • char Character
  • float Float
  • double Double
  • boolean Boolean

自动装箱:把基本数据类型 自动转换为对应的 包装类型
拆箱装箱:把包装类型 自动转换为对应的 基本数据类型

基本类型与字符串之间的转换:
1.基本类型转换为字符串
// 1.基本类型转换为字符串  三种
int num = 10;
String str1 = num + "";

Integer i = num;
String str2 = i.toString();

String str3 = String.valueOf(num);
2.字符串转换为基本数据类型

除了Character类之外，其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型

  • public static byte parseByte(String s)：将字符串参数转换为对应的byte基本类型。
  • public static short parseShort(String s)：将字符串参数转换为对应的short基本类型。
  • public static int parseInt(String s)：将字符串参数转换为对应的int基本类型。
  • public static long parseLong(String s)：将字符串参数转换为对应的long基本类型。
  • public static float parseFloat(String s)：将字符串参数转换为对应的float基本类型。
  • public static double parseDouble(String s)：将字符串参数转换为对应的double基本类型。
  • public static boolean parseBoolean(String s)：将字符串参数转换为对应的boolean基本类型
// 2.字符串转换为基本数据类型
Integer i2 = new Integer("123");// 123
int num2 = i2;

Integer i3 = Integer.valueOf("1234");// 1234
int num3 = i3;

int num4 = Integer.parseInt("12345");// 12345
上一篇：通过循环设置多条对象，用于分页测试


下一篇：时间、时间戳相关小结 - iOS