Java编写日期代码 在编程中日期的编写

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

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

我们提供的服务有：网站设计、成都网站建设、微信公众号开发、网站优化、网站认证、璧山ssl等。为上千家企事业单位解决了网站和推广的问题。提供周到的售前咨询和贴心的售后服务，是有科学管理、有技术的璧山网站制作公司

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的对比图：

新API的示例代码：

public class TimeIntroduction {

public static void testClock() throws InterruptedException {

//时钟提供给我们用于访问某个特定 时区的 瞬时时间、日期 和 时间的。  

Clock c1 = Clock.systemUTC(); //系统默认UTC时钟（当前瞬时时间 System.currentTimeMillis()）  

System.out.println(c1.millis()); //每次调用将返回当前瞬时时间（UTC）  

Clock c2 = Clock.systemDefaultZone(); //系统默认时区时钟（当前瞬时时间）  

Clock c31 = Clock.system(ZoneId.of("Europe/Paris")); //巴黎时区  

System.out.println(c31.millis()); //每次调用将返回当前瞬时时间（UTC）  

Clock c32 = Clock.system(ZoneId.of("Asia/Shanghai"));//上海时区  

System.out.println(c32.millis());//每次调用将返回当前瞬时时间（UTC）  

Clock c4 = Clock.fixed(Instant.now(), ZoneId.of("Asia/Shanghai"));//固定上海时区时钟  

System.out.println(c4.millis());

Thread.sleep(1000);

System.out.println(c4.millis()); //不变 即时钟时钟在那一个点不动  

Clock c5 = Clock.offset(c1, Duration.ofSeconds(2)); //相对于系统默认时钟两秒的时钟  

System.out.println(c1.millis());

System.out.println(c5.millis());

}

public static void testInstant() {

//瞬时时间 相当于以前的System.currentTimeMillis()  

Instant instant1 = Instant.now();

System.out.println(instant1.getEpochSecond());//精确到秒 得到相对于1970-01-01 00:00:00 UTC的一个时间  

System.out.println(instant1.toEpochMilli()); //精确到毫秒  

Clock clock1 = Clock.systemUTC(); //获取系统UTC默认时钟  

Instant instant2 = Instant.now(clock1);//得到时钟的瞬时时间  

System.out.println(instant2.toEpochMilli());

Clock clock2 = Clock.fixed(instant1, ZoneId.systemDefault()); //固定瞬时时间时钟  

Instant instant3 = Instant.now(clock2);//得到时钟的瞬时时间  

System.out.println(instant3.toEpochMilli());//equals instant1  

}

public static void testLocalDateTime() {

//使用默认时区时钟瞬时时间创建 Clock.systemDefaultZone() --即相对于 ZoneId.systemDefault()默认时区  

LocalDateTime now = LocalDateTime.now();

System.out.println(now);

//自定义时区  

LocalDateTime now2 = LocalDateTime.now(ZoneId.of("Europe/Paris"));

System.out.println(now2);//会以相应的时区显示日期  

//自定义时钟  

Clock clock = Clock.system(ZoneId.of("Asia/Dhaka"));

LocalDateTime now3 = LocalDateTime.now(clock);

System.out.println(now3);//会以相应的时区显示日期  

//不需要写什么相对时间 如java.util.Date 年是相对于1900 月是从0开始  

//2013-12-31 23:59  

LocalDateTime d1 = LocalDateTime.of(2013, 12, 31, 23, 59);

//年月日 时分秒 纳秒  

LocalDateTime d2 = LocalDateTime.of(2013, 12, 31, 23, 59, 59, 11);

//使用瞬时时间 + 时区  

Instant instant = Instant.now();

LocalDateTime d3 = LocalDateTime.ofInstant(Instant.now(), ZoneId.systemDefault());

System.out.println(d3);

//解析String---LocalDateTime  

LocalDateTime d4 = LocalDateTime.parse("2013-12-31T23:59");

System.out.println(d4);

LocalDateTime d5 = LocalDateTime.parse("2013-12-31T23:59:59.999");//999毫秒 等价于999000000纳秒  

System.out.println(d5);

//使用DateTimeFormatter API 解析 和 格式化  

DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");

LocalDateTime d6 = LocalDateTime.parse("2013/12/31 23: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());

//时间增减  

LocalDateTime d7 = d6.minusDays(1);

LocalDateTime d8 = d7.plus(1, IsoFields.QUARTER_YEARS);

//LocalDate 即年月日 无时分秒  

//LocalTime即时分秒 无年月日  

//API和LocalDateTime类似就不演示了  

}

public static void testZonedDateTime() {

//即带有时区的date-time 存储纳秒、时区和时差（避免与本地date-time歧义）。  

//API和LocalDateTime类似，只是多了时差(如2013-12-20T10:35:50.711+08:00[Asia/Shanghai])  

ZonedDateTime now = ZonedDateTime.now();

System.out.println(now);

ZonedDateTime now2 = ZonedDateTime.now(ZoneId.of("Europe/Paris"));

System.out.println(now2);

//其他的用法也是类似的 就不介绍了  

ZonedDateTime z1 = ZonedDateTime.parse("2013-12-31T23:59:59Z[Europe/Paris]");

System.out.println(z1);

}

public static void testDuration() {

//表示两个瞬时时间的时间段  

Duration d1 = 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()  

Duration d2 = Duration.ofDays(1);

System.out.println(d2.toDays());

}

public static void testChronology() {

//提供对java.util.Calendar的替换，提供对年历系统的支持  

Chronology c = HijrahChronology.INSTANCE;

ChronoLocalDateTime d = c.localDateTime(LocalDateTime.now());

System.out.println(d);

}

/**

* 新旧日期转换

*/

public static void testNewOldDateConversion(){

Instant instant=new Date().toInstant();

Date date=Date.from(instant);

System.out.println(instant);

System.out.println(date);

}

public static void main(String[] args) throws InterruptedException {

testClock();

testInstant();

testLocalDateTime();

testZonedDateTime();

testDuration();

testChronology();

testNewOldDateConversion();

}

}

JAVA日历代码，怎么做？

import java.util.Date;

import java.util.Calendar;

import java.text.DateFormat;

import java.text.SimpleDateFormat;

import java.text.ParseException;

import java.awt.Color;

import java.awt.Font;

import java.awt.Point;

import java.awt.Dimension;

import java.awt.BorderLayout;

import java.awt.FlowLayout;

import java.awt.GridLayout;

import java.awt.Cursor;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import javax.swing.JButton;

import javax.swing.JDialog;

import javax.swing.JPanel;

import javax.swing.JLabel;

import javax.swing.JSpinner;

import javax.swing.SpinnerNumberModel;

import javax.swing.SwingUtilities;

import javax.swing.SwingConstants;

import javax.swing.event.ChangeListener;

import javax.swing.event.ChangeEvent;

import javax.swing.border.LineBorder;

/**

* @company:NEUSOFT

* @Title:日期选择控件

* @Description:在原有基础上修改了以下内容：

* 1. 将容器由Frame改为了Dialog，以便在基于对话框的程序中也能够使用

* 2. 将最小日期由1980改为了1950，考虑到目前球员的出生日期可能早于1980年

* 3. 将初始显示格式设置为 yyyy年MM月dd日 格式，原有的小时去掉了，不适合于出生日期字段

*/

public class DateChooserJButton extends JButton {

private DateChooser dateChooser = null;

private String preLabel = "";

public DateChooserJButton() {

this(getNowDate());

}

public DateChooserJButton(SimpleDateFormat df, String dateString) {

this();

setText(df, dateString);

}

public DateChooserJButton(Date date) {

this("", date);

}

public DateChooserJButton(String preLabel, Date date) {

if (preLabel != null)

this.preLabel = preLabel;

setDate(date);

setBorder(null);

setCursor(new Cursor(Cursor.HAND_CURSOR));

addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

if (dateChooser == null)

dateChooser = new DateChooser();

Point p = getLocationOnScreen();

p.y = p.y + 30;

dateChooser.showDateChooser(p);

}

});

}

