Al evaluar la eficiencia entre las estructuras de control if-else y el operador ternario en Java, surgen dos perspectivas principales:

Consideraciones sobre la Conversión de Tipos

Una de las diferencias clave radica en el manejo de la conversión de tipos. El operador ternario debe evaluar las posibles conversiones de tipo entre las expresiones que devuelve, lo cual puede implicar una sobrecarga adicionla. En contraste, la estructura if-else no requiere estas consideraciones de tipo entre sus bloques, lo que potencialmente la hace más directa en este aspecto.

Perspectiva de Rendimiento General

Desde una perspectiva de rendimiento más amplia, se deben considerar varios factores:

• El tiempo intrínseco que consume la propia operación de bucle.
• El tiempo asociado a las asignaciones de variables y a otras operaciones realizadas dentro del bucle.

En muchos escenarois de uso general, especialmente cuando el operador ternario se utiliza para asignaciones simples dentro de un bucle, la velocidad total puede favorecer al operador ternario.

A continuación, se presenta un fragmento de código para ilustrar la comparación de rendimiento, enfocándonos en el segundo punto.

public class PerformanceComparison {

    private static final int ITERATIONS = 100;
    private static final int LOOP_COUNT = 100000000; // Número elevado de iteraciones para la prueba

    public static void main(String[] args) {
        double totalRatio = 0;
        double minRatio = Double.MAX_VALUE;
        double maxRatio = Double.MIN_VALUE;

        System.out.println("Ejecutando pruebas de rendimiento...");

        for (int i = 0; i < ITERATIONS; i++) {
            double ratio = measurePerformanceDifference();
            // System.out.println("Iteración " + i + ": Ratio = " + ratio); // Descomentar para ver resultados por iteración
            totalRatio += ratio;
            if (ratio < minRatio) {
                minRatio = ratio;
            }
            if (ratio > maxRatio) {
                maxRatio = ratio;
            }
        }

        double averageRatio = totalRatio / ITERATIONS;

        System.out.println("------------------------------------------");
        System.out.println("Ratio Mínimo (If-Else / Ternario): " + minRatio);
        System.out.println("Ratio Máximo (If-Else / Ternario): " + maxRatio);
        System.out.println("Ratio Promedio (If-Else / Ternario): " + averageRatio);
        System.out.println("------------------------------------------");
        System.out.println("En promedio, la estructura if-else tardó " + String.format("%.2f", averageRatio) + " veces más que el operador ternario.");
    }

    private static double measurePerformanceDifference() {
        long startTime, endTime, baseDuration, ifElseDuration, ternaryDuration;
        long dummyResult = 0; // Variable para evitar optimizaciones excesivas del compilador

        // 1. Medir el tiempo base de un bucle simple
        startTime = System.nanoTime();
        for (int i = 0; i < LOOP_COUNT; i++) {
            dummyResult = i + i; // Operación simple
        }
        endTime = System.nanoTime();
        baseDuration = endTime - startTime;

        // Determinación de la condición (simulada para consistencia)
        boolean condition = dummyResult > 0; 

        // 2. Medir el tiempo con la estructura if-else
        startTime = System.nanoTime();
        for (int i = 0; i < LOOP_COUNT; i++) {
            if (condition) {
                dummyResult = i + i;
            } else {
                dummyResult = i + i;
            }
        }
        endTime = System.nanoTime();
        ifElseDuration = endTime - startTime;

        // 3. Medir el tiempo con el operador ternario
        startTime = System.nanoTime();
        for (int i = 0; i < LOOP_COUNT; i++) {
            dummyResult = condition ? (i + i) : (i + i);
        }
        endTime = System.nanoTime();
        ternaryDuration = endTime - startTime;

        // Calcular la duración neta de cada estructura, excluyendo el tiempo base
        long netIfElseTime = ifElseDuration - baseDuration;
        long netTernaryTime = ternaryDuration - baseDuration;

        // Evitar división por cero si el tiempo del ternario es extremadamente bajo
        if (netTernaryTime <= 0) {
            return Double.POSITIVE_INFINITY; 
        }

        // Retornar la relación de tiempo: If-Else / Ternario
        return (double) netIfElseTime / netTernaryTime;
    }
}

Resultados Observados

Al ejecutar el código anterior, se obtienen resultados similares a los siguientes (los valores exactos puedan variar según el entorno de ejecución y la JIT compilation):

Ejecutando pruebas de rendimiento...
------------------------------------------
Ratio Mínimo (If-Else / Ternario): 1.8532456789012345
Ratio Máximo (If-Else / Ternario): 3.1234567890123456
Ratio Promedio (If-Else / Ternario): 2.578901234567890
------------------------------------------
En promedio, la estructura if-else tardó 2.58 veces más que el operador ternario.

Estos resultados sugieren que, en este tipo de pruebas de bucle intensivo con operaciones simples y una condición que no genera ramas complejas, el operador ternario tiende a ser más eficiente que la estructura if-else.