下面列出了java.util.Calendar#get ( ) 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
/**
* Returns a calendar for the current day that does not have the time set.
*
* @return the current date.
*/
public static Calendar getCurrentCalendarNoTime()
{
// Get the current year, month, and day before we clear out the fields.
Calendar calendar = Calendar.getInstance();
int year = calendar.get(Calendar.YEAR);
int month = calendar.get(Calendar.MONTH);
int day = calendar.get(Calendar.DATE);
// Clear out ALL the fields of the calendar. If any are not cleared, we run the risk of something being set that we don't want.
calendar.clear();
// Update the calendar with just the year, month, and day.
calendar.set(year, month, day);
// Return the updated calendar.
return calendar;
}
public static String formatDateForBan(long date) {
try {
date *= 1000;
Calendar rightNow = Calendar.getInstance();
int year = rightNow.get(Calendar.YEAR);
rightNow.setTimeInMillis(date);
int dateYear = rightNow.get(Calendar.YEAR);
if (year == dateYear) {
return getInstance().formatterBannedUntilThisYear.format(new Date(date));
} else {
return getInstance().formatterBannedUntil.format(new Date(date));
}
} catch (Exception e) {
FileLog.e(e);
}
return "LOC_ERR";
}
/**
* 获取当前时间
* @return 时分秒,格式如122415,12时24分15秒
*/
public static String getCurrTime() {
StringBuffer sb = new StringBuffer(30);
Calendar nowtime = Calendar.getInstance();
int _hour = nowtime.get(Calendar.HOUR_OF_DAY); //获取小时
int _minute = nowtime.get(Calendar.MINUTE); //获取分钟
int _second = nowtime.get(Calendar.SECOND); //获取秒数
if(_hour <10){
sb.append("0");
}
sb.append(_hour);
if(_minute <10){
sb.append("0");
}
sb.append(_minute);
if(_second <10){
sb.append("0");
}
sb.append(_second);
return sb.toString();
}
/**
* {@inheritDoc}
*/
@Override
public void appendTo(StringBuffer buffer, Calendar calendar) {
TimeZone zone = calendar.getTimeZone();
if (zone.useDaylightTime()
&& calendar.get(Calendar.DST_OFFSET) != 0) {
buffer.append(getTimeZoneDisplay(zone, true, mStyle, mLocale));
} else {
buffer.append(getTimeZoneDisplay(zone, false, mStyle, mLocale));
}
}
/**
* This will ensure that the toDate is never larger than 2100, currently
* doesn't do any throttling on the from date
*/
private void throttleDates() {
if (getToDateValue() != null) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(getToDateValue());
if (calendar.get(Calendar.YEAR) > TO_DATE_UPPER_LIMIT) {
calendar.set(Calendar.YEAR, TO_DATE_UPPER_LIMIT);
setToDateValue(new Timestamp(calendar.getTimeInMillis()));
setToDateString(new SimpleDateFormat("MM/dd/yyyy").format(getToDateValue()));
}
}
}
private int timeZoneOffset(Calendar d) {
int localStandarTimeMillis = (
d.get(Calendar.HOUR_OF_DAY) * 3600 +
d.get(Calendar.MINUTE) * 60 +
d.get(Calendar.SECOND)) * 1000;
return d.getTimeZone().getOffset(
1,
d.get(Calendar.YEAR),
d.get(Calendar.MONTH),
d.get(Calendar.DAY_OF_MONTH),
d.get(Calendar.DAY_OF_WEEK),
localStandarTimeMillis) / 1000;
}
public static boolean isItTimeToDo(final String when) {
String[] whiles = when.split(";");
if (whiles.length > 0) {
Calendar now = Calendar.getInstance();
for (String w : whiles) {
int nowHour = Integer.parseInt(w);
if (nowHour == now.get(Calendar.HOUR_OF_DAY)) {
return true;
}
}
}
return false;
}
/**
* Parse the input string and return the corresponding calendar field
* number.
*/
private static double getNumber(String in, String[] formats, int calField)
throws ParseException
{
Calendar cal = Calendar.getInstance();
cal.setLenient(false);
// Try the allowed formats, from longest to shortest.
Date date = testFormats(in, formats);
if (date == null) return Double.NaN;
cal.setTime(date);
return cal.get(calField);
}
public static Object secondOfMinute( IValueMeta metaA, Object dataA ) throws HopValueException {
if ( dataA == null ) {
return null;
}
Calendar calendar = Calendar.getInstance();
calendar.setTime( metaA.getDate( dataA ) );
return new Long( calendar.get( Calendar.SECOND ) );
}
/**
* 计算两个时间之间的差值,根据标志的不同而不同
*
* @param flag
* 计算标志,表示按照年/月/日/时/分/秒等计算
* @param calSrc
* 减数
* @param calDes
* 被减数
* @return 两个日期之间的差值
*/
public static int dateDiff(char flag, Calendar calSrc, Calendar calDes) {
long millisDiff = getMillis(calSrc) - getMillis(calDes);
if (flag == 'y') {
return (calSrc.get(calSrc.YEAR) - calDes.get(calDes.YEAR));
}
if (flag == 'd') {
return (int) (millisDiff / DAY_IN_MILLIS);
}
if (flag == 'h') {
return (int) (millisDiff / HOUR_IN_MILLIS);
}
if (flag == 'm') {
return (int) (millisDiff / MINUTE_IN_MILLIS);
}
if (flag == 's') {
return (int) (millisDiff / SECOND_IN_MILLIS);
}
return 0;
}
static int reduceAndCorrect(Calendar start, Calendar end, int field, int difference) {
end.add( field, -1 * difference );
int endValue = end.get(field);
int startValue = start.get(field);
if (endValue < startValue) {
int newdiff = startValue - endValue;
end.add( field, newdiff );
return newdiff;
} else {
return 0;
}
}
private static boolean isDifferentDayInPast(long now, long last, long period) {
Calendar lastRestoreCalendar = Calendar.getInstance();
lastRestoreCalendar.setTimeInMillis(last);
return period == DateUtils.DAY_IN_MILLIS &&
lastRestoreCalendar.get(Calendar.DAY_OF_WEEK) != Calendar.getInstance().get(Calendar.DAY_OF_WEEK) &&
now > last;
}
@SuppressWarnings("unchecked")
private void writeValue(Type type, Schema avroSchema, Object value) {
Schema nonNullAvroSchema = AvroSchemaConverter.getNonNull(avroSchema);
Schema.Type avroType = nonNullAvroSchema.getType();
if (avroType.equals(Schema.Type.BOOLEAN)) {
recordConsumer.addBoolean((Boolean) value);
} else if (avroType.equals(Schema.Type.INT)) {
if (value instanceof Character) {
recordConsumer.addInteger((Character) value);
} else {
recordConsumer.addInteger(((Number) value).intValue());
}
} else if (avroType.equals(Schema.Type.LONG)) {
if (type.asPrimitiveType().getPrimitiveTypeName().equals(PrimitiveType.PrimitiveTypeName.INT96)) {
final long NANOS_PER_HOUR = TimeUnit.HOURS.toNanos(1);
final long NANOS_PER_MINUTE = TimeUnit.MINUTES.toNanos(1);
final long NANOS_PER_SECOND = TimeUnit.SECONDS.toNanos(1);
long timestamp = ((Number) value).longValue();
Calendar calendar;
if (timeZoneId != null && ! timeZoneId.isEmpty()) {
calendar = Calendar.getInstance(TimeZone.getTimeZone(timeZoneId));
} else {
calendar = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
}
calendar.setTime(new Date(timestamp));
// Calculate Julian days and nanoseconds in the day
LocalDate dt = LocalDate.of(calendar.get(Calendar.YEAR), calendar.get(Calendar.MONTH)+1, calendar.get(Calendar.DAY_OF_MONTH));
int julianDays = (int) JulianFields.JULIAN_DAY.getFrom(dt);
long nanos = (calendar.get(Calendar.HOUR_OF_DAY) * NANOS_PER_HOUR)
+ (calendar.get(Calendar.MINUTE) * NANOS_PER_MINUTE)
+ (calendar.get(Calendar.SECOND) * NANOS_PER_SECOND);
// Write INT96 timestamp
byte[] timestampBuffer = new byte[12];
ByteBuffer buf = ByteBuffer.wrap(timestampBuffer);
buf.order(ByteOrder.LITTLE_ENDIAN).putLong(nanos).putInt(julianDays);
// This is the properly encoded INT96 timestamp
Binary timestampBinary = Binary.fromReusedByteArray(timestampBuffer);
recordConsumer.addBinary(timestampBinary);
} else {
recordConsumer.addLong(((Number) value).longValue());
}
} else if (avroType.equals(Schema.Type.FLOAT)) {
recordConsumer.addFloat(((Number) value).floatValue());
} else if (avroType.equals(Schema.Type.DOUBLE)) {
recordConsumer.addDouble(((Number) value).doubleValue());
} else if (avroType.equals(Schema.Type.BYTES)) {
if (value instanceof byte[]) {
recordConsumer.addBinary(Binary.fromReusedByteArray((byte[]) value));
} else {
recordConsumer.addBinary(Binary.fromReusedByteBuffer((ByteBuffer) value));
}
} else if (avroType.equals(Schema.Type.STRING)) {
recordConsumer.addBinary(fromAvroString(value));
} else if (avroType.equals(Schema.Type.RECORD)) {
writeRecord(type.asGroupType(), nonNullAvroSchema, value);
} else if (avroType.equals(Schema.Type.ENUM)) {
recordConsumer.addBinary(Binary.fromString(value.toString()));
} else if (avroType.equals(Schema.Type.ARRAY)) {
listWriter.writeList(type.asGroupType(), nonNullAvroSchema, value);
} else if (avroType.equals(Schema.Type.MAP)) {
writeMap(type.asGroupType(), nonNullAvroSchema, (Map<CharSequence, ?>) value);
} else if (avroType.equals(Schema.Type.UNION)) {
writeUnion(type.asGroupType(), nonNullAvroSchema, value);
} else if (avroType.equals(Schema.Type.FIXED)) {
recordConsumer.addBinary(Binary.fromReusedByteArray(((GenericFixed) value).bytes()));
}
}
int getYear(Date date) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
return calendar.get(Calendar.YEAR);
}
/**
* See above.
*/
public static double dayOfWeekInMonth()
{
Calendar cal = Calendar.getInstance();
return cal.get(Calendar.DAY_OF_WEEK_IN_MONTH);
}
/**
* Sets up the fixture, for example, open a network connection.
* This method is called before a test is executed.
*
* @throws Exception if there is a problem.
*/
@Before
public void setUp() throws Exception {
// setup our test timelines
//
// Legend for comments below:
// <spaces> = Segments included in the final timeline
// EE = Excluded segments via timeline rules
// xx = Exception segments inherited from base timeline exclusions
// 1-ms test timeline using 5 included and 2 excluded segments.
//
// timeline start time = 0
// |
// v
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 ..
// +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+..
// | | | | | |EE|EE| | | | | |EE|EE| | | | | | |EE|EE| <-- msTimeline
// +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+..
// \_________ ________/ \_/
// \/ |
// segment group segment size = 1 ms
//
this.msTimeline = new SegmentedTimeline(1, 5, 2);
this.msTimeline.setStartTime(0);
// 4-ms test base timeline for ms2Timeline using 1 included and 1
// excluded segments
//
// timeline start time = 0
// |
// v
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 ...
// +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+...
// | | | | |EE|EE|EE|EE| | | | |EE|EE|EE|EE| | | | | <-- ms2BaseTimeline
// +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+...
// \__________ _________/ \____ _____/
// \/ \/
// segment group segment size = 4 ms
//
this.ms2BaseTimeline = new SegmentedTimeline(4, 1, 1);
this.ms2BaseTimeline.setStartTime(0);
// 1-ms test timeline (with a baseTimeline) using 2 included and 2
// excluded segments centered inside each base segment
//
// The ms2Timeline without a base would look like this:
//
// timeline start time = 1
// |
// v
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 ...
// +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+...
// |EE| | |EE|EE| | |EE|EE| | |EE|EE| | |EE|EE| | |EE| <-- ms2Timeline
// +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+...
// \____ _____/ \_/
// \/ |
// segment group segment size = 1 ms
//
// With the base timeline some originally included segments are now
// removed (see "xx" below):
//
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 ...
// +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+...
// |EE| | |EE|EE|xx|xx|EE|EE| | |EE|EE|xx|xx|EE|EE| | |EE| <-- ms2Timeline
// +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+...
// | | | | |EE|EE|EE|EE| | | | |EE|EE|EE|EE| | | | | <-- ms2BaseTimeline
// +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+...
//
this.ms2Timeline = new SegmentedTimeline(1, 2, 2);
this.ms2Timeline.setStartTime(1);
this.ms2Timeline.setBaseTimeline(this.ms2BaseTimeline);
// test monday though friday timeline
this.mondayFridayTimeline
= SegmentedTimeline.newMondayThroughFridayTimeline();
// test 9am-4pm Monday through Friday timeline
this.fifteenMinTimeline
= SegmentedTimeline.newFifteenMinuteTimeline();
// find first Monday after 2001-01-01
Calendar cal = new GregorianCalendar(
SegmentedTimeline.NO_DST_TIME_ZONE);
cal.set(2001, 0, 1, 0, 0, 0);
cal.set(Calendar.MILLISECOND, 0);
while (cal.get(Calendar.DAY_OF_WEEK) != Calendar.MONDAY) {
cal.add(Calendar.DATE, 1);
}
this.monday = (Calendar) cal.clone();
// calculate 9am on the first Monday after 2001-01-01
cal.add(Calendar.HOUR, 9);
this.monday9am = (Calendar) cal.clone();
}
/**
* Calendar-version for fragment-calculation in any unit
*
* @param calendar the calendar to work with, not null
* @param fragment the Calendar field part of calendar to calculate
* @param unit Calendar field defining the unit
* @return number of units within the fragment of the calendar
* @throws IllegalArgumentException if the date is <code>null</code> or
* fragment is not supported
* @since 2.4
*/
private static long getFragment(Calendar calendar, int fragment, int unit) {
if(calendar == null) {
throw new IllegalArgumentException("The date must not be null");
}
long millisPerUnit = getMillisPerUnit(unit);
long result = 0;
// Fragments bigger than a day require a breakdown to days
switch (fragment) {
case Calendar.YEAR:
result += (calendar.get(Calendar.DAY_OF_YEAR) * MILLIS_PER_DAY) / millisPerUnit;
break;
case Calendar.MONTH:
result += (calendar.get(Calendar.DAY_OF_MONTH) * MILLIS_PER_DAY) / millisPerUnit;
break;
}
switch (fragment) {
// Number of days already calculated for these cases
case Calendar.YEAR:
case Calendar.MONTH:
// The rest of the valid cases
case Calendar.DAY_OF_YEAR:
case Calendar.DATE:
result += (calendar.get(Calendar.HOUR_OF_DAY) * MILLIS_PER_HOUR) / millisPerUnit;
//$FALL-THROUGH$
case Calendar.HOUR_OF_DAY:
result += (calendar.get(Calendar.MINUTE) * MILLIS_PER_MINUTE) / millisPerUnit;
//$FALL-THROUGH$
case Calendar.MINUTE:
result += (calendar.get(Calendar.SECOND) * MILLIS_PER_SECOND) / millisPerUnit;
//$FALL-THROUGH$
case Calendar.SECOND:
result += (calendar.get(Calendar.MILLISECOND) * 1) / millisPerUnit;
break;
case Calendar.MILLISECOND: break;//never useful
default: throw new IllegalArgumentException("The fragment " + fragment + " is not supported");
}
return result;
}
public static boolean isSameDay(final Calendar cal1, final Calendar cal2)
{
return cal1.get(Calendar.YEAR) == cal2.get(Calendar.YEAR) && cal1.get(Calendar.DAY_OF_YEAR) == cal2.get(Calendar.DAY_OF_YEAR);
}
private SelectedDateItem computeNewSelectedDateItem(int difference) {
Calendar cal = Calendar.getInstance();
cal.set(displayYear, displayMonth, 1);
cal.add(Calendar.MONTH, -difference);
return new SelectedDateItem(cal.get(Calendar.YEAR),
cal.get(Calendar.MONTH), 1);
}
/**
* Constructs a MonthDay from a <code>java.util.Calendar</code>
* using exactly the same field values avoiding any time zone effects.
* <p>
* Each field is queried from the Calendar and assigned to the MonthDay.
* <p>
* This factory method ignores the type of the calendar and always
* creates a MonthDay with ISO chronology. It is expected that you
* will only pass in instances of <code>GregorianCalendar</code> however
* this is not validated.
*
* @param calendar the Calendar to extract fields from
* @return the created MonthDay, never null
* @throws IllegalArgumentException if the calendar is null
* @throws IllegalArgumentException if the monthOfYear or dayOfMonth is invalid for the ISO chronology
*/
public static MonthDay fromCalendarFields(Calendar calendar) {
if (calendar == null) {
throw new IllegalArgumentException("The calendar must not be null");
}
return new MonthDay(calendar.get(Calendar.MONTH) + 1, calendar.get(Calendar.DAY_OF_MONTH));
}