java date format Javadateformate

目录

• 简介
• Date

• Date的构造方法
• after 测试此日期是否在指定日期之后
• before 测试此日期是否在指定日期之前
• clone 返回此对象的副本
• compareTo 比较两个日期
• equals 比较两个date类型数据是否相等
• from 从Instant对象获得Date的实例

• Instant类

• getTmie 自1970年1月1日00:00:00 GMT以来的毫秒数
• setTime 将date对象根据long类型值设置时间
• hashCode与toString

• DateFormat

• SimpleDateFormat

• 构造方法
• set2DigitYearStart get2DigitYearStart 设置与获取
• format 为Date对象设置格式并返回String类型值
• toPattern 返回描述日期格式的模式字符串
• toLocalizedPattern 用字符串返回本地日期格式
• applyPattern 将给定的模式字符串应用于此日期格式
• parse 将String类型的时间转换为Date对象存储

简介

本文简单介绍Date DateFormat的常用方法

Date

Date的构造方法

Date的部分方法

通过上图我们其实可以发现Date中的方法大多都已经过时了，我们只需要了解一些现在还在使用的方法，其他过时的方法我们大多需要通过Calendar类或者DateFormat中的方法去实现了。

Date的构造方法

现在我们使用的Date的构造方法只有两个，我通过代码测试了一下这两个代码

Date date = new Date();
        System.out.println("date = " + date);
        Date date2 = new Date(50000L);
        System.out.println("date2 = " + date2);

运行图示：

可以发现，如果没有参数的构造方法构造Date类型的数据，他会获取本地时间。
如果有一个long类型的参数x，他会在1970年1月1日00:00:00 GMT的基础上加上x毫秒，即为构造出的date类型的值。

after 测试此日期是否在指定日期之后

为了方便在目录中观看并且迅速找到方法，我把方法的名称和大致功能都写在了标题上。
参数：

public boolean after(Date when)

测试代码：

Date date1 = new Date(48L);
        Date date2 = new Date(49L);
        Date date3 = new Date(50L);

        System.out.println(date2.after(date1));
        System.out.println(date2.after(date2));
        System.out.println(date2.after(date3));

运行图示：

可以发现等于的情况它返回的也是false

before 测试此日期是否在指定日期之前

参数：

public boolean before(Date when)

测试代码：

Date date1 = new Date(48L);
        Date date2 = new Date(49L);
        Date date3 = new Date(50L);

        System.out.println(date2.before(date1));
        System.out.println(date2.before(date2));
        System.out.println(date2.before(date3));

运行图示：

clone 返回此对象的副本

参数及返回类型：

public Object clone()

测试代码：

Date date1 = new Date(900000000000L);
        Date date2 = (Date) date1.clone();

        System.out.println("date1 = " + date1);
        System.out.println("date2 = " + date2);

运行图示：

compareTo 比较两个日期

参数及返回类型：

public int compareTo(Date anotherDate)

返回int类型数据，1为调用者更大，0为两者相同，-1为调用者更小
测试代码：

Date date1 = new Date(900000000000L);
        Date date2 = new Date(900000000001L);
        Date date3 = new Date(900000000002L);

        System.out.println(date2.compareTo(date1));
        System.out.println(date2.compareTo(date2));
        System.out.println(date2.compareTo(date3));

运行图示：

equals 比较两个date类型数据是否相等

参数及返回类型：

public boolean equals(Object obj)

相同为true 不同为false

测试代码：

Date date1 = new Date(900000000000L);
        Date date2 = new Date(900000000001L);
        Date date3 = new Date(900000000001L);

        System.out.println(date2.equals(date1));
        System.out.println(date2.equals(date2));
        System.out.println(date2.equals(date3));
        System.out.println(date2.equals(null));

运行图示：

from 从Instant对象获得Date的实例

这个方法涉及到了一个Instant对象，那么这个Instant类又是什么呢？

Instant类

通过api文档我们发现，api文档中没有记录这个类的构造方法，我们只能通过源码来研究这个类了。

首先我们通过源码看一下这个类的构造方法：

