Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   *  Copyright 2001-2010 Stephen Colebourne
   *
   *  Licensed 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.
  */
 package org.joda.time;
 
 import  org.joda.convert.FromString;
 import  org.joda.convert.ToString;
An immutable time period representing a number of months.

Months is an immutable period that can only store months. It does not store years, days or hours for example. As such it is a type-safe way of representing a number of months in an application.

The number of months is set in the constructor, and may be queried using getMonths(). Basic mathematical operations are provided - plus(), minus(), multipliedBy() and dividedBy().

Months is thread-safe and immutable.

Author(s):
Stephen Colebourne
Since:
1.4
 
 public final class Months extends BaseSingleFieldPeriod {

    
Constant representing zero months.
 
     public static final Months ZERO = new Months(0);
    
Constant representing one month.
 
     public static final Months ONE = new Months(1);
    
Constant representing two months.
 
     public static final Months TWO = new Months(2);
    
Constant representing three months.
 
     public static final Months THREE = new Months(3);
    
Constant representing four months.
 
     public static final Months FOUR = new Months(4);
    
Constant representing five months.
 
     public static final Months FIVE = new Months(5);
    
Constant representing six months.
 
     public static final Months SIX = new Months(6);
    
Constant representing seven months.
 
     public static final Months SEVEN = new Months(7);
    
Constant representing eight months.
 
     public static final Months EIGHT = new Months(8);
    
Constant representing nine months.
 
     public static final Months NINE = new Months(9);
    
Constant representing ten months.
 
     public static final Months TEN = new Months(10);
    
Constant representing eleven months.
 
     public static final Months ELEVEN = new Months(11);
    
Constant representing twelve months.
 
     public static final Months TWELVE = new Months(12);
    
Constant representing the maximum number of months that can be stored in this object.
 
     public static final Months MAX_VALUE = new Months(.);
    
Constant representing the minimum number of months that can be stored in this object.
 
     public static final Months MIN_VALUE = new Months(.);

    
The parser to use for this class.
 
     private static final PeriodFormatter PARSER = ISOPeriodFormat.standard().withParseType(PeriodType.months());
    
Serialization version.
 
     private static final long serialVersionUID = 87525275727380867L;
 
     //-----------------------------------------------------------------------
     
Obtains an instance of Months that may be cached. Months is immutable, so instances can be cached and shared. This factory method provides access to shared instances.

Parameters:
months the number of months to obtain an instance for
Returns:
the instance of Months
 
     public static Months months(int months) {
         switch (months) {
             case 0:
                 return ;
             case 1:
                 return ;
             case 2:
                 return ;
             case 3:
                 return ;
             case 4:
                return ;
            case 5:
                return ;
            case 6:
                return ;
            case 7:
                return ;
            case 8:
                return ;
            case 9:
                return ;
            case 10:
                return ;
            case 11:
                return ;
            case 12:
                return ;
            case .:
                return ;
            case .:
                return ;
            default:
                return new Months(months);
        }
    }
    //-----------------------------------------------------------------------
    
Creates a Months representing the number of whole months between the two specified datetimes. This method corectly handles any daylight savings time changes that may occur during the interval.

Parameters:
start the start instant, must not be null
end the end instant, must not be null
Returns:
the period in months
Throws:
IllegalArgumentException if the instants are null or invalid
    public static Months monthsBetween(ReadableInstant startReadableInstant end) {
        int amount = BaseSingleFieldPeriod.between(startend, DurationFieldType.months());
        return Months.months(amount);
    }

    
Creates a Months representing the number of whole months between the two specified partial datetimes.

The two partials must contain the same fields, for example you can specify two LocalDate objects.

Parameters:
start the start partial date, must not be null
end the end partial date, must not be null
Returns:
the period in months
Throws:
IllegalArgumentException if the partials are null or invalid
    public static Months monthsBetween(ReadablePartial startReadablePartial end) {
        if (start instanceof LocalDate && end instanceof LocalDate)   {
            Chronology chrono = DateTimeUtils.getChronology(start.getChronology());
            int months = chrono.months().getDifference(
                    ((LocalDateend).getLocalMillis(), ((LocalDatestart).getLocalMillis());
            return Months.months(months);
        }
        int amount = BaseSingleFieldPeriod.between(startend);
        return Months.months(amount);
    }

    
Creates a Months representing the number of whole months in the specified interval. This method corectly handles any daylight savings time changes that may occur during the interval.

Parameters:
interval the interval to extract months from, null returns zero
Returns:
the period in months
Throws:
IllegalArgumentException if the partials are null or invalid
    public static Months monthsIn(ReadableInterval interval) {
        if (interval == null)   {
            return .;
        }
        int amount = BaseSingleFieldPeriod.between(interval.getStart(), interval.getEnd(), DurationFieldType.months());
        return Months.months(amount);
    }

    
Creates a new Months by parsing a string in the ISO8601 format 'PnM'.

The parse will accept the full ISO syntax of PnYnMnWnDTnHnMnS however only the months component may be non-zero. If any other component is non-zero, an exception will be thrown.

Parameters:
periodStr the period string, null returns zero
Returns:
the period in months
Throws:
IllegalArgumentException if the string format is invalid
    @FromString
    public static Months parseMonths(String periodStr) {
        if (periodStr == null) {
            return .;
        }
        Period p = .parsePeriod(periodStr);
        return Months.months(p.getMonths());
    }
    //-----------------------------------------------------------------------
    
Creates a new instance representing a number of months. You should consider using the factory method months(int) instead of the constructor.

Parameters:
months the number of months to represent
    private Months(int months) {
        super(months);
    }

    
Resolves singletons.

Returns:
the singleton instance
    private Object readResolve() {
        return Months.months(getValue());
    }
    //-----------------------------------------------------------------------
    
Gets the duration field type, which is months.

Returns:
the period type
    public DurationFieldType getFieldType() {
        return DurationFieldType.months();
    }

    
Gets the period type, which is months.

Returns:
the period type
    public PeriodType getPeriodType() {
        return PeriodType.months();
    }
    //-----------------------------------------------------------------------
    
Gets the number of months that this period represents.

Returns:
the number of months in the period
    public int getMonths() {
        return getValue();
    }
    //-----------------------------------------------------------------------
    
Returns a new instance with the specified number of months added.

This instance is immutable and unaffected by this method call.

Parameters:
months the amount of months to add, may be negative
Returns:
the new period plus the specified number of months
Throws:
ArithmeticException if the result overflows an int
    public Months plus(int months) {
        if (months == 0) {
            return this;
        }
        return Months.months(FieldUtils.safeAdd(getValue(), months));
    }

    
Returns a new instance with the specified number of months added.

This instance is immutable and unaffected by this method call.

Parameters:
months the amount of months to add, may be negative, null means zero
Returns:
the new period plus the specified number of months
Throws:
ArithmeticException if the result overflows an int
    public Months plus(Months months) {
        if (months == null) {
            return this;
        }
        return plus(months.getValue());
    }
    //-----------------------------------------------------------------------
    
Returns a new instance with the specified number of months taken away.

This instance is immutable and unaffected by this method call.

Parameters:
months the amount of months to take away, may be negative
Returns:
the new period minus the specified number of months
Throws:
ArithmeticException if the result overflows an int
    public Months minus(int months) {
        return plus(FieldUtils.safeNegate(months));
    }

    
Returns a new instance with the specified number of months taken away.

This instance is immutable and unaffected by this method call.

Parameters:
months the amount of months to take away, may be negative, null means zero
Returns:
the new period minus the specified number of months
Throws:
ArithmeticException if the result overflows an int
    public Months minus(Months months) {
        if (months == null) {
            return this;
        }
        return minus(months.getValue());
    }
    //-----------------------------------------------------------------------
    
Returns a new instance with the months multiplied by the specified scalar.

This instance is immutable and unaffected by this method call.

Parameters:
scalar the amount to multiply by, may be negative
Returns:
the new period multiplied by the specified scalar
Throws:
ArithmeticException if the result overflows an int
    public Months multipliedBy(int scalar) {
        return Months.months(FieldUtils.safeMultiply(getValue(), scalar));
    }

    
Returns a new instance with the months divided by the specified divisor. The calculation uses integer division, thus 3 divided by 2 is 1.

This instance is immutable and unaffected by this method call.

Parameters:
divisor the amount to divide by, may be negative
Returns:
the new period divided by the specified divisor
Throws:
ArithmeticException if the divisor is zero
    public Months dividedBy(int divisor) {
        if (divisor == 1) {
            return this;
        }
        return Months.months(getValue() / divisor);
    }
    //-----------------------------------------------------------------------
    
Returns a new instance with the months value negated.

Returns:
the new period with a negated value
Throws:
ArithmeticException if the result overflows an int
    public Months negated() {
        return Months.months(FieldUtils.safeNegate(getValue()));
    }
    //-----------------------------------------------------------------------
    
Is this months instance greater than the specified number of months.

Parameters:
other the other period, null means zero
Returns:
true if this months instance is greater than the specified one
    public boolean isGreaterThan(Months other) {
        if (other == null) {
            return getValue() > 0;
        }
        return getValue() > other.getValue();
    }

    
Is this months instance less than the specified number of months.

Parameters:
other the other period, null means zero
Returns:
true if this months instance is less than the specified one
    public boolean isLessThan(Months other) {
        if (other == null) {
            return getValue() < 0;
        }
        return getValue() < other.getValue();
    }
    //-----------------------------------------------------------------------
    
Gets this instance as a String in the ISO8601 duration format.

For example, "P4M" represents 4 months.

Returns:
the value as an ISO8601 string
    @ToString
    public String toString() {
        return "P" + String.valueOf(getValue()) + "M";
    }
New to GrepCode? Check out our FAQ X