String array containing expiration credit card years from current year count 10 more years

Question

For the expiration date of credit/debit cards, I am using an array that contains all years since 2020 to 2030:

String[] expirationYearArray = { "2020", "2021", "2022", "2023", "2024", "2025", "2026", "2027", "2028", "2029", "2030" };

That is a bad approach because years are hard-coded. That means that after 3 years, in 2023, users will still have the option to choose 2020, 2021 and 2022 as the expiration date of credit cards. That is clearly wrong. What I want to do is to fill the array with Strings from current year to 10 more years from the current year. What I am thinking to do is to use a Java built-in function to get the current year. Then use a for loop to make 10 iterations and in each iteration convert from Int to String so that I convert 2020 to "2020" and then push that "2020" as the first element of the expirationYearArray array. The for or while loop would continue to do that until I reach the tenth iteration. Does this approach make sense to you? Please let me know if you see a different or more optimal option that may do the same with less code or if it makes sense to you the way I am envisioning it. Thank you.

Answer 1

tl;dr

In 2 lines, using streams and lambda syntax.

Year currentYear = Year.now( ZoneId.of( "Pacific/Auckland" ) );  // Determining the current year requires a time zone when near the ending/beginning of the year.
List < Year > years =                                            // A list of objects of the class `Year`. Better to use a specific type than use a mere integer number.
        IntStream                                                // Generates a stream of `int` primitive numbers.
        .range(                                                  // Get numbers from the specified beginning to the specified ending.
            currentYear.getValue() ,                             // Get `int` number of the current year.
            currentYear.plusYears( 10 ).getValue()               // Yet the `int` number of a later year.
        )                                                        // Returns a `IntStream` object.
        .boxed()                                                 // Converts the `int` primitive values into a stream of `Integer` objects.
        .map( integer -> Year.of( integer ) )                    // Uses each `Integer` object to instantiate a `Year` object. The `Integer` object is auto-boxed back into an `int` primitive`. Primitives cannot be mapped in a stream with a lambda. So we had to do this funky `int` -> `Integer` -> `int` conversion juggling.
        .collect( Collectors.toList() )                          // Gather the `Year` objects produced by the `map` method into a `List` collection.
;

In a few lines, using conventional syntax.

Year currentYear = Year.now( ZoneId.of( "Asia/Tokyo" ) ) ;
List< Year > years = new ArrayList<>( 10 ) ;
for( int i = 0 ; i < 10 ; i ++ ) 
{
    years.add( currentYear.plusYears( i ) ) ;
}

See this code run live at IdeOne.com.

years.toString(): [2020, 2021, 2022, 2023, 2024, 2025, 2026, 2027, 2028, 2029]

java.time.Year

Java offers a specific class to represent a year, appropriately named Year. I suggest using that class rather than a mere integer to make your code type-safe and more self-documenting.

Time zone is crucial

Getting the current year requires a time zone. For any given moment, the date various around the world by time zone. While "tomorrow" in Tokyo Japan, it is simultaneously "yesterday" in Montréal Québec.

Therefore, around the last day / first day of the year, it may be "next year" in Tokyo Japan while simultaneously "last year" in Montréal Québec. So when determining the current year, specify the desired/expected time zone.

ZoneId z = ZoneId.of( "America/Montreal" ) ;
Year currentYear = Year.now( z ) ;

Get your next ten years by iterating.

List< Year > years = new ArrayList<>( 10 ) ;
Year year = currentYear ;
for( int i = 0 ; i < 10 ; i ++ ) 
{
    // Remember this year.
    years.add( year ) ;
    // Set up the next loop.
    year = currentYear.plusYears( i ) ;
}

Make an unmodifiable list from that ArrayList by calling List.copyOf.

List< Year > years = List.copyOf( years ) ;  // Returns an unmodifiable `List`, with adding/removing elements disallowed.

java.time.Month

For expiration year-month, you also need the a widget for picking month. There you can use the Month class.

List< Month > months = List.copyOf( Month.values() ) 

The toString method of Month gives you the name of the month in English in all uppercase, based on the name of enum element. You might want to make a list of localized names for display to users.

