日期类

最新推荐文章于 2023-01-08 23:16:35 发布
最新推荐文章于 2023-01-08 23:16:35 发布
阅读量151 收藏
点赞数
分类专栏： c++语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_34967445/article/details/70217239
版权 
//#include <iostream>
//using namespace std;
//
//class Array
//{
//public:
//  Array(size_t size)
//  {
//      _array = (int*) malloc(sizeof(int)*size);
//  }
//  }
//
//  ~Array()
//  {
//      free(_array);
//      _array = NULL;
//  }
//private:
//  int * _array;
//};
//
//class Date
//{
//public:
//  Date(int year, int month, int day)
//  {
//      _year = year;
//      _month = month;
//      _day = day;
//  }
//
//  ~Date()
//  {
//      //cout<<"~Date()"<<endl;
//      //cout<<_year<<"-"<<_month<<endl;
//  }
//
//  void Display()
//  {
//      cout<<_year<<"-"<<_month<<"-"<<_day<<endl;
//  }
//
//  //bool Greater(const Date& d);
//  bool operator>(const Date& d)
//  {
//      if (_year > d._year)
//      {
//          return true;
//      }
//      else if (_year < d._year)
//      {
//          return false;
//      }
//      else
//      {
//          if (_month > d._month)
//          {
//              return true;
//          }
//          else if (_month < d._month)
//          {
//              return false;
//          }
//          else
//          {
//              return _day > d._day;
//          }
//      }
//  }
//  
//  // d1 = d2 = d3;
//
//  // d1 = d3;
//  // d1 = d1;
//  Date(const Date& d)
//  {
//      cout<<"Date(const Date&)"<<endl;
//      _year = d._year;
//      _month = d._month;
//      _day = d._day;
//  }
//
//  Date& operator=(const Date& d)
//  {
//      cout<<"operator="<<endl;
//      if (this != &d)
//      {
//          this->_year = d._year;
//          this->_month = d._month;
//          this->_day = d._day;
//      }
//
//      return *this;
//  }
//  /*void operator=(const Date& d)
//  {
//      cout<<"operator="<<endl;
//
//      this->_year = d._year;
//      this->_month = d._month;
//      this->_day = d._day;
//  }*/
//
//private:
//  int _year;
//  int _month;
//  int _day;
//};
//
////bool operator>(const Date& d1, const Date& d2)
////{
////    if (d1._year > d2._year)
////    {
////        return true;
////    }
////    else if (d1._year < d2._year)
    {
        return false;
    }
    else
    {
        if (d1._month > d2._month)
////        {
////            return true;
////        }
////        else if (d1._month < d2._month)
        {
            return false;
        }
        else
        {
            return d1._day > d2._day;
////        }
////    }
////}
//
//int main()
//{
//  // A 2,1 B 1,2
//  Date d1(2016, 1, 1);
//  Date d2(d1);
//  Date d3 = d1;
//  Date d4(2016, 12, 24);
//  d1 = d4;
//
//  //Date d3(2016,12,24);
//
//  // d1.operator(&d1, d2.operator=(&d2, d3));
//  //d1 = d2 = d3;
//  //d1 = d1;
//  //d2.Display();
//  //d3.Display();
//
//  // 可读性
//  //cout<<(d1 > d3)<<endl;
//  //cout<<d1.Greater(d3)<<endl;
//
//  return 0;
//}

#include <iostream>
#include <assert.h>
using namespace std;

class Date
{
public:
    Date(int year, int month, int day)
    {
        _year = year;
        _month = month;
        _day = day;

        assert(IsInvalid());
    }

    void Display()
    {
        cout<<_year<<"-"<<_month<<"-"<<_day<<endl;
    }

    bool IsInvalid()
    {
        if (_year >= 0
            && _month > 0 && _month < 13
            && _day > 0 && _day <= GetMonthDays(_year, _month))
        {
            return true;
        }

        return false;
    }

    bool IsLeapYear(int year)
    {
        if ((year%4 == 0 && year%100 != 0) || (year%400 == 0))
        {
            return true;
        }

        return false;
    }

    int GetMonthDays(int year, int month)
    {
        assert(month > 0 &&  month < 13);
        static int days[] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
        int day = days[month];

        if (month == 2 && IsLeapYear(year))
        {
            day += 1; 
        }

        return day;
    }

    // 拷贝构造、赋值运算符的重载、析构
    bool operator>(const Date& d)
    {
        //...
        return true;
    }
    bool operator<(const Date& d);
    bool operator>=(const Date& d);
    bool operator<=(const Date& d);
    // d1 == d2
    bool operator==(const Date& d)
    {
        return _year==d._year
            && _month==d._month
            && _day==d._day;
    }

    // ++d == d.operator++(&d)
    Date& operator++()   // 前置
    {
        int days = GetMonthDays(_year, _month);
        if (_day < days)
        {
            ++_day;
        }
        else if (_day == days)
        {
            if(_month == 12)
            {
                _day = 1;
                _month = 1;
                _year++;
            }
            else
            {
                _day = 1;
                _month++;
            }
        }
        else
        {
            // 防御式编程
            assert(false);
        }

        return *this;
    }

    // d++
    Date operator++(int) //后置
    {
        Date tmp(*this);

        //++(*this); // operator++(this);
        operator++();

        return tmp;
    }

    Date operator--()
    {
        if (_day > 1)
        {
            --_day;
        }
        else if (_day == 1)
        {
            if (_month == 1)
            {
                --_year;
                _month = 12;
                _day = GetMonthDays(_year, _month);
            }
            else
            {
                --_month;
                _day = GetMonthDays(_year, _month);
            }
        }

        return *this;
    }

    //d1 + -40;
    Date operator+(int day)
    {
        if (day < 0)
        {
            return *this - (-day);
        }

        Date tmp(*this);

        tmp._day += day;
        while(!tmp.IsInvalid())
        {
            tmp._day -= GetMonthDays(tmp._year, tmp._month);
            if (tmp._month == 12)
            {
                ++tmp._year;
                tmp._month = 1;
            }
            else
            {
                ++tmp._month;
            }
        }

        return tmp;
    }

    Date operator-(int day);

    Date& operator+=(int day)
    {
        *this = *this + day;
        return *this;
    }
    Date operator-=(int day);

    // d1 - d2
    int operator-(const Date& d)
    {
        size_t count = 0;
        int tag = 1;
        Date* max = this;
        Date* min = &d;
        if (*this < d)
        {
            max = &d;
            min = this;
            tag = -1;
        }

        while (*min != *max)
        {
            ++*min;
            ++count;
        }

        return count*tag;
    }

protected:
    int _year;
    int _month;
    int _day;
};

void main()
{
    Date d1(2017, 1, 12);
    Date d2(d1);

    d1.Display();
    d1 += 40;
    d1.Display();
    d1 += -40;
    d1.Display();
}


//class Complex
//{
//public:
//  Complex(double real = 0.0, double imge = 0.0)
//  {
//      _imge = imge;
//      _real = real;
//  }
//
//  // 复用
//  // c1 < c2
//  bool operator<(const Complex& c)
//  {
//      if (_real > c._real)
//      {
//          return true;
//      }
//      else if (_real < c._real)
//      {
//          return false;
//      }
//      else
//      {
//          return _imge > c._imge;
//      }
//  }
//
//  // c1 > c2
//  bool operator>(const Complex& c)
//  {
//      return !(*this < c || *this == c);
//  }
//
//  bool operator<=(const Complex& c)
//  {
//      return *this < c && *this == c;
//  }
//
//  bool operator>=(const Complex& c)
//  {
//      //return 
//  }
//
//  bool operator==(const Complex& c)
//  {
//      return _real == c._real && _imge == c._imge;
//  }
//
//  bool operator!=(const Complex& c);
//
//  // ++c->c.operator++(&c) call ___
//  Complex& operator++() // @Zoperator++C
//  {
//      ++_real;
//      return *this;
//  }
//
//  // 占位
//  // c++->c.operator++(&c, int()); // @Z@Zoperator++CI
//  Complex operator++(int)
//  {
//      Complex tmp(*this);
//      ++_real;
//      return tmp;
//  }
//
//  Complex operator--();
//  Complex operator--(int);
//
//  // + - * / += -= *= /=
//private:
//  double _real; // 实部
//  double _imge; // 虚部
//};
//
//int main()
//{
//  cout<<int()<<endl;
//
//  return 0;
//}

关于日期d1-d2所得差值的思路总结：
方法一：重载一个自增运算符，然后使用计数器来计算两个日期之间的差值。
int Date::operator-(const Date& d1)//两个天数相减（形如：d1-d2）
{
int flag = 1;
if (d1 > *this)
{
flag = -flag;
}
int count = 0;
Date minDate = *this;
Date maxDate = d1;
if (minDate > maxDate)
{
Swap(minDate, maxDate);
}
while (minDate != maxDate)
{
minDate++;
count++;
}
return flag * count;
}
第二种方法：
①当d1和d2是同年且同月的日期时：
结果为return d1._day - d2._day;
②当d1和d2是同年但不同月时：
则用d1当年的天数减去d2当年的天数。
③当d1和d2不同年时（比较复杂，需仔细分析）： 

int remainDays = 0;//小的日期在当年剩余的天数（到年底）
int dayInYear = 0;//大的日期在当年的天数
int d_value = 0;//两个日期年之间相差的天数
令变量minDate表示小的日期；
maxDate表示大的日期。
1）首先，求的remainDays的值（通过minDate）
当minDate日期为闰年时：remainDays = 366 - 小日期当年的天数
否则：remianDays = 365 - 小日期当年的天数
2）求的dayInYear的值（通过maxDate）
dayInYear = 大的日期在当年的天数
3）求的d_value的值（通过minDate和maxDate）：

所有代码： //Date.h

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
#include<cassert>
#include<ctime>
class Date
{
public :
    Date(int year = 1990, int month = 1, int day = 1);
    Date operator+(int day);
    Date& operator+=(int day);
    Date operator-(int day);
    Date& operator-=(int day);
    int operator-(const Date& d);
    Date& operator++();//前置++
    Date operator++(int);//后置++
    Date& operator--();//前置--
    Date operator--(int);//后置--
    void Dispaly();
    int Date::DayInYear(const Date& d);
    bool IsLeapYear(int year);
    friend void Swap(Date& d1, Date& d2);
    friend bool operator>(const Date& d1, const Date& d2);
    friend bool operator<(const Date& d1, const Date& d2);
    friend bool operator==(const Date&d1, const Date& d2);
    friend bool operator!=(const Date&d1, const Date& d2);

protected:
    bool IsValid(const Date& d)
    {
        if (d.m_year > 0 && (d.m_month > 0 && d.m_month < 13) && (d.m_day > 0 && d.m_day <= GetMonthDays(d.m_year, d.m_month)))
        {
            return true;
        }
        return false;
    }
    int GetMonthDays(int year, int month)
    {
        static int MonthDays[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
        if (month != 2)
        {
            return MonthDays[month];
        }
        else if (IsLeapYear(year))//是闰年
        {
            return 29;
        }
        else
            return 28;
    }
private :
    int m_year;
    int m_month;
    int m_day;
};

//Date.cpp

#include"Date1.h"
Date::Date(int year, int month, int day)//构造函数
:m_year(year)
, m_month(month)
, m_day(day)
{
    assert(IsValid(*this) != 0);
}
Date Date::operator+(int day)//某个日期加上一个天数（形如：d1+100）
{
    Date tmp(*this);
    tmp.m_day += day;
    while (tmp.m_day > GetMonthDays(tmp.m_year, tmp.m_month))
    {
        tmp.m_day -= GetMonthDays(tmp.m_year, tmp.m_month);
        if (tmp.m_month == 12)
        {
            tmp.m_year++;
            tmp.m_month = 1;
        }
        else
        {
            tmp.m_month++;
        }
    }
    return tmp;
}
Date& Date::operator+=(int day)//注意与operator+之间的区别（一个返回引用，一个返回值）
{
    *this = *this + day;
    return *this;
}
Date& Date::operator++()//前置++
{
    *this = *this + 1;
    return *this;
}
Date Date::operator++(int)//后置++
{
    Date tmp(*this);
    *this = *this + 1;
    return tmp;
}
Date Date::operator-(int day)//某个日期减去某个天数（形如：d1-100）
{
    Date tmp(*this);
    tmp.m_day -= day;
    while (!IsValid(tmp))
    {
        if (tmp.m_month == 1)
        {
            tmp.m_year--;
            tmp.m_month = 12;
        }
        else
        {
            tmp.m_month--;
        }
        tmp.m_day += GetMonthDays(tmp.m_year, tmp.m_month);
    }
    return tmp;
}
Date& Date::operator-=(int day)
{
    *this = *this - day;
    return *this;
}
bool operator>(const Date& d1, const Date& d2)//重载>
{
    if ((d1.m_year > d2.m_year) \
        || (d1.m_year == d2.m_year) && ((d1.m_month > d2.m_month) || ((d1.m_month == d2.m_month) && (d1.m_day > d2.m_day))))
    {
        return true;
    }
    return false;
}
bool operator<(const Date& d1, const Date& d2)//重载<
{
    return !((d1 > d2) || (d1 == d2));
}
bool operator!=(const Date&d1, const Date& d2)//重载！=
{
    return !(d1 == d2);
}
bool operator==(const Date&d1, const Date& d2)//重载==
{
    if ((d1.m_year == d2.m_year) && (d1.m_month == d2.m_month) && (d1.m_day == d2.m_day))
    {
        return true;
    }
    return false;
}
//
//int Date::operator-(const Date& d1)//两个天数相减（形如：d1-d2）
//{
//  int flag = 1;
//  if (d1 > *this)
//  {
//      flag = -flag;
//  }
//  int count = 0;
//  Date minDate = *this;
//  Date maxDate = d1;
//  if (minDate > maxDate)
//  {
//      Swap(minDate, maxDate);
//  }
//  while (minDate != maxDate)
//  {
//      minDate++;
//      count++;
//  }
//  return flag * count;
//  
//}
int Date::operator-(const Date& d1)//两个天数相减（形如：d1-d2）
{
    int flag = 1;
    if (d1 > *this)
    {
        flag = -flag;
    }
    int remainDays = 0;//小的日期在当年剩余的天数（到年底）
    int dayInYear = 0;//大的日期在当年的天数
    int d_value = 0;//两个日期的年之间相差的天数
    Date d2(*this);
    assert(IsValid(d1) != 0);//判断两个日期的有效性
    assert(IsValid(d2) != 0);
    if ((d1.m_year == d2.m_year) && (d1.m_month == d2.m_month))//当两个日期是同年且同月
    {
        return d1.m_day - d2.m_day;
    }
    else if (d1.m_year == d2.m_year)//当两个日期是同年但不同月
    {
        return (DayInYear(d1) - DayInYear(d2));
    }
    else//当两个日期不同年
    {
        Date minDate = d1;
        Date maxDate = d2;
        if (minDate > maxDate)
        {
            Swap(minDate, maxDate);
        }
        if (IsLeapYear(minDate.m_year))
        {
            remainDays = 366 - DayInYear(minDate);
        }
        else
        {
            remainDays = 365 - DayInYear(minDate);
        }
        dayInYear = DayInYear(maxDate);//获得大的日期在当年的天数
        //获取两个日期的年之间的差值
        for (int year = minDate.m_year + 1; year < maxDate.m_year; year++)
        {
            if (IsValid(year))
            {
                d_value += 366;
            }
            else
            {
                d_value += 365;
            }
        }
    }
    return flag * (d_value + remainDays + dayInYear);
}
Date& Date::operator--()//前置--
{
    *this = *this - 1;
    return *this;
}
Date Date::operator--(int)//后置--
{
    Date tmp(*this);
    *this = *this - 1;
    return tmp;
}
void Swap(Date& d1, Date& d2)//交换两个日期
{
    int tmp = d1.m_year;
    d1.m_year = d2.m_year;
    d2.m_year = tmp;
    tmp = d1.m_month;
    d1.m_month = d2.m_month;
    d2.m_month = tmp;
    tmp = d1.m_day;
    d1.m_day = d2.m_day;
    d2.m_day = tmp;
}
int Date::DayInYear(const Date& d)//获取当年的天数
{
    assert(IsValid(d) != 0);
    int days = d.m_day;
    for (int month = 1; month < d.m_month; month++)
    {
        days += GetMonthDays(d.m_year, month);
    }
    return days;
}
bool Date::IsLeapYear(int year)//判断闰年
{
    if (((year % 4 == 0) && (year % 100 != 0)) || (year % 100 == 0))
    {
        return true;
    }
    return false;
}
void Date::Dispaly()//输出日期
{
    cout << m_year << "-" << m_month << "-" << m_day << endl;
}
//测试
void Test()
{
    Date d1(2017, 2, 28);
    Date d2;
    d2 = d1 + 100;
    d2.Dispaly();
    d2 = d2 - 100;
    d2.Dispaly();
}
void Test2()
{
    Date d2(2017, 2, 28);
    Date d1(2015, 3, 8);
    int start = clock();
    int day = d1 - d2;
    int end = clock();
    cout << (end - start) << endl;
    cout << day << endl;
}
void Test3()
{
    Date d2(2017, 2, 28);
    d2.Dispaly();
    d2++.Dispaly();
    Date d1(2015, 3, 8);
    d1.Dispaly();
    ++d1;
    d1.Dispaly();
}
void Test4()
{
    Date d2(2017, 2, 28);
    d2.Dispaly();
    d2--.Dispaly();
    Date d1(2015, 3, 8);
    --d1;
    d1.Dispaly();
}
void Test5()
{
    Date d1(2015, 3, 8);
    d1 += 100;
    d1.Dispaly();
    d1 -= 100;
    d1.Dispaly();
}
void Test6()
{
    Date d1(2015, 3, 8);
    Date d2(2017, 2, 28);
    cout << (d1 < d2) << endl;
    cout << (d1 > d2) << endl;
    cout << (d1 == d2) << endl;
}
int main()
{
    //Test();
    //Test2();
    //Test3();
    //Test4();
    //Test5();
    Test6();
    return 0;
}
夏天的呆子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
类和对象实战 —— 日期类的实现
Edison's 小宇宙
10-24 1万+
日期类的实现
定义日期类
qq_52846711的博客
04-01 1698
定义一个类Date，包含三个私有属性年（year）、月（month）、日（day），均为整型数，其中：年份的合法取值范围为[1900,2000] ，月份合法取值范围为[1,12] ,日期合法取值范围为[1,31] 。 注意：不允许使用Java中和日期相关的类和方法，否则按0分处理。 要求：Date类结构如下图所示： 输入格式: 在一行内输入年月日的值，均为整型数，可以用一到多个空格或回车分隔。 输出格式: 当输入数据非法及输入日期不存在时，输出“Date Format is Wrong”； 当输入日期合法
时间日期类
BroRiver
01-08 2312
时间日期是每个程序都不可避免要操作到的数据类型。
JAVA日期类
weixin_47267628的博客
02-27 5504
日期类 第一代日期类 1.Date类：精确到毫秒，代表特定的瞬间 2.SimpleDateFormat类：格式和解析日期的类 SimpleDateFormat格式化和解析日期的具体类。它允许进行格式化【日期 --> 文本】，解析【文本 --> 日期】和规范化 3.SimpleDateFormat类需要掌握方法【format：格式形式 parse：转换解析【就是将字符串日期格式转成Date类】】 4.一般情况下Date类和SimpleDateFormat类一起搭配使用 Date和
java中的日期类
冲出仁川，走出马德里，故事还会再继续
09-22 4128
中包含了所有关于本地日期(LocalDate)、本地时间(LocalTime)、本地日期时间(LocalDateTime)、时区(ZonedDateTime)和持续时间(Duration)的类。类是一个抽象类，它为特定瞬间与一组诸如YEAR、MONTH、DAY_OF_MONTH、HOUR等日历字段之间的转换提供了一些方法，并为操作日历字段(如获得下星期的日期)提供了一些方法。通过API或源码，可以看出Date类的大部分方法已经过时，已被第二代日期类Calendar代替，剩下的Date类常见方法如下所示。
java时间日期类
m0_51779342的博客
09-13 3884
Date类封装当前的日期和时间，精确到毫秒，其中大部分方法都已过时。
Java常用的日期类
qq_44717657的博客
11-04 4027
Java使用Date、Calendar、DateFormat、SimpleDateFormat的一些分析及应用
日期类Date
热门推荐
wang386476890的专栏
04-11 1万+
Date类内部维护着一个long值，保存的是自1970-1-1至今的毫秒值。 废话不多说，先来热身下 // Date转String Date date = new Date(); SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); String var1 = formatter.format(date); System.out.println(var1); // 输出：2021-04-11 19:56:45
java的日期类
sober_chen的博客
03-29 5714
1、Date类 2、Calendar 3、LocalDate
java怎么创建日期类_java中的日期类Date
weixin_34649372的博客
02-13 4119
一、Java中的日期概述日期在Java中是一块非常复杂的内容，对于一个日期在不同的语言国别环境中，日期的国际化，日期和时间之间的转换，日期的加减运算，日期的展示格式都是非常复杂的问题。在Java中，操作日期主要涉及到一下几个类：1、java.util.Date类 Date 表示特定的瞬间，精确到毫秒。从 JDK 1.1 开始，应该使用 Calendar 类实现日期和时间字段之间转换，使用 Date...
日期类 c++
04-18
c++定义的日期类 可以实现年月日的加法,从某个时间加多少天，月，或者年 蓝桥杯，日期计算
一个简单的日期类的实现
03-30
简单的日期类，方便理解之前C++笔记中的一些默认函数和操作符重载，具体有获取天数，两个日期相减，实现了日期加天数，日期减天数，判断输入的日期是否合法，判断输入的日期是星期几，还有前置后置++(--)的重载等等...
java写的日期类Date
03-25
java学习时编写的日期类源码，供java入门学习使用，体现了java面向对象的思想
C++实现日期类（Date）
12-31
本文实例为大家分享了C++实现日期类的具体代码，供大家参考，具体内容如下 #include #include using namespace std; class Date { public: //构造函数 Date(int year = 1900, int month = 1, int day = 1) :_...
DateUtil Java日期类
07-20
Java日期类，可进行日期比较（可精确到分钟）、求几天前、几天后的日期
多态性与虚函数
火锅——博客
07-20 407
关于多态： 从系统的角度看，多态分为静态多态和动态多态。 静态多态是利用重载实现的，在程序编译时确定要调用的是哪个函数，因此静态多态又称为编译时多态。 动态多态和虚函数主要研究的是：当一个基类被继承为不同的派生类时，各派生类可以使用与基类成员相同的成员名，如果在运行时用同一个成员名调用类对象的成员，那么会调用哪一个对象的成员？ 也就是，通过继承而产生了相关的不同派生类，与基
时间复杂度和空间复杂度
火锅——博客
04-17 369
时间复杂度： 一般情况下，算法中基本操作重复执行的次数是问题规模n的某个函数f(n)，进而分析f(n)随n的变化情况并确定T(n)的数量级。这里用”O”来表示数量级，给出算法的时间复杂度。 T(n)=O(f(n)); 它表示随着问题规模的n的增大，算法的执行时间的增长率和f(n)的增长率相同，这称作算法的渐进时间复杂度，简称时间复杂度。而我们一
【C++常见面试题：实现一个string 类】-深拷贝&浅拷贝&string类
火锅——博客
07-20 337
面试中string类的正确写法 http://coolshell.cn/articles/10478.html String的实现： //备注： 只在构造函数里面调用new char[],只在析构函数里面调用delete[]; 每个函数都只有一两行代码，没有条件判断；#include<iostream> #pragma warning(disable :4996) using namesp
如何定义一个只能在栈/堆上生成对象的类
火锅——博客
07-15 326
如何定义一个只能在栈上生成对象的类？（考察对C++语法的理解及应用） 分析：对象可以在栈上生成也可以由我们在堆上new出来。要想只在栈上生成对象而不能在堆上生成对象在类外是无法完成的，因此我们必须从类的内部入手。 我们知道，类对象的构造是由构造函数完成的，如果我们把构造函数声明为保护的，使得不能在类外调用构造函数，这样的话就不能在类外new出对象了，但同时也不能在类外定义对象了。为此我们可以在类
java 日期类格式输出
最新发布
06-12
Java 日期类可以使用 SimpleDateFormat 类来进行格式化输出。以下是一个示例代码，将当前日期格式化为 "yyyy-MM-dd HH:mm:ss" 的字符串： ``` import java.text.SimpleDateFormat; import java.util.Date; public ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值