New Features in Java 5 (Sept 2004)

Java 5 (also known as Java 1.5), released on September 30, 2004, marked a significant milestone in the evolution of the Java platform. This version introduced major language features and APIs that substantially enhanced Java's capabilities, expressiveness, and developer productivity.

Key Features Introduced in Java 5:

• Generics: Introduced parameterized types, enhancing type safety and reducing casting.
• Enhanced for Loop: Simplified iteration over collections and arrays.
• Autoboxing/Unboxing: Automatic conversion between primitive types and their wrapper classes.
• Enumerations: Type-safe enumeration of constants.
• Varargs: Methods that accept a variable number of arguments.
• Static Import: Allowed static members to be imported, reducing verbosity.
• Annotations: Metadata tags that can be used for various purposes including code generation and runtime processing.
• Improved Concurrency Utilities: Introduction of the java.util.concurrent package.
• Scanner Class: Simplified parsing of primitive types and strings from various input sources.
• Formatted Output: Introduction of printf-style formatting.
• Covariant Return Types: Allowed overriding methods to return more specific types.
• Typesafe Enums: Improved type-safety and functionality of enumeration types.

Code Examples Demonstrating Java 5 Features:

// Generics Example
import java.util.*;

public class GenericsDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("Java");
        list.add("5");
        
        for (String s : list) { // Enhanced for loop
            System.out.println(s);
        }
    }
}

// Autoboxing and Enums Example
enum Day { MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY }

public class AutoboxingEnumDemo {
    public static void main(String[] args) {
        Map<Day, Integer> workHours = new EnumMap<>(Day.class);
        workHours.put(Day.MONDAY, 8); // Autoboxing of 8 to Integer
        
        int mondayHours = workHours.get(Day.MONDAY); // Unboxing to int
        System.out.println("Monday work hours: " + mondayHours);
    }
}

// Varargs and Static Import Example
import static java.lang.Math.*;

public class VarargsStaticImportDemo {
    public static void main(String[] args) {
        System.out.println("Max value: " + max(3, 7, 2, 5)); // Static import of Math.max
        printAll("Java", "is", "awesome"); // Varargs
    }
    
    static void printAll(String... strings) {
        for (String s : strings) {
            System.out.print(s + " ");
        }
    }
}

// Annotations Example
import java.lang.annotation.*;

@Retention(RetentionPolicy.RUNTIME)
@interface TestInfo {
    String[] tags();
}

public class AnnotationDemo {
    @TestInfo(tags = {"unit", "integration"})
    public void testMethod() {
        // Method implementation
    }
}

// Concurrency Utilities Example
import java.util.concurrent.*;

public class ConcurrencyDemo {
    public static void main(String[] args) throws Exception {
        ExecutorService executor = Executors.newFixedThreadPool(2);
        Future<String> future = executor.submit(() -> {
            Thread.sleep(1000);
            return "Task Completed";
        });
        
        System.out.println(future.get());
        executor.shutdown();
    }
}

// Scanner and Formatted Output Example
import java.util.Scanner;

public class ScannerFormattedOutputDemo {
    public static void main(String[] args) {
        String input = "John 25 3.14";
        Scanner scanner = new Scanner(input);
        
        String name = scanner.next();
        int age = scanner.nextInt();
        double value = scanner.nextDouble();
        
        System.out.printf("Name: %s, Age: %d, Value: %.2f%n", name, age, value);
    }
}

// Covariant Return Types Example
class Animal {}
class Dog extends Animal {}

class AnimalFactory {
    Animal createAnimal() { return new Animal(); }
}

class DogFactory extends AnimalFactory {
    @Override
    Dog createAnimal() { return new Dog(); } // Covariant return type
}

Detailed Comparison of Java 5 with Adjacent Versions:

Java 5 represented a revolutionary leap forward in Java's capabilities, particularly in terms of language expressiveness and type safety. The introduction of generics, enhanced for loop, and autoboxing/unboxing significantly improved code readability and reduced common programming errors. Annotations opened up new possibilities for metaprogramming and code generation, while the improved concurrency utilities made it easier to write efficient multi-threaded applications.

This release marked one of the most significant changes to the Java language since its inception, setting the stage for modern Java development practices. While it introduced complexity, especially with generics, it also provided powerful tools that remain fundamental to Java development to this day. Java 5 struck a balance between adding new functionality and maintaining backwards compatibility, continuing Java's evolution strategy while taking a bold step forward in language design.

The addition of formatted output (printf-style) and covariant return types further enhanced Java's capabilities, making it more flexible and expressive. These features, along with the others introduced in Java 5, collectively represented a major overhaul of the language, addressing many long-standing requests from the Java community and setting a new standard for modern programming languages.