java日期类型定义

㈠ javaWeb的实体类定义中一般日期定义成什么格式

前后端交流数据,我建议的是,大家都统一成时间戳.
如果是string,或者Date,不好统一.
每个前端的日期格式不一样,可能A页面传过来的是2020-10-10 12:00 GTM+8之类的.
B页面传过来的又是2020/10/10 12:00,每个人都特么不一样.
现在很多程序员都是前后端一体开发,自己写的可能你还会注意统一一下.但如果不是同一个人写,有模块之间调用,很麻烦的.你转换器到底怎么写才合适?
所以我建议用时间戳,long类型的,这个大家都没有异议,世界统一啊.
我不管你前端怎么显示,怎么定义,但你要传给我后端的时候,我只要时间戳,而我内部我怎么定义,怎么用,那是我的事,我传给你前端时,也只会给你时间戳.
这样的话,你自己开发没问题,跟其他人对接也不会有问题.
而实体类你直接定义成Date就可以.前端传值一个long类型的时间戳,是可以直接装入到Date类型的,这种spring是有默认转换器的,都不用操心.
而Date也可以直接存入数据库中的Date,Time,TimeStamp等时间类型的.也不需要转换.
综上,总结下:数据库是时间格式的(Date,Time,TimeStamp),实体是Date格式的.前端传过来时间戳,Controller里面直接写实体就行.如果写的实体里一个字段,那也用long,然后自己new Date(long),总之跨了不同的范围,就统一成long时间戳.

㈡ java中如何定义日期型数据

可能是你没导入包的原因，解决方法，两种：
1，在文件顶部导入包：import java.util.Date;

2.声明时写全：java.util.Date birthday;

㈢ java里怎么自定义一个日期！

在旧版本的jdk中，Java的日期/时间类的定义并不一致，在java.util和java.sql的包中都有日期类，此外用于格式化和解析的类在java.text.SimpleDateFormat包中定义。

java.util.Date是在除了SQL语句的情况下面使用的。
java.sql.Date是针对SQL语句使用的，它只包含日期而没有时间部分

它们都有getTime方法返回毫秒数，自然就可以直接构建。java.util.Date 是 java.sql.Date 的父类，前者是常用的表示时间的类，我们通常格式化或者得到当前时间都是用他，后者之后在读写数据库的时候用他，因为PreparedStament的setDate()的第2参数和ResultSet的getDate()方法的第2个参数都是java.sql.Date。

java.sql.Date转为java.util.Date
java.sql.Date date=new java.sql.Date();
java.util.Date d=new java.util.Date (date.getTime());

java.util.Date转为java.sql.Date
java.util.Date utilDate=new Date();
java.sql.Date sqlDate=new java.sql.Date(utilDate.getTime());
java.util.Date utilDate=new Date();
java.sql.Date sqlDate=new java.sql.Date(utilDate.getTime());
java.sql.Time sTime=new java.sql.Time(utilDate.getTime());
java.sql.Timestamp stp=new java.sql.Timestamp(utilDate.getTime());

这里所有时间日期都可以被SimpleDateFormat格式化format()
SimpleDateFormat f=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
f.format(stp);
f.format(sTime);
f.format(sqlDate);
f.format(utilDate)
java.sql.Date sqlDate=java.sql.Date.valueOf(" 2005-12-12");
utilDate=new java.util.Date(sqlDate.getTime());

另类取得年月日的方法：
import java.text.SimpleDateFormat;
import java.util.*;
java.util.Date date = new java.util.Date();
//如果希望得到YYYYMMDD的格式SimpleDateFormat
sy1=new SimpleDateFormat("yyyyMMDD");
String dateFormat=sy1.format(date);
//如果希望分开得到年，月，日SimpleDateFormat
sy=new SimpleDateFormat("yyyy");
SimpleDateFormat sm=new SimpleDateFormat("MM");
SimpleDateFormat sd=new SimpleDateFormat("dd");
String syear=sy.format(date);
String smon=sm.format(date);
String sday=sd.format(date);

