Le ricorsioni sono intrinsecamente meno sicure delle iterazioni?

Java non ha un limite di profondità di ricorsione predefinito. Di conseguenza la ricorsione di seguito (un metodo fittizio che restituisce il valore) genera java.lang.StackOverflowError dopo le iterazioni 62844 (con statico) e 14002 (senza statico).

public static int testRecursion(int number) {
    if (number == 1) {
        return 1;
    } else {
        int result = 1 + testRecursion(number - 1);
        return result;
    }    
}


public int testIteration(int number){
int result = 0;
while (number > 0){
     result++;
     number--;
     }
return result;
}

Ho due dubbi:

1. Il metodo di iterazione funziona correttamente per tutti i valori positivi int, mentre la ricorsività genera un'eccezione
2. Le modifiche a un metodo modificano la profondità di ricorsione alla quale verrà generata l'eccezione.

La ricorsione in Java sembra un modo per aggiungere bug fluttuanti. La profondità di ricorsione è maggiore di un numero magico? Il programma genera un'eccezione. Metodo ricorsivo modificato dall'autore - la profondità di ricorsione consentita è diminuita e viene nuovamente generata un'eccezione.

Le ricorsioni sono ampiamente usate in Java. Significa che il limite di ricorsione è raramente raggiunto in situazioni pratiche? O ci sono alcuni metodi generali e robusti per gestire il limite di profondità di ricorsione mobile?

Ho letto queste domande:

• Come convertire questo ricorsivo problema a iterativo? L'algoritmo Line Simplification non riesce a essere eseguito a causa della massima profondità di ricorsione che viene colpita
• ricorsione o cicli while
• Quali sono i vantaggi della ricorsione rispetto a iterazione?

Ma nessuna di queste domande discute un problema di profondità di ricorsione in Java.