Increment Alpha-Numeric values but restrict to 3 characters

Question

The scenario is - I read the last line of a file, increment it by one and write it back.

The read and write has been done. I am finding it difficult to increment the alpha-numberic values as it has a few conditions.

The conditions are:

• It should only be 3 characters long
• Example : A01, A02.... A99, B01, B02.... B99..
• Once Z99 is reached it should be AA1, AA2, AA3...AA9, .....
• Then AB1, AB2,... AZ9
• So basically while incrementing the value should not go AA10 which makes it 4 characters

What I am doing now is separating the alphabets and integers, incrementing it and concatenating them back.

The code so far:

String[] part = lastLine.split("(?<=\\D)(?=\\d)");
    System.out.println(part[0]);
    System.out.println(part[1]);    

int numberOnly = Integer.parseInt(lastLine.replaceAll("[^0-9]", ""));
numberOnly++;

String lettersOnly = lastLine.replaceAll("[^A-Z]", "");

if (lettersOnly.length() > 1){

            String lastLetter = lettersOnly.substring(lettersOnly.length() - 1);

            if(lastLetter.equalsIgnoreCase("Z") && number.equalsIgnoreCase("9") ){

                String notLastLetter = lettersOnly.substring(lettersOnly.length() - 2);
                char d = lettersOnly.charAt(0);
                d++;
                System.out.println("Letters after increment more tan two : " +d);
                lettersOnly = Character.toString(d) + "Z";
            }

        }
            else{

            }



        System.out.println("Letters after increment : " +lettersOnly);

Any help would be greatly appreciated.

Answer 1

public class AlphaNumericCounter {
    String[] part;

    int counter; //Variable storing numeric part of counter

    String alpha; //Variable storing Alpha part of counter

    static String final_output = "A00"; // First Input considered as A00 and also the variable which will be store each count

    static boolean continueIncrement = true; //For running the loop till we reach ZZ9

    /* Def constructor */    
    public AlphaNumericCounter() {
    }

    /* Constructor called from main method with primary input A00 */
    public AlphaNumericCounter(String number) {
        part = number.split("(?<=\\D)(?=\\d)");
    }

    /* Function called each time from inside loop to generate next alphanumeric count */
    public void increment() {
        part = final_output.split("(?<=\\D)(?=\\d)");
        counter = Integer.valueOf(part[1]) + 1;
        alpha = part[0];
    }

    public String toString() {
        if (alpha.length() == 1){
            if (String.valueOf(counter).length() > 2){
                if ((int)alpha.charAt(0) + 1 > 90/*If Z encountered*/){
                    alpha = "AA";
                }else{
                    alpha = String.valueOf((char)((int)alpha.charAt(0) + 1));//Take Next Alphabet
                }
                counter = 1; //Reset counter to 1
            }
        }else{
            //We have AA, AB ... ZZ format of alpha
            if (String.valueOf(counter).length() > 1){
                if ((int)alpha.charAt(0) + 1 > 90 && (int)alpha.charAt(1) + 1 > 90){
                    continueIncrement = false;
                    System.out.println("NO MORE COMBINATION AVAILABLE"); //We reached ZZ
                    return "";
                }else if ((int)alpha.charAt(1) + 1 <= 90){
                    alpha = String.valueOf((char)((int)alpha.charAt(0))) + String.valueOf((char)((int)alpha.charAt(1) + 1));
                    counter = 1;
                }else if ((int)alpha.charAt(1) + 1 > 90){
                    if ((int)alpha.charAt(0) + 1 <= 90){
                        alpha = String.valueOf((char)((int)alpha.charAt(0) + 1)) + "A";
                        counter = 1;
                    }
                }
            }
        }

        generateString();

        return final_output;

    }

    private void generateString(){
        int l1 = String.valueOf(counter).length();
        int l2 = alpha.length();

        final_output = alpha + (l2 == 1 && l1 == 1 ? "0" : "") + String.valueOf(counter);
    }

    public static void main(String[] args) {
        AlphaNumericCounter lic = new AlphaNumericCounter(final_output);

        while (continueIncrement){
            lic.increment();
            System.out.println(lic);
        }
    }
}

Answer 2

What about incrementing each "digit" separatly from right to left and handle overvlow to the next digit:

String number;//number - is your originally string
char[] digits = number.toCharArray();
boolean overflow = true;
for(int i = 2; i >= 0; i--){
    if(overflow){
        switch(digits[i]){
            case 'Z':
                digits[i] = '0';
                overflow = true;
                break;
            case '9':
                digits[i] = 'A';
                overflow = false;
                break;
            default:
                digits[i]++;
                overflow = false;
        }
    }
}
if(overflow){
    //handle ZZZ overflow here
}
String result = new String(digits);