New Features Introduced in Java 1.4 (Feb 2002)

Java 1.4, released on February 6, 2002, marked a significant milestone in the evolution of the Java platform. This version, also known as Java 2 Standard Edition 1.4, introduced a plethora of new features and APIs that substantially enhanced Java's capabilities and developer productivity.

Key Features Introduced in Java 1.4:

• Assert Keyword: Introduced a new language construct for making debugging assertions.
• Regular Expressions: Added built-in support for powerful string pattern matching and manipulation.
• Non-Blocking I/O (NIO): Implemented a new I/O API for high-performance, scalable I/O operations.
• Logging API: Provided a flexible, configurable logging framework for applications.
• Image I/O API: Enhanced support for reading and writing image data across multiple formats.
• JDBC 3.0: Improved database connectivity with new features like connection pooling and batch updates.
• Java Web Start: Enabled easy deployment of Java applications over the network.
• XML Processing: Integrated XML parsing capabilities with JAXP 1.1.
• Security Enhancements: Introduced JAAS, Java GSS, JSSE, and JCE as standard features.

Code Examples Demonstrating Java 1.4 Features:

// Assert Keyword Example
public class AssertDemo {
    public static void main(String[] args) {
        int x = 5;
        assert x == 5 : "x should be 5";
        System.out.println("Assertion passed successfully");
    }
}

// Regular Expressions Example
import java.util.regex.*;

public class RegexDemo {
    public static void main(String[] args) {
        String text = "Java 1.4 was released in 2002";
        Pattern pattern = Pattern.compile("Java \\d\\.\\d");
        Matcher matcher = pattern.matcher(text);
        
        if (matcher.find()) {
            System.out.println("Found: " + matcher.group());
        }
    }
}

// Non-Blocking I/O (NIO) Example
import java.nio.channels.*;
import java.net.*;

public class NIODemo {
    public static void main(String[] args) throws Exception {
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        serverChannel.configureBlocking(false);
        serverChannel.socket().bind(new InetSocketAddress(8080));
        
        Selector selector = Selector.open();
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);
        
        while (true) {
            selector.select();
            // Process selected keys
        }
    }
}

// Logging API Example
import java.util.logging.*;

public class LoggingDemo {
    private static final Logger logger = Logger.getLogger(LoggingDemo.class.getName());
    
    public static void main(String[] args) {
        logger.info("Application started");
        logger.warning("This is a warning message");
        logger.severe("This is a severe error message");
    }
}

// Image I/O Example
import javax.imageio.*;
import java.io.File;

public class ImageIODemo {
    public static void main(String[] args) throws Exception {
        BufferedImage image = ImageIO.read(new File("input.jpg"));
        ImageIO.write(image, "png", new File("output.png"));
    }
}

// JDBC 3.0 Example
import java.sql.*;

public class JDBCDemo {
    public static void main(String[] args) throws Exception {
        Connection conn = DriverManager.getConnection("jdbc:mysql://localhost/db", "user", "pass");
        PreparedStatement pstmt = conn.prepareStatement("INSERT INTO users VALUES (?, ?)");
        
        pstmt.setString(1, "John");
        pstmt.setString(2, "Doe");
        pstmt.addBatch();
        
        pstmt.setString(1, "Jane");
        pstmt.setString(2, "Smith");
        pstmt.addBatch();
        
        int[] updateCounts = pstmt.executeBatch();
    }
}

Detailed Comparison of Java 1.4 with Adjacent Versions:

Java 1.4 represented a substantial leap forward in Java's capabilities, particularly in areas of I/O performance, string manipulation, and developer tooling. Its introduction of the assert keyword and the logging API significantly improved debugging and application monitoring capabilities. The NIO package opened up new possibilities for high-performance, scalable applications, especially in the realm of server-side development.

While not as revolutionary as the subsequent Java 5 release, Java 1.4 laid important groundwork and introduced features that remain fundamental to Java development to this day. It struck a balance between adding new functionality and maintaining backward compatibility, a hallmark of Java's evolution strategy.