Java 12 — Switch Expressions Preview

// Switch tradicional - verboso e propenso a bugs
String getSeasonOld(int month) {
    String season;
    switch (month) {
        case 12:
        case 1:
        case 2:
            season = "Winter";
            break;
        case 3:
        case 4:
        case 5:
            season = "Spring";
            break;
        case 6:
        case 7:
        case 8:
            season = "Summer";
            break;
        case 9:
        case 10:
        case 11:
            season = "Fall";
            break;
        default:
            throw new IllegalArgumentException("Invalid month: " + month);
    }
    return season;
}

// Java 12 - Switch Expression (mais limpo)
String getSeason(int month) {
    return switch (month) {
        case 12, 1, 2 -> "Winter";
        case 3, 4, 5 -> "Spring";
        case 6, 7, 8 -> "Summer";
        case 9, 10, 11 -> "Fall";
        default -> throw new IllegalArgumentException("Invalid month: " + month);
    };
}

// Casos mais complexos com yield (Java 13+)
int calculateDays(String month, boolean isLeapYear) {
    return switch (month.toLowerCase()) {
        case "january", "march", "may", "july", "august", "october", "december" -> 31;
        case "april", "june", "september", "november" -> 30;
        case "february" -> isLeapYear ? 29 : 28;
        default -> throw new IllegalArgumentException("Invalid month: " + month);
    };
}

// Switch com processamento complexo
String processGrade(char grade) {
    return switch (grade) {
        case 'A', 'a' -> "Excellent";
        case 'B', 'b' -> "Good";
        case 'C', 'c' -> "Average";
        case 'D', 'd' -> "Below Average";
        case 'F', 'f' -> "Fail";
        default -> "Invalid grade: " + grade;
    };
}

// Tradicional: statement (executa ações)
switch (status) {
    case ACTIVE:
        enableFeatures();
        sendNotification();
        break;
    case INACTIVE:
        disableFeatures();
        break;
}

// Expression: retorna valor
String message = switch (status) {
    case ACTIVE -> "User is active";
    case INACTIVE -> "User is inactive";
    case SUSPENDED -> "User is suspended";
};

// Híbrido: pode fazer ambos no Java 14+
String result = switch (operation) {
    case ADD -> {
        logger.info("Performing addition");
        yield a + b;
    }
    case SUBTRACT -> {
        logger.info("Performing subtraction");
        yield a - b;
    }
};

// indent() - adiciona indentação a cada linha
String code = """
    public class Example {
        public void method() {
            System.out.println("Hello");
        }
    }
    """;

String indented = code.indent(4);
// Adiciona 4 espaços a cada linha

// Exemplo prático: formatação de código
public String formatJavaCode(String code, int indentLevel) {
    return code.lines()
        .map(line -> " ".repeat(indentLevel) + line)
        .collect(Collectors.joining("\n"));
}

// transform() - aplica função de transformação
String greeting = "hello world";

// Aplicar múltiplas transformações
String result = greeting
    .transform(String::toUpperCase)        // "HELLO WORLD"
    .transform(s -> s.replace(" ", "_"))   // "HELLO_WORLD"
    .transform(s -> "[" + s + "]");        // "[HELLO_WORLD]"

// Exemplo prático: pipeline de transformação
public String processUserInput(String input) {
    return input
        .transform(String::trim)           // Remove espaços
        .transform(String::toLowerCase)    // Minúsculas
        .transform(this::removeSpecialChars) // Remove caracteres especiais
        .transform(this::validateFormat);  // Valida formato
}

// Comparação com abordagem tradicional
// Antes:
String processed = validateFormat(
    removeSpecialChars(
        input.trim().toLowerCase()
    )
);

// Com transform() - mais fluente
String processed = input
    .transform(String::trim)
    .transform(String::toLowerCase)
    .transform(this::removeSpecialChars)
    .transform(this::validateFormat);

// Exemplo de microbenchmark
@BenchmarkMode(Mode.Throughput)
@State(Scope.Benchmark)
public class StringConcatBenchmark {

    @Param({"10", "100", "1000"})
    private int size;

    @Benchmark
    public String stringConcat() {
        String result = "";
        for (int i = 0; i < size; i++) {
            result += "test";
        }
        return result;
    }

    @Benchmark
    public String stringBuilder() {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < size; i++) {
            sb.append("test");
        }
        return sb.toString();
    }
}