org.joda.time.Months Java Examples

protected static int dateDiff(Date beginDate, Date endDate, DateType type) {
    //Interval interval = new Interval(beginDate.getTime(), endDate.getTime());
    //Period p = interval.toPeriod();
    DateTime start =new DateTime(beginDate);
    DateTime end =new DateTime(endDate);
    if (DateType.YEAR.equals(endDate)) {
         return Years.yearsBetween(start, end).getYears();
    } else if (DateType.MONTH.equals(type)) {
        return Months.monthsBetween(start, end).getMonths();
    } else if (DateType.WEEK.equals(type)) {
        return Weeks.weeksBetween(start, end).getWeeks();
    } else if (DateType.DAY.equals(type)) {
        return Days.daysBetween(start, end).getDays();
    } else if (DateType.HOUR.equals(type)) {
        return Hours.hoursBetween(start, end).getHours();
    } else if (DateType.MINUTE.equals(type)) {
        return Minutes.minutesBetween(start, end).getMinutes();
    } else if (DateType.SECOND.equals(type)) {
        return Seconds.secondsBetween(start, end).getSeconds();
    } else {
        return 0;
    }
}
 

public Calendar(DateTime firstMonth, DateTime lastMonth) {
    this.firstMonth = firstMonth;
    this.firstDayOfWeek = java.util.Calendar.getInstance(Locale.getDefault()).getFirstDayOfWeek();

    DateTime startMonth = firstMonth.plusMonths(1);
    int monthsBetweenCount = Months.monthsBetween(firstMonth, lastMonth).getMonths();

    months = new ArrayList<>();

    months.add(firstMonth);
    currentMonth = firstMonth;

    DateTime monthToAdd = new DateTime(startMonth.getYear(), startMonth.getMonthOfYear(), 1, 0, 0);
    for (int i = 0; i <= monthsBetweenCount; i++) {
        months.add(monthToAdd);
        monthToAdd = monthToAdd.plusMonths(1);
    }
}
 

private String getFrequencyElseNull() {
    final SortedSet<InvoiceItem> items = invoice.getItems();
    if(items.isEmpty()) {
        return null;
    }
    final InvoiceItem item = items.first();
    final LocalDate startDate = item.getStartDate();
    final LocalDate endDate = item.getEndDate();
    if(startDate == null || endDate == null) {
        return null;
    }
    Months months = Months.monthsBetween(startDate, endDate.plusDays(1));
    switch (months.getMonths()) {
    case 12:
        return "YEAR";
    case 3:
        return "QUARTER";
    case 1:
        return "MONTH";
    }
    return null;
}
 

public static int getMonthsBetween(final String date1, final String date2, String format){
    try {
    final DateTimeFormatter fmt =
            DateTimeFormat
                    .forPattern(format)
                    .withChronology(
                            LenientChronology.getInstance(
                                    GregorianChronology.getInstance()));
    return Months.monthsBetween(
            fmt.parseDateTime(date1),
            fmt.parseDateTime(date2)
    ).getMonths();
    } catch (Exception ex) {
        ex.printStackTrace();
        return 0;
    }
}
 

/**
 * Returns the number of months between two dates.
 */
@Function("MONTHS")
@FunctionParameters({
	@FunctionParameter("startDate"),
	@FunctionParameter("endDate")})
public Integer MONTHS(Object startDate, Object endDate){
	Date startDateObj = convertDateObject(startDate);
	if(startDateObj==null) {
		logCannotConvertToDate();
		return null;
	}
	Date endDateObj = convertDateObject(endDate);
	if(endDateObj==null){
		logCannotConvertToDate();
		return null;
	}
	else{
		LocalDate dt1=new LocalDate(startDateObj);
		LocalDate dt2=new LocalDate(endDateObj);
		return Months.monthsBetween(dt1, dt2).getMonths();
	}
}
 

