Truncate this date(Calendar), leaving the field specified as the most significant field. : Date Calculation « Data Type « Java Tutorial

Home
Java Tutorial
1.Language
2.Data Type
3.Operators
4.Statement Control
5.Class Definition
6.Development
7.Reflection
8.Regular Expressions
9.Collections
10.Thread
11.File
12.Generics
13.I18N
14.Swing
15.Swing Event
16.2D Graphics
17.SWT
18.SWT 2D Graphics
19.Network
20.Database
21.Hibernate
22.JPA
23.JSP
24.JSTL
25.Servlet
26.Web Services SOA
27.EJB3
28.Spring
29.PDF
30.Email
31.J2ME
32.J2EE Application
33.XML
34.Design Pattern
35.Log
36.Security
37.Apache Common
38.Ant
39.JUnit
Java Tutorial » Data Type » Date Calculation 
2.42.50.Truncate this date(Calendar), leaving the field specified as the most significant field.Previous/Next
import java.util.Calendar;
import java.util.Date;

/**
 * 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.
 */




/**
 * A suite of utilities surrounding the use of the
 {@link java.util.Calendar} and {@link java.util.Date} object.
 
 * DateUtils contains a lot of common methods considering manipulations
 * of Dates or Calendars. Some methods require some extra explanation.
 * The truncate and round methods could be considered the Math.floor(),
 * Math.ceil() or Math.round versions for dates
 * This way date-fields will be ignored in bottom-up order.
 * As a complement to these methods we've introduced some fragment-methods.
 * With these methods the Date-fields will be ignored in top-down order.
 * Since a date without a year is not a valid date, you have to decide in what
 * kind of date-field you want your result, for instance milliseconds or days.
 
 *   
 *   
 *
 @author <a href="mailto:sergek@lokitech.com">Serge Knystautas</a>
 @author Stephen Colebourne
 @author Janek Bogucki
 @author <a href="mailto:ggregory@seagullsw.com">Gary Gregory</a>
 @author Phil Steitz
 @author Robert Scholte
 @since 2.0
 @version $Id: DateUtils.java 634096 2008-03-06 00:58:11Z niallp $
 */
public class Main {
  private static final int[][] fields = {
    {Calendar.MILLISECOND},
    {Calendar.SECOND},
    {Calendar.MINUTE},
    {Calendar.HOUR_OF_DAY, Calendar.HOUR},
    {Calendar.DATE, Calendar.DAY_OF_MONTH, Calendar.AM_PM 
        /* Calendar.DAY_OF_YEAR, Calendar.DAY_OF_WEEK, Calendar.DAY_OF_WEEK_IN_MONTH */
    },
    {Calendar.MONTH, DateUtils.SEMI_MONTH},
    {Calendar.YEAR},
    {Calendar.ERA}};



