Profundidad de anidamiento de bucles

Actualizado el 15 de noviembre de 2026

Sigla LOOP_NEST
Aspecto «Complejidad»
Se mide en método
Tipo de valor máximo (entero, mínimo 0): el nivel más profundo de bucles del método
Dirección más alto es peor
Stau Metro LoopNestingDepth

En pocas palabras

Dice cuántos bucles hay, como mucho, uno dentro de otro. Un método sin bucles vale 0; con un bucle suelto, 1; con un bucle dentro de otro, 2. Los bucles que van uno detrás de otro no suman: solo cuenta lo profundo.

Qué mide

Mide dos cosas a la vez:

  • Dificultad de lectura. Cada bucle interior obliga a seguir varios índices o elementos a la vez y a saber qué valor tiene cada uno en cada vuelta.
  • Coste potencial. Si cada bucle recorre algo del tamaño de la entrada, dos bucles anidados hacen del orden de n2n^2 vueltas y tres, de n3n^3. Un valor alto no prueba que el método sea lento, pero señala dónde mirar cuando lo es.

Cómo se calcula

Se recorre el método llevando la cuenta de cuántos bucles rodean al punto actual. Cada bucle suma 1 al entrar y resta 1 al salir; el valor es el máximo alcanzado. Cuentan for, for mejorado, while y do … while. Las demás sentencias (if, switch, try) no suman ni cortan la cuenta: un while dentro de un if que está dentro de un for está en el nivel 2.

No cuentan como bucles las iteraciones escondidas en llamadas: lista.forEach(…), una cadena de streams o una llamada a contains sobre una lista recorren datos, pero no son sentencias de bucle.

Ejemplo

int countPairs(int[][] rows, int target) {
    int count = 0;
    for (int[] row : rows) {                          // nivel 1
        for (int i = 0; i < row.length; i++) {        // nivel 2
            int j = i + 1;
            while (j < row.length) {                  // nivel 3
                if (row[i] + row[j] == target) {      // el if no cuenta
                    count++;
                }
                j++;
            }
        }
    }
    for (int[] row : rows) {                          // vuelve al nivel 1
        count -= row.length == 0 ? 1 : 0;
    }
    return count;
}

El método vale 3: el while está dentro de dos bucles. El segundo for mejorado, al ir después y no dentro, no cambia el resultado.

Cómo interpretarla

Stau Metro no le asigna umbrales de referencia. Como lectura orientativa:

  • 1: lo corriente.
  • 2: frecuente y a menudo legítimo (recorrer una matriz, comparar dos colecciones). Conviene comprobar que el coste cuadrático no importa con los tamaños reales de los datos.
  • 3 o más: si cada bucle recorre la entrada, el coste es del orden de n3n^3. Merece una revisión, tanto por legibilidad como por rendimiento.

Qué hacer con un valor alto:

  • Extrae el bucle interior a un método con un nombre que diga qué calcula (countPairsInRow(row, target)).
  • Cambia el algoritmo o la estructura de datos. Muchas búsquedas dentro de un bucle desaparecen con un HashMap o un HashSet preparado antes.
  • Comprueba los tamaños. Si el bucle interior siempre recorre tres elementos, el anidamiento no es un problema de rendimiento, aunque pueda serlo de lectura.

Relación con otras métricas

En las herramientas

Stau Metro (LoopNestingDepth, a nivel de método). Cuenta for, for mejorado, while y do … while. Un bucle suelto ya vale 1: el valor es la profundidad del bucle más interior, no el número de bucles que están dentro de otros. Los bucles de las lambdas y de los métodos de clases anónimas o locales declaradas dentro del método cuentan para el método que las contiene, sumando a los bucles que las rodean; esos métodos no tienen valor propio. No se calcula para métodos abstractos; los constructores cuentan como métodos.

Checkstyle (NestedForDepth). Limita el anidamiento de bucles for (en su código fuente, la palabra clave for, que incluye el for mejorado); while y do no cuentan. Cuenta la profundidad desde 0 y su máximo por defecto es 1, así que avisa a partir del tercer for anidado.

MetricsReloaded (plugin de IntelliJ). Calcula LOOP_NEST como la profundidad máxima de anidamiento de los bucles de cada método. Su descripción nombra for, while y do … while; su código cuenta también el for mejorado.

Referencias