private static Date getNowDate() {

return Calendar.getInstance().getTime();

}

private static SimpleDateFormat getDefaultDateFormat() {

return new SimpleDateFormat("yyyy年MM月dd日");

}

// 覆盖父类的方法

public void setText(String s) {

Date date;

try {

date = getDefaultDateFormat().parse(s);

} catch (ParseException e) {

date = getNowDate();

}

setDate(date);

}

public void setText(SimpleDateFormat df, String s) {

Date date;

try {

date = df.parse(s);

} catch (ParseException e) {

date = getNowDate();

}

setDate(date);

}

public void setDate(Date date) {

super.setText(preLabel + getDefaultDateFormat().format(date));

}

public Date getDate() {

String dateString = this.getText().substring(preLabel.length());

try {

return getDefaultDateFormat().parse(dateString);

} catch (ParseException e) {

return getNowDate();

}

}

public String getDateString()

{

Date birth =getDate();

DateFormat formatDate = new SimpleDateFormat("yyyy-MM-dd");

return formatDate.format(birth).toString();

//return this.getText().substring(preLabel.length());

}

// 覆盖父类的方法使之无效

//public void addActionListener(ActionListener listener) {

//}

private class DateChooser extends JPanel implements ActionListener,

ChangeListener {

int startYear = 1950; // 默认【最小】显示年份

int lastYear = 2050; // 默认【最大】显示年份

int width = 200; // 界面宽度

int height = 200; // 界面高度

Color backGroundColor = Color.gray; // 底色

// 月历表格配色----------------//

Color palletTableColor = Color.white; // 日历表底色

Color todayBackColor = Color.orange; // 今天背景色

Color weekFontColor = Color.blue; // 星期文字色

Color dateFontColor = Color.black; // 日期文字色

Color weekendFontColor = Color.red; // 周末文字色

// 控制条配色------------------//

Color controlLineColor = Color.pink; // 控制条底色

Color controlTextColor = Color.white; // 控制条标签文字色

Color rbFontColor = Color.white; // RoundBox文字色

Color rbBorderColor = Color.red; // RoundBox边框色

Color rbButtonColor = Color.pink; // RoundBox按钮色

Color rbBtFontColor = Color.red; // RoundBox按钮文字色

JDialog dialog;

JSpinner yearSpin;

JSpinner monthSpin;

JSpinner hourSpin;

JButton[][] daysButton = new JButton[6][7];

DateChooser() {

setLayout(new BorderLayout());

setBorder(new LineBorder(backGroundColor, 2));

setBackground(backGroundColor);

JPanel topYearAndMonth = createYearAndMonthPanal();

add(topYearAndMonth, BorderLayout.NORTH);

JPanel centerWeekAndDay = createWeekAndDayPanal();

add(centerWeekAndDay, BorderLayout.CENTER);

}

private JPanel createYearAndMonthPanal() {

Calendar c = getCalendar();

int currentYear = c.get(Calendar.YEAR);

int currentMonth = c.get(Calendar.MONTH) + 1;

int currentHour = c.get(Calendar.HOUR_OF_DAY);

JPanel result = new JPanel();

result.setLayout(new FlowLayout());

result.setBackground(controlLineColor);

yearSpin = new JSpinner(new SpinnerNumberModel(currentYear,

startYear, lastYear, 1));

yearSpin.setPreferredSize(new Dimension(48, 20));

yearSpin.setName("Year");

yearSpin.setEditor(new JSpinner.NumberEditor(yearSpin, "####"));

yearSpin.addChangeListener(this);

result.add(yearSpin);

JLabel yearLabel = new JLabel("年");

yearLabel.setForeground(controlTextColor);

result.add(yearLabel);

monthSpin = new JSpinner(new SpinnerNumberModel(currentMonth, 1,

12, 1));

monthSpin.setPreferredSize(new Dimension(35, 20));

monthSpin.setName("Month");

monthSpin.addChangeListener(this);

result.add(monthSpin);

JLabel monthLabel = new JLabel("月");

monthLabel.setForeground(controlTextColor);

result.add(monthLabel);

hourSpin = new JSpinner(new SpinnerNumberModel(currentHour, 0, 23,

1));

hourSpin.setPreferredSize(new Dimension(35, 20));

hourSpin.setName("Hour");

hourSpin.addChangeListener(this);

result.add(hourSpin);

JLabel hourLabel = new JLabel("时");

hourLabel.setForeground(controlTextColor);

result.add(hourLabel);

return result;

}

private JPanel createWeekAndDayPanal() {

String colname[] = { "日", "一", "二", "三", "四", "五", "六" };

JPanel result = new JPanel();

// 设置固定字体，以免调用环境改变影响界面美观

result.setFont(new Font("宋体", Font.PLAIN, 12));

result.setLayout(new GridLayout(7, 7));

result.setBackground(Color.white);

JLabel cell;

for (int i = 0; i 7; i++) {

cell = new JLabel(colname[i]);

cell.setHorizontalAlignment(JLabel.RIGHT);

if (i == 0 || i == 6)

cell.setForeground(weekendFontColor);

else

cell.setForeground(weekFontColor);

result.add(cell);

}

int actionCommandId = 0;

for (int i = 0; i 6; i++)

for (int j = 0; j 7; j++) {

JButton numberButton = new JButton();

numberButton.setBorder(null);

numberButton.setHorizontalAlignment(SwingConstants.RIGHT);

numberButton.setActionCommand(String

.valueOf(actionCommandId));

numberButton.addActionListener(this);

numberButton.setBackground(palletTableColor);

numberButton.setForeground(dateFontColor);

if (j == 0 || j == 6)

numberButton.setForeground(weekendFontColor);

else

numberButton.setForeground(dateFontColor);

daysButton[i][j] = numberButton;

result.add(numberButton);

actionCommandId++;

}

return result;

}

private JDialog createDialog(JDialog owner) {

JDialog result = new JDialog(owner, "日期时间选择", true);

result.setDefaultCloseOperation(JDialog.HIDE_ON_CLOSE);

result.getContentPane().add(this, BorderLayout.CENTER);

result.pack();

result.setSize(width, height);

return result;

}

void showDateChooser(Point position) {

JDialog owner = (JDialog) SwingUtilities

.getWindowAncestor(DateChooserJButton.this);

if (dialog == null || dialog.getOwner() != owner)

dialog = createDialog(owner);

dialog.setLocation(getAppropriateLocation(owner, position));

flushWeekAndDay();

dialog.setVisible(true);

}

Point getAppropriateLocation(JDialog owner, Point position) {

Point result = new Point(position);

Point p = owner.getLocation();

int offsetX = (position.x + width) - (p.x + owner.getWidth());

int offsetY = (position.y + height) - (p.y + owner.getHeight());

if (offsetX 0) {

result.x -= offsetX;

}

if (offsetY 0) {

result.y -= offsetY;

}

return result;

}

private Calendar getCalendar() {

Calendar result = Calendar.getInstance();

result.setTime(getDate());

return result;

}

private int getSelectedYear() {

return ((Integer) yearSpin.getValue()).intValue();

}

private int getSelectedMonth() {

return ((Integer) monthSpin.getValue()).intValue();

}

private int getSelectedHour() {

return ((Integer) hourSpin.getValue()).intValue();

}

private void dayColorUpdate(boolean isOldDay) {

Calendar c = getCalendar();

int day = c.get(Calendar.DAY_OF_MONTH);

c.set(Calendar.DAY_OF_MONTH, 1);

int actionCommandId = day - 2 + c.get(Calendar.DAY_OF_WEEK);

int i = actionCommandId / 7;

int j = actionCommandId % 7;

if (isOldDay)

daysButton[i][j].setForeground(dateFontColor);

else

daysButton[i][j].setForeground(todayBackColor);

}

private void flushWeekAndDay() {

Calendar c = getCalendar();

c.set(Calendar.DAY_OF_MONTH, 1);

int maxDayNo = c.getActualMaximum(Calendar.DAY_OF_MONTH);

int dayNo = 2 - c.get(Calendar.DAY_OF_WEEK);

for (int i = 0; i 6; i++) {

for (int j = 0; j 7; j++) {

String s = "";

if (dayNo = 1 dayNo = maxDayNo)

s = String.valueOf(dayNo);

daysButton[i][j].setText(s);

dayNo++;

}

}

dayColorUpdate(false);

}

public void stateChanged(ChangeEvent e) {

JSpinner source = (JSpinner) e.getSource();

Calendar c = getCalendar();

if (source.getName().equals("Hour")) {

c.set(Calendar.HOUR_OF_DAY, getSelectedHour());

setDate(c.getTime());

return;

}

dayColorUpdate(true);

if (source.getName().equals("Year"))

c.set(Calendar.YEAR, getSelectedYear());

else

// (source.getName().equals("Month"))

c.set(Calendar.MONTH, getSelectedMonth() - 1);

setDate(c.getTime());

flushWeekAndDay();

}

public void actionPerformed(ActionEvent e) {

JButton source = (JButton) e.getSource();

if (source.getText().length() == 0)

return;

dayColorUpdate(true);

source.setForeground(todayBackColor);

int newDay = Integer.parseInt(source.getText());

Calendar c = getCalendar();

c.set(Calendar.DAY_OF_MONTH, newDay);

setDate(c.getTime());

}

}

}