List< String > monthsLocalized = new ArrayList<>( months.size() ) ;
Locale locale = Locale.CANADA_FRENCH ;
for( Month month : months ) 
{
    monthsLocalized.add( month.getDisplayName( TextStyle.FULL , locale ) ;
}
monthsLocalized = List.copyOf( monthsLocalized ) ;

java.time.YearMonth

For your final result of a user picking a year and a month, use YearMonth. Oddly, the YearMonth factory methods do not take a Year object, only a mere integer. So call Year::getValue to get the number.

YearMonth yearMonth = YearMonth.of( selectedYear.getValue() , selectedMonth ) ;

Premature Optimization

You expressed concern about optimizing for performance. This is not the kind of code you need to optimize. Indeed, do not fall into the trap of premature optimization. Even the most experienced programmers have been shown to be notoriously bad at intuitively guessing where the bottlenecks live in their codebase. Optimize only after having empirically proven a significant slowdown that materially affects the performance of your code and the running of the business. Most often, writing simple straightforward short lines of Java code will result in highly optimized executing code after the Java compiler and runtime optimizer (HotSpot, OpenJ9) do their job.

About java.time

The java.time framework is built into Java 8 and later. These classes supplant the troublesome old legacy date-time classes such as java.util.Date, Calendar, & SimpleDateFormat.

To learn more, see the Oracle Tutorial. And search Stack Overflow for many examples and explanations. Specification is JSR 310.

The Joda-Time project, now in maintenance mode, advises migration to the java.time classes.

You may exchange java.time objects directly with your database. Use a JDBC driver compliant with JDBC 4.2 or later. No need for strings, no need for java.sql.* classes.

Where to obtain the java.time classes?

• Java SE 8, Java SE 9, Java SE 10, Java SE 11, and later - Part of the standard Java API with a bundled implementation.
  • Java 9 adds some minor features and fixes.
• Java SE 6 and Java SE 7
  • Most of the java.time functionality is back-ported to Java 6 & 7 in ThreeTen-Backport.
• Android
  • Later versions of Android bundle implementations of the java.time classes.
  • For earlier Android (<26), the ThreeTenABP project adapts ThreeTen-Backport (mentioned above). See How to use ThreeTenABP….

Answer 2

It's a good idea to avoid hard-coding the list of years.

As for the range of years you generate, you might check with your card processor for the rules. For example, expired cards can be charged in some cases when they were setup for a recurring charge, like a subscription, but they probably shouldn't be accepted for new plans. Likewise, credit cards typically expire sooner than 10 years; your processor may reject cards with an unrealistically long expiration.

Again, processors may not be consistent in the enforcement of time zones. Some might consider a year to end when it ends in their local time zone, others might use UTC. The most lenient policy would be to use the "anywhere on earth" zone, with an offset of -12:00 from UTC.

To make your logic testable, pass it a Clock instance. Typically, the clock would be the system default clock, but in this case, you might set the zone to be "anywhere in the world". By passing a clock, you can remove the dependency on the actual time, and test how your calculation will behave at any time.

private static final ZoneOffset aoe = ZoneOffset.ofHours(-12);

private static final DateTimeFormatter fmt = DateTimeFormatter.ofPattern("uuuu");

public static void main(String[] args) {
    Clock clock = Clock.system(aoe);
    List<Year> years = nextYears(clock, 10L);
    years.stream().map(fmt::format).forEach(System.out::println);
}

private List<Year> nextYears(Clock clock, long count) {
    return Stream.iterate(Year.now(clock), year -> year.plusYears(1L))
        .limit(count)
        .collect(Collectors.toList());
}

Answer 3

Here are several variants:

  public static void main(String[] args) {

    System.out.println(Arrays.toString(getExpirationYears(LocalDateTime.now().getYear())));
    System.out.println(Arrays.toString(getExpirationYears(Calendar.getInstance().get(Calendar.YEAR))));
    System.out.println(Arrays.toString(getExpirationYears(1900 + new Date().getYear())));
    System.out.println(Arrays.toString(getExpirationYearByStreams(1900 + new Date().getYear())));
}

static String[] getExpirationYears(int year) {
    String[] expirationYearArray = new String[10];
    for (int i = 0; i < expirationYearArray.length; i++) {
        expirationYearArray[i] = String.valueOf(year + i);
    }
    return expirationYearArray;
}


static String[] getExpirationYearByStreams(int year) {
   return IntStream.range(year, year+10)
            .boxed()
            .map(String::valueOf)
            .toArray(String[]::new);

}

Answer 4

This is how I achieved it in my code, following Nonika's advice (see his answer):

package com.myapp;
..........
public class Payment extends BaseActivity implements ResponseListener {
    ..........
    int currentYear = Calendar.getInstance().get(Calendar.YEAR);
    String[] cardYearArray = new String[10];
    ..........
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        ..........
        cardYearArray=getExpirationYears(currentYear);
        SpinnerAdapter creditCardYearAdapter = new SpinnerAdapter(Payment.this,
            cardYearArray);
        ..........
    }
    static String[] getExpirationYears(int year) {
        String[] expirationYearArray = new String[10];
        for (int i = 0; i < expirationYearArray.length; i++) {
            expirationYearArray[i] = String.valueOf(year + i);
        }
        return expirationYearArray;
    }
    ..........
}

Now I see the years appearing correctly as I needed it: