Compound Assignment vs Simple Assignment

The expression a += b performs implicit type casting, equivalent to a = (type of a)(a + b), which prevents compilation errors when types mismatch. Conversely, a = a + b requires strict type compatibility; otherwise, it results in a compile-time error without automatic downcasting.

JDK 8 Enhancements

JDK 8 introduced Lambda expressions, the Stream API, functional interfaces, default and static methods in interfaces, and structural optimizations for HashMap. Stream pipelines are single-use; traversing a stream invalidates it, preventing subsequent operations.

// 1. Stream Initialization
List<String> names = ...;
names.stream();                // Sequential processing
names.parallelStream();       // Parallel processing
Arrays.stream(new String[]{});// Array to stream
Stream.of("v1", "v2", "v3");   // Explicit values

// 2. Intermediate Operations
Stream<String> strStream = names.stream();
strStream.filter(item -> item.length() > 5);  // Retain matching elements
strStream.distinct();                         // Remove duplicates
strStream.map(item -> item.length());         // Transform String to Integer
strStream.sorted();                            // Sort naturally or with comparator
strStream.limit(2);                            // Truncate to first 2 elements
strStream.skip(1);                             // Discard the first element

// 3. Terminal Operations
strStream.collect(Collectors.toList());                     // Aggregate into List
strStream.collect(Collectors.toSet());                      // Aggregate into Set
String merged = strStream.collect(Collectors.joining("-")); // Concatenate with delimiter

long total = strStream.filter(item -> item.startsWith("a")).count(); // Element count

boolean hasTarget = strStream.anyMatch(item -> item.equals("target")); // Any match?
boolean isAllValid = strStream.allMatch(item -> item.length() > 3);    // All match?

strStream.forEach(item -> System.out.println(item));                 // Iterate and consume

Memory Leak Scenarios

A memory leak occurs when objects no longer in use remain reachable via reference chains, preventing garbage collection and eventually causing OutOfMemoryError. Common scenarios include:

• Static Collections: Their lifecycle matches the JVM. Continuously adding objects without removal maintains static references, blocking GC.
• Unbounded Caches: Maps or caches lacking eviction policies or expiration timers accumulate unused data indefinitely.
• ThreadLocal Mismanagement: Unremoved entries in thread-local storage, especially in reused thread pools.
• Active Thread Pools: Unshutdown worker threads keep task references alive.

Static vs Non-static Nested Classes

Static nested classes are bound to the outer class rather than its instances. They can be instantiated without an outer object, cannot be overridden (since binding occurs at compile-time), cannot access this or super of the outer instance, and only interact with static outer fields. Non-static inner classes hold an implicit reference to the enclosing instance, requiring its instantiation first.

Serialization and Deserialization

Serialization transforms an object's state into a byte stream for storage or network transfer, while deserialization reconstructs the object from those bytes. Classes must implement the Serializable marker interface. ObjectOutputStream.writeObject() handles the core logic: validating the interface, recording metadata, and writing field values.

Serialization rules:

1. static fields are excluded as they belong to the class, not the instance.
2. transient keywords explicitly skip specific fields during byte stream generation.
3. A serialVersionUID must be explicitly declared. Without it, the JVM calculates one dynamically based on class structure; modifying the class post-serialization alters the UID, causing InvalidClassException during reconstruction.

Deserialization via ObjectInputStream.readObject() bypasses constructors, utilizing Unsafe.allocateInstance() to allocate memory directly. This mechanism can compromise singleton patterns unless a readResolve() method is implemented to substitute the reconstructed instance with the existing singleton.

private Object reconstructObject(boolean exclusive) throws IOException, ClassNotFoundException {
    // Step 1: Retrieve class metadata
    ObjectStreamClass classDesc = readClassDesc(false);
    
    // Step 2: Verify UID compatibility
    // Mismatch throws InvalidClassException
    
    // Step 3: Allocate instance bypassing constructors (Unsafe.allocateInstance)
    Object instance = classDesc.isInstantiable() ? classDesc.newInstance() : null;

    // Step 4: Populate fields, ignoring static/transient
    readFieldData(instance, classDesc);

    // Step 5: Enforce singleton integrity via readResolve()
    if (instance != null && handles.lookupException(passHandle) == null && classDesc.hasReadResolveMethod()) {
        Object resolvedInstance = classDesc.invokeReadResolve(instance);
        instance = resolvedInstance;
    }
    
    return instance;
}

Implementation example:

// Serialize to file
String outputPath = "person.dat";
ObjectOutputStream serializer = new ObjectOutputStream(new FileOutputStream(outputPath));
Person record = new Person("Alice", 30, "New York");
serializer.writeObject(record);
serializer.close();

// Deserialize from file
ObjectInputStream deserializer = new ObjectInputStream(new FileInputStream(outputPath));
Person restoredRecord = (Person) deserializer.readObject();
deserializer.close();

Unsafe API

Java restricts direct memory and hardware manipulation for safety, but the Unsafe class provides native methods bypassing these constraints. It allows off-heap memory allocation (untracked by GC, requiring manual deallocation), direct field modification (ignoring access modifiers), thread parking/unparking, and atomic compare-and-swap (CAS) operations.