Variables and Scopes — Middle Level¶

String prefix = "Hello"; // effectively final — never reassigned
List<String> names = List.of("Alice", "Bob");
names.forEach(name -> System.out.println(prefix + " " + name)); // OK

String mutable = "Hi";
mutable = "Hey"; // reassigned — no longer effectively final
// names.forEach(name -> System.out.println(mutable + " " + name)); // COMPILE ERROR

var list = new ArrayList<String>(); // inferred as ArrayList<String>
var count = 10;                      // inferred as int
var name = "Alice";                  // inferred as String

// Cannot use var for:
// var x;              // no initializer
// var y = null;       // cannot infer type from null
// var z = {1, 2, 3};  // array initializer

int multiplier = 3; // effectively final
IntUnaryOperator op = x -> x * multiplier; // captures the value 3
// multiplier = 4; // would break the capture rule

public class Counter {
    private int count = 0; // NOT thread-safe

    // Multiple threads calling this = race condition
    public void increment() {
        count++; // read-modify-write is not atomic
    }
}

import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        String department = "Engineering"; // effectively final
        double minSalary = 50000.0;        // effectively final

        List<Employee> employees = List.of(
            new Employee("Alice", "Engineering", 75000),
            new Employee("Bob", "Sales", 45000),
            new Employee("Carol", "Engineering", 80000)
        );

        // Both 'department' and 'minSalary' captured by the lambda
        List<Employee> filtered = employees.stream()
            .filter(e -> e.department().equals(department) && e.salary() >= minSalary)
            .collect(Collectors.toList());

        filtered.forEach(e -> System.out.println(e.name() + ": " + e.salary()));
    }

    record Employee(String name, String department, double salary) {}
}

import java.util.*;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        // Without var — verbose
        Map<String, List<Integer>> groupedScores1 = new HashMap<String, List<Integer>>();

        // With var — clean
        var groupedScores2 = new HashMap<String, List<Integer>>();

        groupedScores2.put("Alice", List.of(95, 87, 92));
        groupedScores2.put("Bob", List.of(78, 85, 90));

        // var shines with complex stream return types
        var averages = groupedScores2.entrySet().stream()
            .collect(Collectors.toMap(
                Map.Entry::getKey,
                e -> e.getValue().stream().mapToInt(Integer::intValue).average().orElse(0)
            ));

        averages.forEach((name, avg) -> System.out.printf("%s: %.1f%n", name, avg));
    }
}

public class RequestContext {
    private static final ThreadLocal<String> currentUser = new ThreadLocal<>();

    public static void setUser(String user) { currentUser.set(user); }
    public static String getUser() { return currentUser.get(); }
    public static void clear() { currentUser.remove(); } // important!
}

// ❌ Mutable configuration — risky in multi-threaded environments
public class Config {
    private String host;
    private int port;
    // getters and setters
}

// ✅ Immutable with record
public record Config(String host, int port) {
    // Compact constructor for validation
    public Config {
        if (port < 0 || port > 65535) throw new IllegalArgumentException("Invalid port: " + port);
    }
}

// ❌ Resource variable leaks beyond its useful scope
BufferedReader reader = new BufferedReader(new FileReader("data.txt"));
String line = reader.readLine();
reader.close(); // easy to forget
// reader is still in scope here

// ✅ Resource variable scoped to try block
try (var reader2 = new BufferedReader(new FileReader("data.txt"))) {
    String line2 = reader2.readLine();
    System.out.println(line2);
} // reader2 is out of scope AND closed

// ❌ Cryptic variables
int a = getTotal();
var b = fetchUsers();

// ✅ Self-documenting even with var
var totalRevenue = getTotal();
var activeUsers = fetchUsers();

// ✅ var helps — type is obvious from the right side
var users = new ArrayList<User>();
var config = Config.load("app.properties");
var response = client.send(request, HttpResponse.BodyHandlers.ofString());

// ❌ var hurts — type not obvious
var result = process(data);  // What type is result?
var x = getValue();           // What type is x?

// ❌ Common mistake — variable declared inside try is not visible in catch
try {
    var connection = DriverManager.getConnection(url);
    connection.execute(query);
} catch (SQLException e) {
    // connection is NOT in scope here — cannot close or log its state
    log.error("Failed", e);
}