注意啦！！！在JAVA 8中有了日期的新的表示方式。在java.time包中。

Java 8日期/时间（ Date/Time）API是开发人员最受追捧的变化之一，Java从一开始就没有对日期时间处理的一致性方法，因此日期/时间API也是除Java核心API以外另一项倍受欢迎的内容。

为什么我们需要新的Java日期/时间API？

在开始研究Java 8日期/时间API之前，让我们先来看一下为什么我们需要这样一个新的API。在Java中，现有的与日期和时间相关的类存在诸多问题，其中有：

1. Java的日期/时间类的定义并不一致，在java.util和java.sql的包中都有日期类，此外用于格式化和解析的类在java.text包中定义。

2. java.util.Date同时包含日期和时间，而java.sql.Date仅包含日期，将其纳入java.sql包并不合理。另外这两个类都有相同的名字，这本身就是一个非常糟糕的设计。

3. 对于时间、时间戳、格式化以及解析，并没有一些明确定义的类。对于格式化和解析的需求，我们有java.text.DateFormat抽象类，但通常情况下，SimpleDateFormat类被用于此类需求。

4. 所有的日期类都是可变的，因此他们都不是线程安全的，这是Java日期类最大的问题之一。

5. 日期类并不提供国际化，没有时区支持，因此Java引入了java.util.Calendar java.util.TimeZone类，但他们同样存在上述所有的问题。

在现有的日期和日历类中定义的方法还存在一些其他的问题，但以上问题已经很清晰地表明：Java需要一个健壮的日期/时间类。这也是为什么Joda Time在Java日期/时间需求中扮演了高质量替换的重要角色。

Java 8日期/时间API是JSR-310的实现，它的实现目标是克服旧的日期时间实现中所有的缺陷，新的日期/时间API的一些设计原则是：

1. 不变性：新的日期/时间API中，所有的类都是不可变的，这对多线程环境有好处。

2. 关注点分离：新的API将人可读的日期时间和机器时间（unix timestamp）明确分离，它为日期（Date）、时间（Time）、日期时间（DateTime）、时间戳（unix timestamp）以及时区定义了不同的类。

3. 清晰：在所有的类中，方法都被明确定义用以完成相同的行为。举个例子，要拿到当前实例我们可以使用now()方法，在所有的类中都定义了format()和parse()方法，而不是像以前那样专门有一个独立的类。为了更好的处理问题，所有的类都使用了工厂模式和策略模式，一旦你使用了其中某个类的方法，与其他类协同工作并不困难。

4. 实用操作：所有新的日期/时间API类都实现了一系列方法用以完成通用的任务，如：加、减、格式化、解析、从日期/时间中提取单独部分，等等。

5. 可扩展性：新的日期/时间API是工作在ISO-8601日历系统上的，但我们也可以将其应用在非IOS的日历上。

Java日期/时间API包含以下相应的包。

1. java.time包：这是新的Java日期/时间API的基础包，所有的主要基础类都是这个包的一部分，如：LocalDate, LocalTime, LocalDateTime, Instant, Period, Duration等等。所有这些类都是不可变的和线程安全的，在绝大多数情况下，这些类能够有效地处理一些公共的需求。

2. java.time.chrono包：这个包为非ISO的日历系统定义了一些泛化的API，我们可以扩展AbstractChronology类来创建自己的日历系统。

3. java.time.format包：这个包包含能够格式化和解析日期时间对象的类，在绝大多数情况下，我们不应该直接使用它们，因为java.time包中相应的类已经提供了格式化和解析的方法。

4. java.time.temporal包：这个包包含一些时态对象，我们可以用其找出关于日期/时间对象的某个特定日期或时间，比如说，可以找到某月的第一天或最后一天。你可以非常容易地认出这些方法，因为它们都具有“withXXX”的格式。

5. java.time.zone包：这个包包含支持不同时区以及相关规则的类。

新旧API的对比图：