  /**
   * Truncate this date, leaving the field specified as the most
   * significant field.
   *
   * For example, if you had the datetime of 28 Mar 2002
   * 13:45:01.231, if you passed with HOUR, it would return 28 Mar
   * 2002 13:00:00.000.  If this was passed with MONTH, it would
   * return 1 Mar 2002 0:00:00.000.
   
   @param date  the date to work with
   @param field  the field from <code>Calendar</code>
   *  or <code>SEMI_MONTH</code>
   @return the rounded date (a different object)
   @throws IllegalArgumentException if the date is <code>null</code>
   @throws ArithmeticException if the year is over 280 million
   */
  public static Calendar truncate(Calendar date, int field) {
      if (date == null) {
          throw new IllegalArgumentException("The date must not be null");
      }
      Calendar truncated = (Calendardate.clone();
      modify(truncated, field, false);
      return truncated;
  }
  //-----------------------------------------------------------------------
  /**
   * Internal calculation method.
   
   @param val  the calendar
   @param field  the field constant
   @param round  true to round, false to truncate
   @throws ArithmeticException if the year is over 280 million
   */
  private static void modify(Calendar val, int field, boolean round) {
      if (val.get(Calendar.YEAR280000000) {
          throw new ArithmeticException("Calendar value too large for accurate calculations");
      }
      
      if (field == Calendar.MILLISECOND) {
          return;
      }

      // ----------------- Fix for LANG-59 ---------------------- START ---------------
      // see http://issues.apache.org/jira/browse/LANG-59
      //
      // Manually truncate milliseconds, seconds and minutes, rather than using
      // Calendar methods.

      Date date = val.getTime();
      long time = date.getTime();
      boolean done = false;

      // truncate milliseconds
      int millisecs = val.get(Calendar.MILLISECOND);
      if (!round || millisecs < 500) {
          time = time - millisecs;
      }
      if (field == Calendar.SECOND) {
          done = true;
      }

      // truncate seconds
      int seconds = val.get(Calendar.SECOND);
      if (!done && (!round || seconds < 30)) {
          time = time - (seconds * 1000L);
      }
      if (field == Calendar.MINUTE) {
          done = true;
      }

      // truncate minutes
      int minutes = val.get(Calendar.MINUTE);
      if (!done && (!round || minutes < 30)) {
          time = time - (minutes * 60000L);
      }

      // reset time
      if (date.getTime() != time) {
          date.setTime(time);
          val.setTime(date);
      }
      // ----------------- Fix for LANG-59 ----------------------- END ----------------

      boolean roundUp = false;
      for (int i = 0; i < fields.length; i++) {
          for (int j = 0; j < fields[i].length; j++) {
              if (fields[i][j== field) {
                  //This is our field... we stop looping
                  if (round && roundUp) {
                      if (field == DateUtils.SEMI_MONTH) {
                          //This is a special case that's hard to generalize
                          //If the date is 1, we round up to 16, otherwise
                          //  we subtract 15 days and add 1 month
                          if (val.get(Calendar.DATE== 1) {
                              val.add(Calendar.DATE, 15);
                          else {
                              val.add(Calendar.DATE, -15);
                              val.add(Calendar.MONTH, 1);
                          }
                      else {
                          //We need at add one to this field since the
                          //  last number causes us to round up
                          val.add(fields[i][0]1);
                      }
                  }
                  return;
              }
          }
          //We have various fields that are not easy roundings
          int offset = 0;
          boolean offsetSet = false;
          //These are special types of fields that require different rounding rules
          switch (field) {
              case DateUtils.SEMI_MONTH:
                  if (fields[i][0== Calendar.DATE) {
                      //If we're going to drop the DATE field's value,
                      //  we want to do this our own way.
                      //We need to subtrace 1 since the date has a minimum of 1
                      offset = val.get(Calendar.DATE1;
                      //If we're above 15 days adjustment, that means we're in the
                      //  bottom half of the month and should stay accordingly.
                      if (offset >= 15) {
                          offset -= 15;
                      }
                      //Record whether we're in the top or bottom half of that range
                      roundUp = offset > 7;
                      offsetSet = true;
                  }
                  break;
              case Calendar.AM_PM:
                  if (fields[i][0== Calendar.HOUR_OF_DAY) {
                      //If we're going to drop the HOUR field's value,
                      //  we want to do this our own way.
                      offset = val.get(Calendar.HOUR_OF_DAY);
                      if (offset >= 12) {
                          offset -= 12;
                      }
                      roundUp = offset > 6;
                      offsetSet = true;
                  }
                  break;
          }
          if (!offsetSet) {
              int min = val.getActualMinimum(fields[i][0]);
              int max = val.getActualMaximum(fields[i][0]);
              //Calculate the offset from the minimum allowed value
              offset = val.get(fields[i][0]) - min;
              //Set roundUp if this is more than half way between the minimum and maximum
              roundUp = offset > ((max - min2);
          }
          //We need to remove this field
          if (offset != 0) {
              val.set(fields[i][0], val.get(fields[i][0]) - offset);
          }
      }
      throw new IllegalArgumentException("The field " + field + " is not supported");

  }
}
2.42.Date Calculation
2.42.1.Compare date time using after method of Java Calendar
2.42.2.Compare date time using before method of Java Calendar
2.42.3.Increment and Decrement a Date Using the Calendar Class
2.42.4.Increment and Decrement Months Using the Calendar Class
2.42.5.Add or substract days to current date using Java Calendar
2.42.6.Substract days from current date using Calendar.add method
2.42.7.Add hours to current date using Calendar.add method
2.42.8.Calendar adjust date automatically
2.42.9.Substract hours from current date using Calendar.add method
2.42.10.Add minutes to current date using Calendar.add method
2.42.11.Substract minutes from current date using Calendar.add method
2.42.12.Add months to current date using Calendar.add method
2.42.13.Substract months from current date using Calendar.add method
2.42.14.Add seconds to current date using Calendar.add method
2.42.15.Substract seconds from current time using Calendar.add method
2.42.16.Add week to current date using Calendar.add method
2.42.17.Substract week from current date
2.42.18.Add year to current date using Calendar.add method
2.42.19.Substract year from current date
2.42.20.Substract 30 days from the calendar
2.42.21.Add 10 months to the calendar
2.42.22.Substract 1 year from the calendar
2.42.23.If a date is after another date
2.42.24.If a date is before another date
2.42.25.Compute days between 2 dates
2.42.26.Calculate the age
2.42.27.Determining If a Year Is a Leap Year
2.42.28.Determining the Day-of-Week for a Particular Date
2.42.29.Add hours, minutes or seconds to a date
2.42.30.Find the Difference Between Two Given Dates
2.42.31.add another 12 hours and print out the date and time
2.42.32.subtract 4 hours from the time and print out the date and time
2.42.33.add 8 days to the current date and print out the date and time
2.42.34.Returns the number of days within the fragment.
2.42.35.Returns the number of hours within the fragment.
2.42.36.Returns the number of milliseconds within the fragment.
2.42.37.Returns the number of minutes within the fragment.
2.42.38.Returns the number of seconds within the fragment.
2.42.39.Returns a Date set just to Noon, to the closest possible millisecond of the day.
2.42.40.Returns a Date set to the last possible millisecond of the month, just before midnight.
2.42.41.Returns a Date set to the first possible millisecond of the month, just after midnight.
2.42.42.Returns a Date set to the last possible millisecond of the minute.
2.42.43.Returns a Date set to the last possible millisecond of the day, just before midnight.
2.42.44.Returns a Date set to the first possible millisecond of the day, just after midnight.
2.42.45.Returns true if endDate is after startDate or if startDate equals endDate.
2.42.46.Round this date, leaving the field specified as the most significant field.
2.42.47.Checks if two date objects represent the same instant in time
2.42.48.Checks if two calendar objects represent the same local time.
2.42.49.Checks if two date objects are on the same day ignoring time
2.42.50.Truncate this date(Calendar), leaving the field specified as the most significant field.
2.42.51.Truncate this date, leaving the field specified as the most significant field.
2.42.52.Days Till End Of Year
2.42.53.Convert day of year to day of month
2.42.54.Determine if an hour is between an interval
java2s.com  | Contact Us | Privacy Policy
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.