// ✅ Declare outside, initialize inside
Connection connection = null;
try {
    connection = DriverManager.getConnection(url);
    connection.execute(query);
} catch (SQLException e) {
    log.error("Failed to execute on connection: {}", connection, e);
} finally {
    if (connection != null) connection.close();
}

// ✅ Best — try-with-resources
try (var connection = DriverManager.getConnection(url)) {
    connection.execute(query);
} catch (SQLException e) {
    log.error("Failed", e);
}

// ❌ Vulnerable — any code can modify the admin list
public class Security {
    public static List<String> adminUsers = new ArrayList<>(List.of("root"));
}

// Attacker code:
Security.adminUsers.add("hacker"); // instant admin access!

// ✅ Secure — immutable
public class Security {
    private static final List<String> ADMIN_USERS =
        Collections.unmodifiableList(List.of("root"));

    public static List<String> getAdminUsers() {
        return ADMIN_USERS;
    }
}

// ❌ Slow — field access in tight loop
public class Processor {
    private double multiplier = 1.5;
    private int[] data;

    public double compute() {
        double sum = 0;
        for (int i = 0; i < data.length; i++) {
            sum += data[i] * multiplier; // field access every iteration
        }
        return sum;
    }
}

// ✅ Fast — cache field in local variable
public double computeFast() {
    double sum = 0;
    double localMultiplier = this.multiplier; // cache in local
    int[] localData = this.data;              // cache array reference
    for (int i = 0; i < localData.length; i++) {
        sum += localData[i] * localMultiplier;
    }
    return sum;
}

// ❌ Creates formatter every call
public String format(double value) {
    var formatter = new DecimalFormat("#.##"); // new object per call
    return formatter.format(value);
}

// ✅ Reuse via instance variable (if thread-safe) or ThreadLocal
private static final ThreadLocal<DecimalFormat> FORMATTER =
    ThreadLocal.withInitial(() -> new DecimalFormat("#.##"));

public String formatFast(double value) {
    return FORMATTER.get().format(value);
}

// Log ThreadLocal state at request boundaries
logger.debug("ThreadLocal user at start: {}", RequestContext.getUser());

List<Runnable> tasks = new ArrayList<>();
for (int i = 0; i < 5; i++) {
    // tasks.add(() -> System.out.println(i)); // COMPILE ERROR — i is not effectively final
}

// Fix: capture in effectively final local
for (int i = 0; i < 5; i++) {
    final int captured = i;
    tasks.add(() -> System.out.println(captured)); // OK
}

@Service
public class OrderService {
    private Order currentOrder; // BUG — shared across all requests!

    public void process(Order order) {
        this.currentOrder = order; // Thread A sets this
        // Thread B might overwrite it before Thread A finishes
        validate(this.currentOrder);
    }
}

// ❌ Looks safe but mutates shared state
final var list = new ArrayList<>(List.of("a", "b"));
Runnable r = () -> list.add("c"); // compiles! final only protects the reference
r.run();
// list is now ["a", "b", "c"] — mutation through "final" variable

// ❌ var + diamond = raw type
var list = new ArrayList<>(); // inferred as ArrayList<Object>, not ArrayList<String>!
list.add("hello");
list.add(42); // compiles — no type safety

// ✅ Specify the type parameter
var list2 = new ArrayList<String>();

var x = "hello"; // x is String at compile time
// x = 42;       // COMPILE ERROR — cannot assign int to String

// ❌ Too many fields = too many responsibilities
public class UserManager {
    private UserRepository userRepo;
    private EmailService emailService;
    private AuditLogger auditLogger;
    private PaymentService paymentService;
    private NotificationService notificationService;
    private ReportGenerator reportGenerator;
    // ... 15 more fields
}

public class Init {
    static int a = b + 1; // COMPILE ERROR — forward reference
    static int b = 2;
}

// But this works:
public class Init2 {
    static int a;
    static int b;
    static {
        b = 2;
        a = b + 1; // OK — b is already assigned
    }
}

int result = switch (status) {
    case "OK" -> {
        int bonus = 100; // scoped to this case
        yield bonus + base;
    }
    case "ERROR" -> {
        int bonus = -50; // no conflict — different scope
        yield bonus + base;
    }
    default -> base;
};

public class Main {
    public static void main(String[] args) {
        var x = 10;
        x = 20;
        System.out.println(x);
    }
}

// Option A
var list = new ArrayList<>();
list.add("hello");
String s = list.get(0);

// Option B
var list = new ArrayList<String>();
list.add("hello");
String s = list.get(0);