publicclassTimeIntroction{
publicstaticvoidtestClock()throwsInterruptedException{
//时钟提供给我们用于访问某个特定时区的瞬时时间、日期和时间的。
Clockc1=Clock.systemUTC();//系统默认UTC时钟（当前瞬时时间System.currentTimeMillis()）
System.out.println(c1.millis());//每次调用将返回当前瞬时时间（UTC）
Clockc2=Clock.systemDefaultZone();//系统默认时区时钟（当前瞬时时间）
Clockc31=Clock.system(ZoneId.of("Europe/Paris"));//巴黎时区
System.out.println(c31.millis());//每次调用将返回当前瞬时时间（UTC）
Clockc32=Clock.system(ZoneId.of("Asia/Shanghai"));//上海时区
System.out.println(c32.millis());//每次调用将返回当前瞬时时间（UTC）
Clockc4=Clock.fixed(Instant.now(),ZoneId.of("Asia/Shanghai"));//固定上海时区时钟
System.out.println(c4.millis());
Thread.sleep(1000);
System.out.println(c4.millis());//不变即时钟时钟在那一个点不动
Clockc5=Clock.offset(c1,Duration.ofSeconds(2));//相对于系统默认时钟两秒的时钟
System.out.println(c1.millis());
System.out.println(c5.millis());
}
publicstaticvoidtestInstant(){
//瞬时时间相当于以前的System.currentTimeMillis()
Instantinstant1=Instant.now();
System.out.println(instant1.getEpochSecond());//精确到秒得到相对于1970-01-0100:00:00UTC的一个时间
System.out.println(instant1.toEpochMilli());//精确到毫秒
Clockclock1=Clock.systemUTC();//获取系统UTC默认时钟
Instantinstant2=Instant.now(clock1);//得到时钟的瞬时时间
System.out.println(instant2.toEpochMilli());
Clockclock2=Clock.fixed(instant1,ZoneId.systemDefault());//固定瞬时时间时钟
Instantinstant3=Instant.now(clock2);//得到时钟的瞬时时间
System.out.println(instant3.toEpochMilli());//equalsinstant1
}
(){
//使用默认时区时钟瞬时时间创建Clock.systemDefaultZone()-->即相对于ZoneId.systemDefault()默认时区
LocalDateTimenow=LocalDateTime.now();
System.out.println(now);
//自定义时区
LocalDateTimenow2=LocalDateTime.now(ZoneId.of("Europe/Paris"));
System.out.println(now2);//会以相应的时区显示日期
//自定义时钟
Clockclock=Clock.system(ZoneId.of("Asia/Dhaka"));
LocalDateTimenow3=LocalDateTime.now(clock);
System.out.println(now3);//会以相应的时区显示日期
//不需要写什么相对时间如java.util.Date年是相对于1900月是从0开始
//2013-12-3123:59
LocalDateTimed1=LocalDateTime.of(2013,12,31,23,59);
//年月日时分秒纳秒
LocalDateTimed2=LocalDateTime.of(2013,12,31,23,59,59,11);
//使用瞬时时间+时区
Instantinstant=Instant.now();
LocalDateTimed3=LocalDateTime.ofInstant(Instant.now(),ZoneId.systemDefault());
System.out.println(d3);
//解析String--->LocalDateTime
LocalDateTimed4=LocalDateTime.parse("2013-12-31T23:59");
System.out.println(d4);
LocalDateTimed5=LocalDateTime.parse("2013-12-31T23:59:59.999");//999毫秒等价于999000000纳秒
System.out.println(d5);
//使用DateTimeFormatterAPI解析和格式化
DateTimeFormatterformatter=DateTimeFormatter.ofPattern("yyyy/MM/ddHH:mm:ss");
LocalDateTimed6=LocalDateTime.parse("2013/12/3123:59:59",formatter);
System.out.println(formatter.format(d6));
//时间获取
System.out.println(d6.getYear());
System.out.println(d6.getMonth());
System.out.println(d6.getDayOfYear());
System.out.println(d6.getDayOfMonth());
System.out.println(d6.getDayOfWeek());
System.out.println(d6.getHour());
System.out.println(d6.getMinute());
System.out.println(d6.getSecond());
System.out.println(d6.getNano());
//时间增减
LocalDateTimed7=d6.minusDays(1);
LocalDateTimed8=d7.plus(1,IsoFields.QUARTER_YEARS);
//LocalDate即年月日无时分秒
//LocalTime即时分秒无年月日
//API和LocalDateTime类似就不演示了
}
(){
//即带有时区的date-time存储纳秒、时区和时差（避免与本地date-time歧义）。
//API和LocalDateTime类似，只是多了时差(如2013-12-20T10:35:50.711+08:00[Asia/Shanghai])
ZonedDateTimenow=ZonedDateTime.now();
System.out.println(now);
ZonedDateTimenow2=ZonedDateTime.now(ZoneId.of("Europe/Paris"));
System.out.println(now2);
//其他的用法也是类似的就不介绍了
ZonedDateTimez1=ZonedDateTime.parse("2013-12-31T23:59:59Z[Europe/Paris]");
System.out.println(z1);
}
publicstaticvoidtestDuration(){
//表示两个瞬时时间的时间段
Durationd1=Duration.between(Instant.ofEpochMilli(System.currentTimeMillis()-12323123),Instant.now());
//得到相应的时差
System.out.println(d1.toDays());
System.out.println(d1.toHours());
System.out.println(d1.toMinutes());
System.out.println(d1.toMillis());
System.out.println(d1.toNanos());
//1天时差类似的还有如ofHours()
Durationd2=Duration.ofDays(1);
System.out.println(d2.toDays());
}
(){
//提供对java.util.Calendar的替换，提供对年历系统的支持
Chronologyc=HijrahChronology.INSTANCE;
ChronoLocalDateTimed=c.localDateTime(LocalDateTime.now());
System.out.println(d);
}
/**
*新旧日期转换
*/
(){
Instantinstant=newDate().toInstant();
Datedate=Date.from(instant);
System.out.println(instant);
System.out.println(date);
}
publicstaticvoidmain(String[]args)throwsInterruptedException{
testClock();
testInstant();
testLocalDateTime();
testZonedDateTime();
testDuration();
testChronology();
testNewOldDateConversion();
}
}

