Library classes

Packages in Java:

A package in Java is a hierarchical directory structure that groups related classes, interfaces, and sub-packages. Packages prevent naming conflicts, provide access protection, and structure large software systems.

• java.lang: The fundamental language package. Contains foundational classes such as System, Math, String, Object, and all Wrapper Classes. It is imported automatically into every Java program without an explicit import statement.
• java.util: Contains utility data structures, collection frameworks, and input scanners (Scanner, Arrays, Date). Must be imported via import java.util.*;.
• java.io: Contains input-output stream classes for reading from and writing to files and consoles (BufferedReader, InputStreamReader, IOException).

Why Does Java Require Wrapper Classes?

Java is an object-oriented language, but primitive data types (int, double, char) are not objects—they hold raw binary values on the Stack. While this provides maximum execution speed, it introduces architectural limitations:

• Java data structures and collections (e.g., ArrayList, Vector) store ONLY object references; they cannot hold primitives directly.
• Methods that accept Object parameters cannot take primitives without wrapping.
• Primitives lack utility methods for base conversion, character checking, and string parsing.

The Eight Primitive-to-Wrapper Class Mappings:

Seamless Interconversion Between Primitives and Objects:

Prior to Java 5, converting a primitive to an object required manual instantiation (Integer obj = new Integer(42);) and extraction required explicit method calls (int val = obj.intValue();). Modern Java automates this entirely:

// Programmer writes:
int num = 25;
Integer obj = num; // Autoboxing!

// Compiler converts under the hood to:
Integer obj = Integer.valueOf(num);

// Programmer writes:
Integer obj = 50;
int val = obj; // Unboxing!

// Compiler converts under the hood to:
int val = obj.intValue();

High-Frequency Character Testing & Mutation Methods:

The java.lang.Character class contains static utility methods to inspect individual char values. Because they are static, they are invoked directly as Character.methodName(ch).

Parsing Primitive Values from Strings:

In GUI applications and console input, numbers are initially captured as String text. The wrapper classes provide static parseXXX() methods to parse these strings into raw binary numeric primitives:

Key Architectural Differences:

Model Program 1: Character Classification Using Library Class Methods

import java.util.Scanner;

public class CharacterClassifier {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter a sentence: ");
        String str = sc.nextLine();

        int upperCount = 0, lowerCount = 0;
        int digitCount = 0, spaceCount = 0, specialCount = 0;

        for (int i = 0; i < str.length(); i++) {
            char ch = str.charAt(i);

            if (Character.isUpperCase(ch)) {
                upperCount++;
            } else if (Character.isLowerCase(ch)) {
                lowerCount++;
            } else if (Character.isDigit(ch)) {
                digitCount++;
            } else if (Character.isWhitespace(ch)) {
                spaceCount++;
            } else {
                specialCount++;
            }
        }

        System.out.println("----- CHARACTER ANALYSIS REPORT -----");
        System.out.println("Uppercase Letters : " + upperCount);
        System.out.println("Lowercase Letters : " + lowerCount);
        System.out.println("Digits (0-9)      : " + digitCount);
        System.out.println("Whitespace Spaces : " + spaceCount);
        System.out.println("Special Characters: " + specialCount);
        System.out.println("Total Characters  : " + str.length());
    }
}

Model Program 2: Case Inversion Algorithm Using Character.toUpperCase/toLowerCase

import java.util.Scanner;

public class CaseToggler {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter a string with mixed casing: ");
        String input = sc.nextLine();

        StringBuilder toggled = new StringBuilder();

        for (int i = 0; i < input.length(); i++) {
            char ch = input.charAt(i);

            if (Character.isUpperCase(ch)) {
                toggled.append(Character.toLowerCase(ch));
            } else if (Character.isLowerCase(ch)) {
                toggled.append(Character.toUpperCase(ch));
            } else {
                toggled.append(ch); // Keep digits, punctuation, and spaces unchanged
            }
        }

        System.out.println("Original String: " + input);
        System.out.println("Toggled String : " + toggled.toString());
    }
}