Here you can find the source of isSameInstant(Calendar cal1, Calendar cal2)
Checks if two calendar objects represent the same instant in time.
| Parameter | Description |
|---|---|
| cal1 | the first calendar, not altered, not null |
| cal2 | the second calendar, not altered, not null |
| Parameter | Description |
|---|---|
| IllegalArgumentException | if either date is <code>null</code> |
public static boolean isSameInstant(Calendar cal1, Calendar cal2)
//package com.java2s; /*/*from ww w. jav a2 s . c o m*/ * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ import java.text.ParseException; import java.text.ParsePosition; import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.Date; public class Main { /** * <p> * Checks if two date objects represent the same instant in time. * </p> * * <p> * This method compares the long millisecond time of the two objects. * </p> * * @param date1 * the first date, not altered, not null * @param date2 * the second date, not altered, not null * @return true if they represent the same millisecond instant * @throws IllegalArgumentException * if either date is <code>null</code> * @since 2.1 */ public static boolean isSameInstant(Date date1, Date date2) { if (date1 == null || date2 == null) { throw new IllegalArgumentException("The date must not be null"); } return date1.getTime() == date2.getTime(); } /** * <p> * Checks if two calendar objects represent the same instant in time. * </p> * * <p> * This method compares the long millisecond time of the two objects. * </p> * * @param cal1 * the first calendar, not altered, not null * @param cal2 * the second calendar, not altered, not null * @return true if they represent the same millisecond instant * @throws IllegalArgumentException * if either date is <code>null</code> * @since 2.1 */ public static boolean isSameInstant(Calendar cal1, Calendar cal2) { if (cal1 == null || cal2 == null) { throw new IllegalArgumentException("The date must not be null"); } return cal1.getTime().getTime() == cal2.getTime().getTime(); } public static long getTime(String date, String pattern) { try { return parseDate(date, pattern).getTime(); } catch (ParseException e) { e.printStackTrace(); } return 0; } /** * <p> * Parses a string representing a date by trying a variety of different * parsers. * </p> * * <p> * The parse will try each parse pattern in turn. A parse is only deemed * successful if it parses the whole of the input string. If no parse * patterns match, a ParseException is thrown. * </p> * The parser will be lenient toward the parsed date. * * @param str * the date to parse, not null * @param parsePatterns * the date format patterns to use, see SimpleDateFormat, not * null * @return the parsed date * @throws IllegalArgumentException * if the date string or pattern array is null * @throws ParseException * if none of the date patterns were suitable (or there were * none) */ public static Date parseDate(String str, String... parsePatterns) throws ParseException { return parseDateWithLeniency(str, parsePatterns, true); } /** * <p> * Parses a string representing a date by trying a variety of different * parsers. * </p> * * <p> * The parse will try each parse pattern in turn. A parse is only deemed * successful if it parses the whole of the input string. If no parse * patterns match, a ParseException is thrown. * </p> * * @param str * the date to parse, not null * @param parsePatterns * the date format patterns to use, see SimpleDateFormat, not * null * @param lenient * Specify whether or not date/time parsing is to be lenient. * @return the parsed date * @throws IllegalArgumentException * if the date string or pattern array is null * @throws ParseException * if none of the date patterns were suitable * @see java.util.Calender#isLenient() */ private static Date parseDateWithLeniency(String str, String[] parsePatterns, boolean lenient) throws ParseException { if (str == null || parsePatterns == null) { throw new IllegalArgumentException("Date and Patterns must not be null"); } SimpleDateFormat parser = new SimpleDateFormat(); parser.setLenient(lenient); ParsePosition pos = new ParsePosition(0); for (String parsePattern : parsePatterns) { String pattern = parsePattern; // LANG-530 - need to make sure 'ZZ' output doesn't get passed to // SimpleDateFormat if (parsePattern.endsWith("ZZ")) { pattern = pattern.substring(0, pattern.length() - 1); } parser.applyPattern(pattern); pos.setIndex(0); String str2 = str; // LANG-530 - need to make sure 'ZZ' output doesn't hit // SimpleDateFormat as it will ParseException if (parsePattern.endsWith("ZZ")) { str2 = str.replaceAll("([-+][0-9][0-9]):([0-9][0-9])$", "$1$2"); } Date date = parser.parse(str2, pos); if (date != null && pos.getIndex() == str2.length()) { return date; } } throw new ParseException("Unable to parse the date: " + str, -1); } }