public boolean areContactsRecent(final Class<? extends PartyContact> contactClass, final int daysNotUpdated) {
    final List<? extends PartyContact> partyContacts = getPartyContacts(contactClass);
    boolean isUpdated = false;
    for (final PartyContact partyContact : partyContacts) {
        if (partyContact.getLastModifiedDate() == null) {
            isUpdated = isUpdated || false;
        } else {
            final DateTime lastModifiedDate = partyContact.getLastModifiedDate();
            final DateTime now = new DateTime();
            final Months months = Months.monthsBetween(lastModifiedDate, now);
            if (months.getMonths() > daysNotUpdated) {
                isUpdated = isUpdated || false;
            } else {
                isUpdated = isUpdated || true;
            }
        }
    }
    return isUpdated;
}
 

@Override
public Long exec(Tuple input) throws IOException
{
    if (input == null || input.size() < 2) {
        return null;
    }

    if (input.get(0) == null || input.get(1) == null) {
        return null;
    }

    DateTime startDate = new DateTime(input.get(0).toString());
    DateTime endDate = new DateTime(input.get(1).toString());

    // Larger value first
    Months m = Months.monthsBetween(endDate, startDate);
    long months = m.getMonths();

    return months;

}
 

@Override
public Long exec(Tuple input) throws IOException
{
    if (input == null || input.size() < 2 || input.get(0) == null || input.get(1) == null) {
        return null;
    }

    DateTime startDate = (DateTime) input.get(0);
    DateTime endDate = (DateTime) input.get(1);

    // Larger value first
    Months m = Months.monthsBetween(endDate, startDate);
    // joda limitation, only integer range, at the risk of overflow, need to be improved
    return (long) m.getMonths();

}
 

@Override
@SuppressWarnings("EqualsBetweenInconvertibleTypes") // SpecimenType knows how to do equals(Class<?>)
public Object create(Object request, SpecimenContext context) {

    if (!(request instanceof SpecimenType)) {
        return new NoSpecimen();
    }

    SpecimenType type = (SpecimenType) request;
    if (!BaseSingleFieldPeriod.class.isAssignableFrom(type.getRawType())) {
        return new NoSpecimen();
    }

    Duration duration = (Duration) context.resolve(Duration.class);
    if (type.equals(Seconds.class)) return Seconds.seconds(Math.max(1, (int) duration.getStandardSeconds()));
    if (type.equals(Minutes.class)) return Minutes.minutes(Math.max(1, (int) duration.getStandardMinutes()));
    if (type.equals(Hours.class)) return Hours.hours(Math.max(1, (int) duration.getStandardHours()));

    if (type.equals(Days.class)) return Days.days(Math.max(1, (int) duration.getStandardDays()));
    if (type.equals(Weeks.class)) return Weeks.weeks(Math.max(1, (int) duration.getStandardDays() / 7));
    if (type.equals(Months.class)) return Months.months(Math.max(1, (int) duration.getStandardDays() / 30));
    if (type.equals(Years.class)) return Years.years(Math.max(1, (int) duration.getStandardDays() / 365));

    return new NoSpecimen();
}
 

public static Integer monthsBetween(String start, String end)  throws ParseException {
    if (isEmpty(start) || isEmpty(end)) {
        return 0;
    }
    DateTime startDate = new DateTime(start);
    DateTime endDate = new DateTime(end);
    return Months.monthsBetween(startDate.withDayOfMonth(1), endDate.withDayOfMonth(1)).getMonths();
}
 

/**
 * 11
 * Implements the MONTH_BETWEEN function
 * if any of the input values are null, the function will return -1. Else, it will return an positive double.
 */
public static double MONTH_BETWEEN(Date source1, Date source2) {
    if (source1 == null || source2 == null) return -1;
    DateTime dt1 = new DateTime(source1);
    DateTime dt2 = new DateTime(source2);
    return Months.monthsBetween(dt1, dt2).getMonths();
}
 