/**
     * Constructs an instance of {@code Instant} using seconds from the epoch of
     * 1970-01-01T00:00:00Z and nanosecond fraction of second.
     *
     * @param epochSecond  the number of seconds from 1970-01-01T00:00:00Z
     * @param nanos  the nanoseconds within the second, must be positive
     */
    private Instant(long epochSecond, int nanos) {
        super();
        this.seconds = epochSecond;
        this.nanos = nanos;
    }

构造一个实例需要秒和纳秒，构造出的实例时间是1970-01-01 00:00:00加上秒数的时间，而且最关键的一点是，这个构造方法是用private修饰的。就是说我们是无法构造这个对象的，那么这个对象一般怎么得到呢？

之后我在api中发现了一些静态的方法，通过其中静态的方法我们可以获取Instant对象，比如：

Instant i = Instant.now();
        System.out.println(i);
        Date date = new Date();
        System.out.println(date);

结果图示：

可以发现 Instant的时间是与date得到的时间不一样的，而且正好差了8个小时

其实now()方法是有重载方法的：

简单的研究一下之后我们就可以得到自己时区的时间了：

Instant i = Instant.now(Clock.systemDefaultZone());
        Instant i2 = Instant.now();
        System.out.println(Clock.systemDefaultZone());
        System.out.println("i = " + i);
        System.out.println("i2 = " + i2);
        Date date = new Date();
        System.out.println("date = " + date);
        Date date2 = Date.from(i);
        System.out.println("date2 = " + date2);
        Date date3 = Date.from(i2);
        System.out.println("date3 = " + date3);

图示：

但是还是有一些疑问没有解决…为啥它时区与时间显示的不匹配呀…

getTmie 自1970年1月1日00:00:00 GMT以来的毫秒数

参数及返回类型：

public long getTime()

返回的是一个long类型的值
测试代码：

Date date = new Date();
        System.out.println(date);
        System.out.println(date.getTime());

运行图示：

setTime 将date对象根据long类型值设置时间

参数及返回类型：

public void setTime(long time)

将此 Date对象设置为表示格林威治标准时间1970年1月1日00:00:00之后的 time毫秒的时间点。

测试代码：

Date date = new Date();
        System.out.println(date);
        date.setTime(1515151515112L);
        System.out.println(date);

运行图示：

hashCode与toString

参数及返回类型：

public int hashCode()
public String toString()

测试代码：

Date date = new Date();
        System.out.println(date);
        System.out.println(date.hashCode());
        System.out.println(date.toString());

运行图示：

DateFormat

根据上图我们可以发现DateFormat是一个抽象类，通常我们使用的应该是它的子类SimpleDateFormat

SimpleDateFormat

构造方法

在构造方法中我们发现了一个String类型的pattern，他要求我们使用它给出的格式设置String类型变量

而对于其中的参数api也给出了示例：

尝试的代码：

SimpleDateFormat sdf1 = new SimpleDateFormat();
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd");
        SimpleDateFormat sdf3 = new SimpleDateFormat("yyyy-MM-dd EEE");
        SimpleDateFormat sdf4 = new SimpleDateFormat("yyyy-MM-dd '第' F '个'" + "星期");
        SimpleDateFormat sdf5 = new SimpleDateFormat("yyyy-MM-dd '第' DDD '天'" );
        SimpleDateFormat sdf6 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");


        Date date = new Date();
        String text = sdf1.format(date);
        System.out.println(text);
        text = sdf2.format(date);
        System.out.println(text);
        text = sdf3.format(date);
        System.out.println(text);
        text = sdf4.format(date);
        System.out.println(text);
        text = sdf5.format(date);
        System.out.println(text);
        text = sdf6.format(date);
        System.out.println(text);

结果图示：

set2DigitYearStart get2DigitYearStart 设置与获取

参数：

public Date get2DigitYearStart()
public void set2DigitYearStart(Date startDate)

代码：