㈣ 用Java做的 定义一个时间类型（类名MyTime） 定义名为Mytime类，其中应有三个整形

packageDemo;
publicclassMyTime{
privateinthour,minute,second;
publicMyTime(inthour,intminute,intsecond){
super();
this.hour=hour;
this.minute=minute;
this.second=second;
}
publicvoidaddSecond(intsec){
second+=sec;
}
publicvoidaddMinute(intmin){
minute+=min;
}
publicvoidaddHour(inthou){
hour+=hou;
}
publicvoidsubSecond(intsec){
second-=sec;
}
publicvoidsubMinute(intmin){
minute-=min;
}
publicvoidsubHour(inthou){
hour-=hou;
}
publicvoiddiaplay(){
System.out.println(hour+"时"+minute+"分"+second+"秒");
}
}

㈤ java程序定义一个日期类

正好我这有一个日期的工具类，你参考一下。我是直接黏贴进来的，看起来感觉有点乱，你复制后放到eclipse里看就整齐了。
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

import org.junit.Test;

/**
* @author Administrator
* 各种日期、时间转换的示例总结：
*/
public class DateFormatUtil {
/**
* 将当前时间转换成指定格式的日期形式的字符串输出
* */
@Test
public void dateToStr(){
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String dateString = sdf.format(new Date());
System.out.println(dateString);
}

/**
* 将给定时间格式的字符串，解析成Date输出
* @throws ParseException
* */
@Test
public void strToDate() throws ParseException{
String str = "201012241002";//yyyyMMddhhmm
SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddhhmm");
Date date = sdf.parse(str);
System.out.println(date);
}
/**
* 字符串，格式化 为指定字符串
* @throws ParseException
*/
@Test
public void formatstr()throws ParseException{
String str = "20170314155847";//yyyyMMddhhmm
SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String str2 = sdf2.format(sdf.parse(str));
System.out.println(str2);
}

/**
* 操作时间：当前时间减去一天，一月，一年
*/
@Test
public void oprateDate(){
Date date = new Date();//获取当前时间
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
// calendar.add(Calendar.YEAR, -1);//当前时间减去一年，即一年前的时间
// calendar.add(Calendar.MONTH, -1);//当前时间前去一个月，即一个月前的时间
calendar.add(Calendar.DATE, -1);
Date time = calendar.getTime();//获取一年前的时间，或者一个月前的时间
System.out.println(time);
}

}