这是一个专门的选日期的类 ，你看看完了调用就行了

日期格式化java程序代码

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Calendar;

import java.util.Scanner;

public class Cat {

public static void main(String[] args) {

System.out.print("Please input a date in format yyyy-MM-dd HH:mm:ss: ");

String input = new Scanner(System.in).nextLine().trim();

try {

Calendar cal = Calendar.getInstance();

cal.setTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(input));

cal.add(Calendar.HOUR, 100);

String date = new SimpleDateFormat("HH:mm:SS yyyy/MM/dd").format(cal.getTime());

System.out.println(date);

} catch (ParseException e) {

System.out.println("日期时间不正确");

}

}

}

------------------测试

Please input a date in format yyyy-MM-dd HH:mm:ss: 2011-6-30 3:10:10

07:10:00 2011/07/04

java 编程中显示日期和时间的代码

可以直接通过jdk基本方法，获取到当前的时间

Date date= new Date();//创建一个时间对象，获取到当前的时间

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置时间显示格式

String str = sdf.format(date);//将当前时间格式化为需要的类型

System.out.println(str);//输出结果

结果为：2015-11-06 13:53:54（实时）。

请问如何编写以下一个计算日期的Java代码。

package com.cn.gjy;

import java.util.Scanner;

/*

说明：1这个应该没有问题，package是我编辑用的包名，你去掉；

2，纯自己手打的

3刚刚看到你这个不是从外面输入，那更简单，你加一个set方法就OK了

public void setDay(int d){}然后调用一下就OK了

* 要用下列六种METHOD

* validateInput (判定用户输入是否正确)

* getMonth (拿月份名称)

* isLeapYear (判定是否闰年)

* daysInMonth (确定一个月有多少天)

* computeTotalDays (计算从1月1日开始过去了多少天)

* nextDay (明天是几号.)*/

