How to get corresponding quarter of previous year in Scala

Question

I have a date string with me in the format - "20202" ["yyyyQ"]. Is there a way to get the corresponding quarter of previous year ?

ex- for 20202 , it should be 20192

Answer 1

An alternative to the other answers is using my lib Time4J and its class CalendarQuarter. Example:

    String input = "20202";

    ChronoFormatter<CalendarQuarter> f =
        ChronoFormatter.ofPattern(
            "yyyyQ", 
            PatternType.CLDR, 
            Locale.ENGLISH, 
            CalendarQuarter.chronology());
    CalendarQuarter cq = f.parse(input);
    CalendarQuarter quarterInPreviousYear = cq.minus(Years.ONE);
    System.out.println(quarterInPreviousYear); // 2019-Q2

Two main advantages of this solution are:

• Calendar quarters are also intervals so it is easy to iterate over them daily.
• Internationalization is supported for more than 90 languages, even style-based.

Interval example:

    for (PlainDate date : quarterInPreviousYear) {
        System.out.println(date);
    }

Output:

> 2019-04-01 
> 2019-04-02 
> 2019-04-03
> ...

Printing example in Danish:

    ChronoFormatter<CalendarQuarter> printer =
        ChronoFormatter.ofPattern(
            "QQQQ y", 
            PatternType.CLDR, 
            new Locale("da"), 
            CalendarQuarter.chronology());
    System.out.println(printer.print(quarterInPreviousYear)); // 2. kvartal 2019

Answer 2

Update (thanks to Ole V.V.)

Given below is pure DateTimeFormatter solution:

import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeFormatterBuilder;
import java.time.temporal.ChronoField;
import java.time.temporal.IsoFields;

import org.threeten.extra.YearQuarter;

public class Main {
    public static void main(String[] args) {
        // Given string
        String str = "20202";

        DateTimeFormatter dtf = new DateTimeFormatterBuilder()
                                .appendValue(ChronoField.YEAR, 4)
                                .appendValue(IsoFields.QUARTER_OF_YEAR, 1)
                                .toFormatter();

        // Parse the converted string
        YearQuarter yearQuarter = YearQuarter.parse(str, dtf);
        System.out.println(yearQuarter.format(dtf));

        // A year ago
        System.out.println(yearQuarter.minusYears(1).format(dtf));
    }
}

Output:

20202
20192

Original answer:

I recommend you do it using ThreeTenExtra library. The only problem that you will have to deal with is converting the given string into yyyy-Q format which you can easily do using a regex as shown below:

import java.time.format.DateTimeFormatter;

import org.threeten.extra.YearQuarter;

public class Main {
    public static void main(String[] args) {
        // Given string
        String str = "20202";

        // Convert the given string into yyyy-Q format
        str = str.replaceAll("(\\d{4})(\\d{1,2})", "$1-$2");

        // Parse the converted string
        YearQuarter yearQuarter = YearQuarter.parse(str, DateTimeFormatter.ofPattern("yyyy-Q"));

        // Define output format
        DateTimeFormatter outputFormat = DateTimeFormatter.ofPattern("uuuuQ");
        System.out.println(yearQuarter.format(outputFormat));

        // A year ago
        System.out.println(yearQuarter.minusYears(1).format(outputFormat));
    }
}

Output:

20202
20192

Explanation of the regex:

1. (\\d{4})(\\d{1,2}) specifies two groups: the first group having 4 digits and the second group having one or two digit(s)
2. The replacement string $1-$2 specifies group(1)-group(2)

Answer 3

Here is a short Scastie showing one approach.

val d = "20202"
(d.substring(0,4).toInt - 1).toString + d.substring(4)  // 20192: String

Answer 4

I thought of using some Date time formatter to solve this, …

Do! I would immediately prefer the solution by Arvind Kumar Avinash using YearQuarter of the ThreeTen Extra library. In case you find it overkill to add an external library to your project (or your team or boss thinks so), we can also do without it, only less elegantly. Here’s a Java solution that I think you can hand translate to Scala:

    DateTimeFormatter quarterFormatter = new DateTimeFormatterBuilder()
            .appendValue(ChronoField.YEAR, 4)
            .appendValue(IsoFields.QUARTER_OF_YEAR, 1)
            .parseDefaulting(IsoFields.DAY_OF_QUARTER, 1)
            .toFormatter();
    
    String quarterString = "20202";
    
    YearMonth firstMonthOfQuarter
            = YearMonth.parse(quarterString, quarterFormatter);
    YearMonth firstMonthOfQuarterLastYear = firstMonthOfQuarter.minusYears(1);
    String quarterPreviousYearString
            = firstMonthOfQuarterLastYear.format(quarterFormatter);
    
    System.out.println(quarterPreviousYearString);

Output is the desired:

20192

Advantages of the right data type

Could you please explain what advantages usage of DateTime may have in this case over simple string manipulation and conversion to int?

Edit: When you need to read some number, for example an ID number, from input and print it again on output, do you read it into an int or a String? Most of use int (or long or BigInteger). Why? Your question is similar.

The advantages of using YearQuarter or YearMonth include (and probably are not limited to):

• Self-explanatory code: val d = "20202" tells nothing about the meaning of this piece of data. A variable of type YearQuarter very clearly tells the reader that this variable hold a quarter of year. YearMonth is the best approximation in the standard Java library and already less clear about why we are using it here, but still a sizeable advantage over String.
• Validation for free: By parsing the string using the formatter, if the string doesn’t denote a valid quarter of year, we will be sure to be notified through an exception.
• Further validation cheap: If you want further validation, for example the quarter must be after 2nd quarter of 2019 but not in the future, this is easy and straightforward with java.time (it can be done with the string too, but the code will be hard to read unless you explain over several lines of comment what you’ve got going).
• Ready for future requirements: If one day you need to do something more with the quarter, like for example finding the first and the last day of the quarter or the quarter before it, this will be a walk in the park because the class offers a very rich set of operations.

Link

Oracle tutorial: Date Time explaining how to use java.time.