/**
 * Calculates the difference between two times, given as long values, and
 * returns the period between them in the specified <code>units</code>. The
 * units value must be one of:
 * <pre>
 *  {@link #MILLISECONDS}
 *  {@link #SECONDS}
 *  {@link #MINUTES}
 *  {@link #HOURS}
 *  {@link #DAYS}
 *  {@link #WEEKS}
 *  {@link #MONTHS}
 *  {@link #YEARS}
 * </pre>
 * All values will be returned as the absolute value of the difference.
 *
 * @param arg1 The value to use as the minuend.
 * @param arg2 The value to use as the subtrahend.
 * @param units The time units to use for expressing the difference.
 * @return The long value of the difference between the arguments in the
 *      specified units.
 */
public static long period(long arg1, long arg2, int units) {
    long delta = arg1 - arg2;
    DateTime start = new DateTime(arg1);
    DateTime end = new DateTime(arg2);
    // Compute delta into appropriate units
    switch (units) {
        case YEARS:
            delta = Years.yearsBetween(start, end).getYears();
            break;
        case MONTHS:
            delta = Months.monthsBetween(start, end).getMonths();
            break;
        case WEEKS:
            delta = Weeks.weeksBetween(start, end).getWeeks();
            break;
        case DAYS:
            delta = Days.daysBetween(start, end).getDays();
            break;
        case HOURS:
            delta = Hours.hoursBetween(start, end).getHours();
            break;
        case MINUTES:
            delta = Minutes.minutesBetween(start, end).getMinutes();
            break;
        case SECONDS:
            delta = Double.valueOf(Math.floor(delta / 1000.0)).longValue();
            break;
        case MILLISECONDS:
            // Here for completeness but already calculated
            break;
        default:
            throw new IllegalArgumentException("Invalid units: "
                    + units + " See Functions.difference(Calendar,Calendar)"
                    + " for allowed values");
    }
    return Math.abs(delta);
}
 

@TLFunctionAnnotation("Returns the difference between dates")
public static final Long dateDiff(TLFunctionCallContext context, Date lhs, Date rhs, DateFieldEnum unit) {
	if (unit == DateFieldEnum.MILLISEC) { // CL-1087
		return lhs.getTime() - rhs.getTime();
	}
	
    long diff = 0;
    switch (unit) {
    case SECOND:
        // we have the difference in seconds
    	diff = (long) Seconds.secondsBetween(new DateTime(rhs.getTime()), new DateTime(lhs.getTime())).getSeconds();
        break;
    case MINUTE:
        // how many minutes'
    	diff = (long) Minutes.minutesBetween(new DateTime(rhs.getTime()), new DateTime(lhs.getTime())).getMinutes();
        break;
    case HOUR:
    	diff = (long) Hours.hoursBetween(new DateTime(rhs.getTime()), new DateTime(lhs.getTime())).getHours();
        break;
    case DAY:
        // how many days is the difference
    	diff = (long) Days.daysBetween(new DateTime(rhs.getTime()), new DateTime(lhs.getTime())).getDays();
        break;
    case WEEK:
        // how many weeks
    	diff = (long) Weeks.weeksBetween(new DateTime(rhs.getTime()), new DateTime(lhs.getTime())).getWeeks();
        break;
    case MONTH:
    	diff = (long) Months.monthsBetween(new DateTime(rhs.getTime()), new DateTime(lhs.getTime())).getMonths();
        break;
    case YEAR:
    	diff = (long) Years.yearsBetween(new DateTime(rhs.getTime()), new DateTime(lhs.getTime())).getYears();
        break;
    default:
        throw new TransformLangExecutorRuntimeException("Unknown time unit " + unit);
    }
    
    return diff;
}
 

public void setCurrentmonth(LocalDate currentmonth){
    if (currentmonth==null)return;

    LocalDate mindateobj=mindate.toDateTimeAtStartOfDay().dayOfMonth().withMinimumValue().toLocalDate();
    LocalDate current=currentmonth.dayOfMonth().withMaximumValue();
    int months= Months.monthsBetween(mindateobj,current).getMonths();
    if (viewPager.getCurrentItem()!=months){
        viewPager.setCurrentItem(months,false);
        viewPager.getAdapter().notifyDataSetChanged();
    }


}
 

public static int getDeltaSinceEpoch(int time, int tempRes) {
    int delta = 0;
    
    // Epoch
    MutableDateTime epoch = new MutableDateTime();
    epoch.setDate(0);
    
    DateTime dt = new DateTime(time*1000, DateTimeZone.UTC);
    
    switch(tempRes) {
    case FrameworkUtils.HOUR:
        Hours hours = Hours.hoursBetween(epoch, dt);
        delta = hours.getHours();
        break;
    case FrameworkUtils.DAY:
        Days days = Days.daysBetween(epoch, dt);
        delta = days.getDays();
        break;
    case FrameworkUtils.WEEK:
        Weeks weeks = Weeks.weeksBetween(epoch, dt);
        delta = weeks.getWeeks();
        break;
    case FrameworkUtils.MONTH:
        Months months = Months.monthsBetween(epoch, dt);
        delta = months.getMonths();
        break;
    case FrameworkUtils.YEAR:
        Years years = Years.yearsBetween(epoch, dt);
        delta = years.getYears();
        break;
    default:
        hours = Hours.hoursBetween(epoch, dt);
        delta = hours.getHours();
        break;
    }
    
    return delta;
}
 

public static int getTimeSteps(int tempRes, int startTime, int endTime) {
    
    if (startTime > endTime) {
        return 0;
    }
    
    int timeSteps = 0;
    DateTime start = new DateTime(((long)startTime)*1000, DateTimeZone.UTC);
    DateTime end = new DateTime(((long)endTime)*1000, DateTimeZone.UTC);
    
    switch(tempRes) {
    case FrameworkUtils.HOUR:
        timeSteps = Hours.hoursBetween(start, end).getHours();
        break;
    case FrameworkUtils.DAY:
        timeSteps = Days.daysBetween(start, end).getDays();
        break;
    case FrameworkUtils.WEEK:
        timeSteps = Weeks.weeksBetween(start, end).getWeeks();
        break;
    case FrameworkUtils.MONTH:
        timeSteps = Months.monthsBetween(start, end).getMonths();
        break;
    case FrameworkUtils.YEAR:
        timeSteps = Years.yearsBetween(start, end).getYears();
        break;
    default:
        timeSteps = Hours.hoursBetween(start, end).getHours();
        break;
    }
    timeSteps++;
    
    return timeSteps;
}
 

private void formatMonths(DateTime now, DateTime then, StringBuffer text) {
    int monthsBetween = Months.monthsBetween(now.toLocalDate(), then.toLocalDate()).getMonths();
    if (monthsBetween == 0) {
        if ((format & DAYS) != 0) {
            formatDays(now, then, text);
        } else {
            text.append(context.getString(R.string.thisMonth));
        }
    } else if (monthsBetween > 0) {    // in N months
        text.append(context.getResources().getQuantityString(R.plurals.carbon_inMonths, monthsBetween, monthsBetween));
    } else {    // N months ago
        text.append(context.getResources().getQuantityString(R.plurals.carbon_monthsAgo, -monthsBetween, -monthsBetween));
    }
}
 

@Override
public IntervalWindow assignWindow(Instant timestamp) {
  DateTime datetime = new DateTime(timestamp, timeZone);

  int monthOffset =
      Months.monthsBetween(startDate.withDayOfMonth(dayOfMonth), datetime).getMonths()
          / number
          * number;

  DateTime begin = startDate.withDayOfMonth(dayOfMonth).plusMonths(monthOffset);
  DateTime end = begin.plusMonths(number);

  return new IntervalWindow(begin.toInstant(), end.toInstant());
}
 

public CreditCard(CreditCardNumber number, String cardHolderName, Months expiryMonth, Years expiryYear) {
	super();
	this.number = number;
	this.cardHolderName = cardHolderName;
	this.expiryMonth = expiryMonth;
	this.expiryYear = expiryYear;
}
 