SimpleDateFormat sdf1 = new SimpleDateFormat();
        System.out.println(sdf1.get2DigitYearStart());

        sdf1.set2DigitYearStart(new Date(6565650656L));
        System.out.println(sdf1.get2DigitYearStart());

        Date date = new Date(6565650656L);
        System.out.println(date);

        sdf1.set2DigitYearStart(new Date());
        System.out.println(sdf1.get2DigitYearStart());

结果图示：

应该是某种要求的时间，没有太理解其中的意义

format 为Date对象设置格式并返回String类型值

这个方法是DateFormat中的方法，SimpleDateFormat中重载了这个方法，可以看看前面构造方法中对于这个format的使用。
参数：

public final String format(Date date)

toPattern 返回描述日期格式的模式字符串

参数：

public String toPattern()

代码：

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        System.out.println(sdf.toPattern());
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd '第' DDD '天'" );
        System.out.println(sdf2.toPattern());
        SimpleDateFormat sdf3 = new SimpleDateFormat();
        System.out.println(sdf3.toPattern());

结果图示：

toLocalizedPattern 用字符串返回本地日期格式

参数：

public String toLocalizedPattern()

代码：

SimpleDateFormat sdf3 = new SimpleDateFormat();
        System.out.println(sdf3.toPattern());
        System.out.println(sdf3.toLocalizedPattern());
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        System.out.println(sdf2.toLocalizedPattern());

结果图示：

从返回值得角度看不出与toPattern有什么区别，需要从源码来看看：

toPattern源码：

/**
     * Returns a pattern string describing this date format.
     *
     * @return a pattern string describing this date format.
     */
    public String toPattern() {
        return pattern;
    }

toLocalizedPattern源码：

/**
     * Returns a localized pattern string describing this date format.
     *
     * @return a localized pattern string describing this date format.
     */
    public String toLocalizedPattern() {
        return translatePattern(pattern,
                                DateFormatSymbols.patternChars,
                                formatData.getLocalPatternChars());
    }

其中的translatePattern方法源码：

/**
     * Translates a pattern, mapping each character in the from string to the
     * corresponding character in the to string.
     *
     * @exception IllegalArgumentException if the given pattern is invalid
     */
    private String translatePattern(String pattern, String from, String to) {
        StringBuilder result = new StringBuilder();
        boolean inQuote = false;
        for (int i = 0; i < pattern.length(); ++i) {
            char c = pattern.charAt(i);
            if (inQuote) {
                if (c == '\'') {
                    inQuote = false;
                }
            }
            else {
                if (c == '\'') {
                    inQuote = true;
                } else if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) {
                    int ci = from.indexOf(c);
                    if (ci >= 0) {
                        // patternChars is longer than localPatternChars due
                        // to serialization compatibility. The pattern letters
                        // unsupported by localPatternChars pass through.
                        if (ci < to.length()) {
                            c = to.charAt(ci);
                        }
                    } else {
                        throw new IllegalArgumentException("Illegal pattern " +
                                                           " character '" +
                                                           c + "'");
                    }
                }
            }
            result.append(c);
        }
        if (inQuote) {
            throw new IllegalArgumentException("Unfinished quote in pattern");
        }
        return result.toString();
    }

emmmmm，因为有些类和属性不知道是怎么赋值的所以还是看不明白，但是如果我们要调用pattern的话toPattern应该是ok的。

applyPattern 将给定的模式字符串应用于此日期格式

参数：

public void applyPattern(String pattern)

代码：

SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd  hh:mm:ss ");
        System.out.println(sdf2.toPattern());
        sdf2.applyPattern("yyyy-MM-dd EEE");
        System.out.println(sdf2.toPattern());

结果图示：

parse 将String类型的时间转换为Date对象存储

参数：

public Date parse(String source) throws ParseException

代码：

SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd  hh:mm:ss ");
        System.out.println(sdf2.toPattern());
        Date date = sdf2.parse("2020-12-12  16:10:24 ");
        System.out.println(sdf2.toPattern());
        System.out.println(date);

结果图示：

在试验的时候发现，他有一点点格式不同，甚至少一个空格都会报错。这一点需要注意一下。