Java Is Open Source Programming Language You Can Download From Java and Java Libraries From http://www.oracle.com.
We provide this code related to title for you to solve your developing problem easily. Libraries which is import in this program you can download from http://www.oracle.com.
Time library
//revised from prefuse
import java.lang.reflect.Constructor;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
/**
* Library routines for dealing with times and time spans. All time values
* are given as long values, indicating the number of milliseconds since
* the epoch (January 1, 1970). This is the same time format returned
* by the {@link java.lang.System#currentTimeMillis()} method.
*
* @author jeffrey heer
*/
public class TimeLib {
/** Represents a millenium, 1000 years. */
public static final int MILLENIUM = -1000;
/** Represents a century, 100 years */
public static final int CENTURY = -100;
/** Represents a decade, 10 years */
public static final int DECADE = -10;
private static final double SECOND_MILLIS = 1000;
private static final double MINUTE_MILLIS = SECOND_MILLIS*60;
private static final double HOUR_MILLIS = MINUTE_MILLIS*60;
private static final double DAY_MILLIS = HOUR_MILLIS * 24.0015;
private static final double WEEK_MILLIS = DAY_MILLIS * 7;
private static final double MONTH_MILLIS = DAY_MILLIS * 30.43675;
private static final double YEAR_MILLIS = WEEK_MILLIS * 52.2;
private static final double DECADE_MILLIS = YEAR_MILLIS * 10;
private static final double CENTURY_MILLIS = DECADE_MILLIS * 10;
private static final double MILLENIUM_MILLIS = CENTURY_MILLIS * 10;
private static final int[] CALENDAR_FIELDS = {
Calendar.YEAR, Calendar.MONTH, Calendar.DATE, Calendar.HOUR_OF_DAY,
Calendar.MINUTE, Calendar.SECOND, Calendar.MILLISECOND
};
private TimeLib() {
// prevent instantiation
}
/**
* Get the number of time units between the two given timestamps.
* @param t0 the first timestamp (as a long)
* @param t1 the second timestamp (as a long)
* @param field the time unit to use, one of the {@link java.util.Calendar}
* fields, or one of the extended fields provided by this class
* (MILLENIUM, CENTURY, or DECADE).
* @return the number of time units between the two timestamps
*/
public static int getUnitsBetween(long t0, long t1, int field) {
boolean negative = false;
if ( t1 < t0 ) {
long tmp = t1; t1 = t0; t0 = tmp; // swap
negative = true;
}
GregorianCalendar gc1 = new GregorianCalendar();
GregorianCalendar gc2 = new GregorianCalendar();
gc1.setTimeInMillis(t0);
gc2.setTimeInMillis(t1);
// add 2 units less than the estimate to 1st date,
// then serially add units till we exceed 2nd date
int est = estimateUnitsBetween(t0, t1, field);
boolean multiYear = isMultiYear(field);
if ( multiYear ) {
gc1.add(Calendar.YEAR, -field*(est-2));
est = -field*est;
} else {
gc1.add(field, est-2);
}
int f = multiYear ? Calendar.YEAR : field;
int inc = multiYear ? -field : 1;
for( int i=est-inc; ; i+=inc ) {
gc1.add(f, inc);
if( gc1.after(gc2) ) {
return negative ? inc-i : i-inc;
}
}
}
/**
* Based on code posted at
* http://forum.java.sun.com/thread.jspa?threadID=488676&messageID=2292012
*/
private static int estimateUnitsBetween(long t0, long t1, int field) {
long d = t1-t0;
switch (field) {
case Calendar.MILLISECOND:
return (int)d; // this could be very inaccurate. TODO: use long instead of int?
case Calendar.SECOND:
return (int)(d / SECOND_MILLIS + .5);
case Calendar.MINUTE:
return (int)(d / MINUTE_MILLIS + .5);
case Calendar.HOUR_OF_DAY:
case Calendar.HOUR:
return (int)(d / HOUR_MILLIS + .5);
case Calendar.DAY_OF_WEEK_IN_MONTH :
case Calendar.DAY_OF_MONTH :
// case Calendar.DATE : // codes to same int as DAY_OF_MONTH
return (int) (d / DAY_MILLIS + .5);
case Calendar.WEEK_OF_YEAR :
return (int) (d / WEEK_MILLIS + .5);
case Calendar.MONTH :
return (int) (d / MONTH_MILLIS + .5);
case Calendar.YEAR :
return (int) (d / YEAR_MILLIS + .5);
case DECADE:
return (int) (d / DECADE_MILLIS + .5);
case CENTURY:
return (int) (d / CENTURY_MILLIS + .5);
case MILLENIUM:
return (int) (d / MILLENIUM_MILLIS + .5);
default:
return 0;
}
}
/**
* Increment a calendar by a given number of time units.
* @param c the calendar to increment
* @param field the time unit to increment, one of the
* {@link java.util.Calendar} fields, or one of the extended fields
* provided by this class (MILLENIUM, CENTURY, or DECADE).
* @param val the number of time units to increment by
*/
public static void increment(Calendar c, int field, int val) {
if ( isMultiYear(field) ) {
c.add(Calendar.YEAR, -field*val);
} else {
c.add(field, val);
}
}
/**
* Get the value of the given time field for a Calendar. Just like the
* {@link java.util.Calendar#get(int)} method, but include support for
* the extended fields provided by this class (MILLENIUM, CENTURY, or
* DECADE).
* @param c the Calendar
* @param field the time field
* @return the value of the time field for the given calendar
*/
public static int get(Calendar c, int field) {
if ( isMultiYear(field) ) {
int y = c.get(Calendar.YEAR);
return -field * (y/-field);
} else {
return c.get(field);
}
}
// ------------------------------------------------------------------------
// Date Access
/**
* Get the timestamp for the given year, month, and, day.
* @param c a Calendar to use to help compute the result. The state of the
* Calendar will be overwritten.
* @param year the year to look up
* @param month the month to look up (months start at 0==January)
* @param day the day to look up
* @return the timestamp for the given date
*/
public static long getDate(Calendar c, int year, int month, int day) {
c.clear(Calendar.MILLISECOND);
c.set(year, month, day, 0, 0, 0);
return c.getTimeInMillis();
}
/**
* Get a timestamp for the given hour, minute, and second. The date will
* be assumed to be January 1, 1970.
* @param c a Calendar to use to help compute the result. The state of the
* Calendar will be overwritten.
* @param hour the hour, on a 24 hour clock
* @param minute the minute value
* @param second the seconds value
* @return the timestamp for the given date
*/
public static long getTime(Calendar c, int hour, int minute, int second) {
c.clear(Calendar.MILLISECOND);
c.set(1970, 0, 1, hour, minute, second);
return c.getTimeInMillis();
}
/**
* Get a new Date instance of the specified subclass and given long value.
* @param type the concrete subclass of the Date instance, must be an
* instance of subclass of java.util.Date
* @param d the date/time value as a long
* @return the new Date instance, or null if the class type is not valid
*/
public static Date getDate(Class type, long d) {
try {
Constructor c = type.getConstructor(new Class[] {long.class});
return (Date)c.newInstance(new Object[] {new Long(d)});
} catch ( Exception e ) {
e.printStackTrace();
return null;
}
}
// ------------------------------------------------------------------------
// Date Normalization
/**
* Get the timestamp resulting from clearing (setting to zero) all time
* values less than or equal to that of the given field. For example,
* clearing to {@link Calendar#HOUR} will floor the time to nearest
* hour which occurred before or at the given time (e.g., 1:32
* --> 1:30).
* @param t the reference time
* @param c a Calendar instance used to help compute the value, the
* state of the Calendar will be overwritten.
* @param field the time field to clear to, one of the
* {@link java.util.Calendar} fields, or one of the extended fields
* provided by this class (MILLENIUM, CENTURY, or DECADE).
* @return the cleared time
*/
public static long getClearedTime(long t, Calendar c, int field) {
c.setTimeInMillis(t);
TimeLib.clearTo(c, field);
return c.getTimeInMillis();
}
/**
* Clear the given calendar, setting to zero all time
* values less than or equal to that of the given field. For example,
* clearing to {@link Calendar#HOUR} will floor the time to nearest
* hour which occurred before or at the given time (e.g., 1:32
* --> 1:30).
* @param c the Calendar to clear
* @param field the time field to clear to, one of the
* {@link java.util.Calendar} fields, or one of the extended fields
* provided by this class (MILLENIUM, CENTURY, or DECADE).
* @return the original Calendar reference, now set to the cleared time
*/
public static Calendar clearTo(Calendar c, int field) {
int i = CALENDAR_FIELDS.length-1;
for ( ; i>=1 && field != CALENDAR_FIELDS[i]; i-- ) {
int val = (CALENDAR_FIELDS[i]==Calendar.DATE?1:0);
c.set(CALENDAR_FIELDS[i],val);
}
if ( isMultiYear(field) ) {
int y = c.get(Calendar.YEAR);
y = -field * (y/-field);
c.set(Calendar.YEAR, y);
}
return c;
}
/**
* Indicates if a field value indicates a timespan greater than one
* year. These multi-year spans are the extended fields introduced by
* this class (MILLENIUM, CENTURY, and DECADE).
* @param field the time field
* @return true if the field is multi-year, false otherwise
*/
public static boolean isMultiYear(int field) {
return ( field == DECADE || field == CENTURY || field == MILLENIUM );
}
} // end of class TimeLib