@Transactional(readOnly = false)
@SuppressWarnings("unchecked")
public void sendEmailReminders() {
	try {
		int currentDayOfWeek = new DateTime().getDayOfWeek();
		int currentDayOfMonth = new DateTime().getDayOfMonth();
		DateTime todayDateTime = new DateTime();

		for (SurveyDefinition surveyDefinition : surveyDefinitionDAO.findAllInternal()){
			if (surveyDefinition.getSendAutoReminders()&& surveyDefinition.getUsers().size()>0 && surveyDefinition.getStatusAsString().equals("P")) {
				Date  lastSentDate = surveyDefinition.getAutoReminderLastSentDate(); 
				switch (surveyDefinition.getAutoRemindersFrequency()) {
				case  WEEKLY:
					int weeks;
					if (lastSentDate !=null) {weeks = Weeks.weeksBetween(new DateTime(lastSentDate),todayDateTime).getWeeks();
					}
					
					else {weeks = 1000;}
					if (weeks >= surveyDefinition.getAutoRemindersWeeklyOccurrence()) {
						for (Day day : surveyDefinition.getAutoRemindersDays()) {
							if (day.getId().equals(new Long(currentDayOfWeek))) {
								sendEmailReminder(surveyDefinition);
								
							}
						}
					}
					break;
				case MONTHLY:
					int months;
					if (lastSentDate !=null) {months = Months.monthsBetween(new DateTime(lastSentDate), todayDateTime).getMonths();
					}
					else {months = 1000;}
					if (months>=surveyDefinition.getAutoRemindersMonthlyOccurrence() && surveyDefinition.getAutoRemindersDayOfMonth().equals(currentDayOfMonth)) {
						sendEmailReminder(surveyDefinition);
						}
					break;
				}
			}
		}
	}
	catch (RuntimeException e) {
		log.error(e.getMessage(),e);
	} 
}
 

public static int getMonthsBetween(String startDate, String endDate) {		
	DateTime s = new DateTime( getStrYMD(startDate.replaceAll("/", "-"), "-") ); 
	DateTime e = new DateTime( getStrYMD(endDate.replaceAll("/", "-"), "-") );		
	return Months.monthsBetween(s, e).getMonths();
}
 

@Test
public void creates_instance_of_Months() {
    Months months = fixture.create(Months.class);
    assertThat(months, notNullValue());
    assertThat(months, is(Months.months(12)));
}
 

/**
 * Protected setter to allow binding the expiration date.
 * 
 * @param date
 */
protected void setExpirationDate(LocalDate date) {

	this.expiryYear = Years.years(date.getYear());
	this.expiryMonth = Months.months(date.getMonthOfYear());
}
 

/**
 * 获得两个日期距离几个月
 *
 * @return
 */
public static int getIntervalMonths(LocalDate date1, LocalDate date2) {
    date1 = date1.withDayOfMonth(1);
    date2 = date2.withDayOfMonth(1);
    return Months.monthsBetween(date1, date2).getMonths();
}
 

/**
 * Calculates the number of months between the start and end-date. Note this
 * method is taking daylight saving time into account and has a performance
 * overhead.
 *
 * @param startDate the start date.
 * @param endDate   the end date.
 * @return the number of months between the start and end date.
 */
public static int monthsBetween( Date startDate, Date endDate )
{
    final Months days = Months.monthsBetween( new DateTime( startDate ), new DateTime( endDate ) );

    return days.getMonths();
}
 

@Test
public void months_between_two_dates_in_java_with_joda () {

	DateTime start = new DateTime(2005, 1, 1, 0, 0, 0, 0);
	DateTime end = new DateTime(2006, 1, 1, 0, 0, 0, 0);

	Months months = Months.monthsBetween(start, end);
	
	int monthsInYear = months.getMonths();
	
	assertEquals(12, monthsInYear);
}