public class JustJustJust {

private static int day;

private static int month;

private static int year;

static Scanner sc = new Scanner(System.in);

//输入错误则推出程序

public static void validateInput(){

System.out.println("请输入年份");

//String dateYear = sc.next();

int dateYear = Integer.parseInt(sc.next());

if(dateYear2013dateYear1899) {

year = dateYear;

}else{

System.out.println("输入错误：超出范围");

System.out.println("程序终止");

System.exit(0);

}

System.out.println("请输入月份");

//String dateMon = sc.next();

int dateMon = Integer.parseInt(sc.next());

if(dateMon13dateMon0) {

month = dateMon;

}else{

System.out.println("输入错误：超出范围");

System.out.println("程序终止");

System.exit(0);

}

System.out.println("请输入日期");

//String dateDay = sc.next();

int dateDay = Integer.parseInt(sc.next());

if((month==1||month==3||month==5||month==7||month==8||month==10||month==12)(dateDay0dateDay33)){

day = dateDay;

}

else if((month==2)(year%4==0)){

if(year%100 !=0){

if(dateDay0dateDay30){

day = dateDay;

}else{

System.out.println("输入错误：超出范围");

System.out.println("程序终止");

System.exit(0);

}

}

}

else if((month==2)(year%400==0)(dateDay0dateDay30))

{day=dateDay;}

else if((month==4||month==6||month==8||month==11)(dateDay0dateDay31))

{day=dateDay;}

else{

System.out.println("输入错误：超出范围");

System.out.println("程序终止");

System.exit(0);

}

}

//获取

//天

public static int getDay(){

return day;

}

//月

public int getMonth() {

return month;

}

//年

public int getYear() {

return year;

}

//判断闰年

public static void isLeapYear(){

if((year%100 !=0)(year%4==0)){

System.out.println("今年是：" + year + "年" );

System.out.println("是闰年");

}else{

System.out.println("今年是：" + year + "年");

System.out.println("不是润年");

}

}

public static void daysInMonth(){

if((year%100 !=0)(year%4==0)){

if((month==1||month==3||month==5||month==7||month==8||month==10||month==12)){

System.out.println("这个月是" + month + "月有31天");

}

else if(month == 2){

System.out.println("这个月是二月有29天");

}else{

System.out.println("这个月是" + month + "月有30天");

}

}else{

System.out.println("今年是：" + year + "年");

System.out.println("不是润年");

if((month==1||month==3||month==5||month==7||month==8||month==10||month==12)){

System.out.println("这个月是" + month + "月有31天");

}

else if(month == 2){

System.out.println("这个月是二月有28天");

}else{

System.out.println("这个月是" + month + "月有30天");

}

}

}

public static int getFebDay(){

int febDay;

if((year%100 !=0)(year%4==0)){

febDay = 29;

}else{

febDay = 28;

}

return febDay;

}

public static void computeTotalDays(int m){

m = month;

switch(m)

{

case 1:m = 1;System.out.println("1月1日开始过去了" + (day + 0) + "天");break;

case 2:m = 2;System.out.println("1月1日开始过去了" + (day + 31) + "天");break;

case 3:m = 3; System.out.println("1月1日开始过去了" + (day + 31+ JustJustJust.getFebDay()) + "天");break;

case 4:System.out.println("1月1日开始过去了" + (day + 31+ JustJustJust.getFebDay() + 31) + "天");break;

/*

* 写的匆忙，没有想到社么好方法，你就以此类推吧

case 5:System.out.println("1月1日开始过去了" + (day + ) + "天");break;

case 6:System.out.println("1月1日开始过去了" + (day + ) + "天");break;

case 7:System.out.println("1月1日开始过去了" + (day + ) + "天");break;

case 8:System.out.println("1月1日开始过去了" + (day + ) + "天");break;

case 9:System.out.println("1月1日开始过去了" + (day + ) + "天");break;

case 10:System.out.println("1月1日开始过去了" + (day + ) + "天");break;

case 11:System.out.println("1月1日开始过去了" + (day + ) + "天");break;

case 12:System.out.println("1月1日开始过去了" + (day + ) + "天");break;

*/

}

}

public static void nextDay(){

System.out.println("明天是 " + (JustJustJust.getDay() + 1) + "号");

}

public static void main(String[] args) {

JustJustJust jjj = new JustJustJust();

jjj.validateInput();

jjj.getMonth();

jjj.isLeapYear();

jjj.daysInMonth();

jjj.computeTotalDays(month);

jjj.nextDay();

/*

* 要用下列六种METHOD

* validateInput (判定用户输入是否正确)

* getMonth (拿月份名称)

* isLeapYear (判定是否闰年)

* daysInMonth (确定一个月有多少天)

* computeTotalDays (计算从1月1日开始过去了多少天)

* nextDay (明天是几号.)*/

}

}

本文标题：Java编写日期代码 在编程中日期的编写
文章源于：http://6mz.cn/article/dodigss.html