[JAVA] Generare sequenza in modo crescente

[miao84]

Avrei bisogno di una funzione che ogni volta che viene richiamata restituisca un numero crescente rispetto a quello che ha generato prima, di sei cifre. Ad esempio il primo numero sarà 000001 poi 000002 e cosi via..è possibile?

[banryu79]

Originariamente inviato da miao84

Avrei bisogno di una funzione che ogni volta che viene richiamata restituisca un numero crescente rispetto a quello che ha generato prima, di sei cifre. Ad esempio il primo numero sarà 000001 poi 000002 e cosi via..è possibile?

Certo, puoi implementarti una classe che faccia quanto hai richiesto (in Java le "funzioni" non esitono, esistono i "metodi di istanza" e i "metodi di classe" quindi è implicato l'uso delle classi).

Un esempio:

public class AutoCounter
{
    private int counter;
    private final int maxCounter;
    private final int maxDigit;

    public AutoCounter(int max) {
        maxCounter = max;
        maxDigit = countDigit(max);
        counter = 1;
    }

    // restituisce il numero di cifre che formano il numero intero in base
    // 10 passato come argometo
    private int countDigit(int number) {
        String s = Integer.toString(number);
        return s.length();
    }

    // restituisce tutte le maxDigit cifre del numero corrente e ne incrementa il valore
    public String getNext() {
        int value = counter;
        incrementCounter();
        return doCustomFormatting(value);
    }

    private void incrementCounter() {
        if (counter < maxCounter) {
            counter++;
        }
//        else {
//            String msg = "Impossibile incrementare il contatore oltre il valore massimo";
//            throw new RuntimeException(msg);
//        }
    }

    // formatta il numero passato in ingresso in una stringa in modo che sia sempre
    // formata dallo stesso numero di cifre di maxCounter.
    // Esempio: con maxCounter = 999999 (6 cifre) e value = 13;
    // la stringa restituita deve essere "000013".
    private String doCustomFormatting(int value) {
        int valueDigit = countDigit(value);
        int leadingZeroes = maxDigit - valueDigit;
        String s = zeroesString(leadingZeroes) + String.valueOf(value);
        return s;
    }
    
    // restituisce una stringa formata da tanti zero quanti
    // indicati da leadingZeroes
    private String zeroesString(int leadingZeroes) {
        StringBuilder sb = new StringBuilder();
        while(leadingZeroes > 0) {
            sb.append("0");
            leadingZeroes--;
        }
        return sb.toString();
    }


    // Esempio d'uso:
    public static void main(String... args) {
        //AutoCounter counter = new AutoCounter(999999);
        AutoCounter counter = new AutoCounter(20);
        for (int i=0; i<30; i++) {
            System.out.println(counter.getNext());
        }
    }
}

In questo esempio, nel caso in cui venga "sforato" il limite impostato per il contatore il contatore stesso non viene più incrementato ma restituisce sempre il valore massimo; un'alternativa può essere quella di lanciare un'eccezione (parte commentata nel codice).