㈥ 用java定义一个日期类，急！！！

class MyDate{
public int year,month,day;
public MyDate(MyDate date){
year=date.year;
month=date.month;
day=date.day;
}
public boolean isLeapYear(){
return (((year%4==0)&&(year%100!=0))||(year%400==0));
}
public MyDate(int y,int m,int d){
year=y;
month=m;
day=d;
if(((month==1)||(month==3)||(month==5)||(month==7)||(month==8)||(month==10)||(month==12))&&((day<1)||(day>31))) System.out.println("wrong date");
if(((month==4)||(month==6)||(month==9)||(month==11))&&((day<1)||(day>30))) System.out.println("wrong date");
if(month==2){
if(isLeapYear()&&((day<1)||(day>29))) System.out.println("wrong date");
if(!isLeapYear()&&((day<1)||(day>28))) System.out.println("wrong date");
}
}
public boolean equal(MyDate date){
return (year==date.year && month==date.month && day==date.day);
}
public void incrementDay(){
if((month==1)||(month==3)||(month==5)||(month==7)||(month==8)||(month==10)){
int flag=0;
if(day==31){month+=1;flag=1;}
if((day<=30)&&(day>=1)){day+=1;}
if(flag==1) day=1;
flag=0;
}
if((month==4)||(month==6)||(month==9)||(month==11)){
int flag=0;
if(day==30){month+=1;flag=1;}
if((day<=29)&&(day>=1)){day+=1;}
if(flag==1) day=1;
flag=0;
}
if(month==12){
int flag=0;
if(day==31){year+=1;month=1;flag=1;}
if((day>=1)&&(day<=30)){day+=1;}
if(flag==1) day=1;
flag=0;
}
if(month==2){
int flag=0;
if(isLeapYear()){
if(day==29){month+=1;flag=1;}
if((day<=28)&&(day>=1)){day+=1;}
if(flag==1) day=1;
flag=0;
}
else{
if(day==28){month+=1;flag=1;}
if((day<=27)&&(day>=1)){day+=1;}
if(flag==1) day=1;
flag=0;
}
}
}
public int getYear(){
return year;
}
public int getMonth(){
return month;
}
public int getDay(){
return day;
}
public String toString(){
return (year+"-"+month+"-"+day);
}
}
public class Mytest{
public static void main(String[] test){
MyDate date1=new MyDate(2000,2,28);
MyDate date2=new MyDate(2006,12,31);
MyDate date3=new MyDate(date2);
System.out.println(date3.equal(date2));
date1.incrementDay();
System.out.println(date1.getYear()+" "+date1.getMonth()+" "+date1.getDay());
System.out.println(date1.toString());
date2.incrementDay();
System.out.println(date2.getYear()+" "+date2.getMonth()+" "+date2.getDay());
System.out.println(date2.toString());
}
}

㈦ Java 定义一个Date类

设计一个日期类MyDate,包含一个构造方法，3个私有成员变量year、month、day以及它们相应的setter和getter方法，再加上一个转换成“XXXX年XX月XX日”格式字符串的方法toString。...

设计一个日期类MyDate,包含一个构造方法，3个私有成员变量year、month、day以及它们相应的setter和getter方法，再加上一个转换成“XXXX年XX月XX日”格式字符串的方法toString。

㈧ java Date类型。

Data类型是日期类型，通常是为了获取某些特定的日期或者转换日期的格式为字符串。举例：
Date date = new Date();//定义一个当前日期，此时输出就是日期类型
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//创建格式日期类型
String str = sdf.format(date);//对创建的日期进行格式化输出。此时输出就是字符串日期类型
输出结果：2015--6-30 19:17:32。

㈨ 用Java做的 定义一个时间类型（类名MyTime）

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.TimeZone;

public class MyTime {
public String hour;
public String minute;
public String second;

public MyTime() {
hour = "00";
minute = "00";
second = "00";
}

public MyTime(String hour, String minute, String second) {
this.hour = hour;
this.minute = minute;
this.second = second;
}

public MyTime TimeAdd(MyTime t) {
SimpleDateFormat format = new SimpleDateFormat("HH:mm:ss");// 定义格式
String str1 = t.toString();// 时间字符串
String str2 = this.toString();// 时间字符串
Date date1 =null;
Date date2 =null;
try {// 构造时间字符串
date1= format.parse(str1);
} catch (ParseException e) {
date1 = new Date();//如果出错为00:00:00
date1.setHours(0);
date1.setMinutes(0);
date1.setSeconds(0);
}
try {
date2= format.parse(str2);
} catch (ParseException e) {// 构造时间字符串
date2 = new Date();//如果出错为00:00:00
date2.setHours(0);
date2.setMinutes(0);
date2.setSeconds(0);
}
TimeZone tz = TimeZone.getTimeZone("+0800");
Calendar c1=Calendar.getInstance();
c1.setTimeZone(tz);

c1.setTime(date1);//转成Calendar类型方便计算
Calendar c2=Calendar.getInstance();
c2.setTimeZone(tz);
c2.setTime(date2);//转成Calendar类型方便计算
String str= format.format(c1.getTimeInMillis()+c2.getTimeInMillis());

System.out.println(str);
return StrToTime(str);//返回时间
}

public MyTime StrToTime(String str) {
SimpleDateFormat format = new SimpleDateFormat("HH:mm:ss");
try {
format.parse(str);
return new MyTime(str.substring(0, 2), str.substring(2, 4), str
.substring(4, 6));
} catch (Exception e) {
return new MyTime("00", "00", "00");
}

}

public String toString() {
return hour + ":" + minute + ":" + second;
}

public static void main(String[] args) {
MyTime myTime=new MyTime("01","05","05");
MyTime myTime2=new MyTime("02","02","01");
myTime.TimeAdd(myTime2);
}
}
相加方法小时有问题，是时区问题，不影响

㈩ java里表示时间的类型是什么

java.util.Date,和java.util.Calendar 是 java 的主要的时间类型

Java.util.Calendar类是java.util.Date类的一个更加深入，更加全面的替代。Java.util.Calendar类支持java.util.Date的所有功能，此外，Calendar还引入了多语言，多区域的特性，可以根据需要获取不同区域，不同时区的时间，Calendar还增加了比Date更加方便和快捷的许多操作，如获取一年当中的第几个星期，各个月的天数等便捷的方法。

Java.util.Calendar区别与java.util.Date的几个地方也需要注意一下：首先，Calendar增加了毫秒的时间段，通过它可以获取时间点的毫秒值，而java.util.Date只是精确到秒。其次，Calendar过去年的时候是当前年份比如：2010，而Date获取年份的时获取到的是当前年份-1900的一个值（2010-1900=110，因此，你调用getYear后过去的值就是110）。最后Calendar是一个抽象类，之所以能够实例化，是因为此处的Calendar充当了一个类似于工厂的作用，在getInstance方法中实例化了Calendar子类GregorianCalendar，并把它返回给客户使用。

此外,还有 java.sql.Date, java.sql.Time, java.sql.Timestamp