1. Mutability:
• String: Immutable. Once a String object is created, its value cannot be changed. Any operation that appears to modify a String actually creates a new String object.
• StringBuffer: Mutable. A StringBuffer object can be modified after it is created using various methods without creating a new object.

2. Performance:
• String: Less efficient for concatenation or frequent modifications because it involves creating new String objects.
• StringBuffer: More efficient for concatenation or frequent modifications due to its mutable nature. It uses a dynamically expandable buffer to store characters, reducing the need for creating new objects.

3. Thread Safety:
• String: Immutable and therefore thread-safe. Multiple threads can safely access a String object without synchronization issues.
• StringBuffer: Mutable and therefore not thread-safe by default. To ensure thread safety, StringBuffer provides synchronized methods, but this can impact performance.

4. Usability:
• String: Suitable for situations where the value of the string is not expected to change frequently.
• StringBuffer: Suitable for situations where frequent modifications to the string are required, such as in loops or when building a string dynamically.

public class CommandLineArguments {
    public static void main(String[] args) {
        // Check if any arguments were provided
        if (args.length == 0) {
            System.out.println("No arguments provided.");
        } else {
            // Print the number of arguments
            System.out.println("Number of arguments: " + args.length);

            // Print all arguments
            System.out.println("Arguments:");
            for (int i = 0; i < args.length; i++) {
                System.out.println("Argument " + (i + 1) + ": " + args[i]);
            }
        }
    }
}

1. Save the code above into a file named CommandLineArguments.java.

2. Compile the program using the command javac CommandLineArguments.java.

3. Run the program with some arguments, for example: java CommandLineArguments arg1 arg2 arg3.

Number of arguments: 3
Arguments:
Argument 1: arg1
Argument 2: arg2
Argument 3: arg3

1. valueOf(): This static method is used to create a wrapper object from a primitive value or a string. For example, Integer.valueOf(10) creates an Integer object with the value 10.

2. parseXxx(): These static methods are used to parse a string into a primitive type. For example, Integer.parseInt("10") returns the integer 10.

3. toString(): This method returns the string representation of the object. For example, Integer.toString(10) returns the string "10".

4. intValue(), doubleValue(), floatValue(), etc.: These methods return the primitive value of the object. For example, Integer.valueOf(10).intValue() returns the integer 10.

5. equals(): This method compares two wrapper objects for equality, returning true if they are equal and false otherwise.

6. compareTo(): This method compares two wrapper objects numerically, returning a negative value if the first object is less than the second, zero if they are equal, and a positive value if the first object is greater than the second.

1. Final:
• When applied to a variable, final indicates that the variable's value cannot be changed once initialized.
• When applied to a method, final prevents the method from being overridden by subclasses.
• When applied to a class, final prevents the class from being subclassed.

2. Static:
• When applied to a variable, static indicates that the variable belongs to the class itself, rather than to instances of the class. There will be only one copy of the variable shared among all instances of the class.
• When applied to a method, static indicates that the method belongs to the class, not to instances of the class. Static methods can be called directly on the class without creating an instance.
• When applied to a block of code, static indicates a static initializer block, which is executed when the class is loaded into memory.

3. this:
• this is a reference to the current object within an instance method or constructor.
• It is used to access instance variables and methods of the current object, to differentiate between instance variables and local variables with the same name, and to pass the current object as a parameter to other methods.

4. super:
• super is a reference to the superclass of the current object.
• It is used to call superclass constructors, to access superclass methods and variables that are hidden by subclass methods or variables, and to pass the current object as a parameter to other methods in the superclass.

// Superclass
class Animal {
    void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

// Subclass
class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Dog barks");
    }
}

// Subclass
class Cat extends Animal {
    @Override
    void makeSound() {
        System.out.println("Cat meows");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal1 = new Dog(); // Dog object
        Animal animal2 = new Cat(); // Cat object

        animal1.makeSound(); // Calls Dog's makeSound method
        animal2.makeSound(); // Calls Cat's makeSound method
    }
}

1. Default (no specifier):
• When no access specifier is used, it is considered as default.
• Members are accessible within the same package but not outside the package.
• Example: class A in package com.example is accessible to other classes in the com.example package but not to classes outside this package.

2. Private:
• Members are accessible only within the same class.
• Example: private int x; can only be accessed within the class where it is declared.

3. Protected:
• Members are accessible within the same package and by subclasses (even if the subclass is in a different package).
• Example: protected void foo(); can be accessed by any subclass of the class where foo() is declared.

4. Public:
• Members are accessible from any other class.
• Example: public void bar(); can be accessed from any class.

import static java.lang.Math.sqrt;

public class Main {
    public static void main(String[] args) {
        double[] array = {25, 36, 49, 64, 81};

        System.out.println("Square roots of the elements:");
        for (double num : array) {
            System.out.println(sqrt(num));
        }
    }
}

1. Checked Exceptions:
• Checked exceptions are exceptions that are checked at compile time by the compiler. This means that the compiler will enforce the programmer to either handle the exception or declare it in the method signature using the throws keyword.
• Examples of checked exceptions:
• IOException: Signals that an I/O exception of some sort has occurred.
• ClassNotFoundException: Thrown when an application tries to load a class through its string name but no definition for the class with the specified name could be found.
• SQLException: An exception that provides information on a database access error or other errors.

2. Unchecked Exceptions (Runtime Exceptions):
• Unchecked exceptions are exceptions that are not checked at compile time. This means that the compiler does not force the programmer to handle or declare these exceptions.
• Examples of unchecked exceptions:
• NullPointerException: Thrown when an application attempts to use null in a case where an object is required.
• ArrayIndexOutOfBoundsException: Thrown to indicate that an array has been accessed with an illegal index.
• ArithmeticException: Thrown when an exceptional arithmetic condition has occurred (e.g., division by zero).

1. Improved performance: Multithreading allows you to take advantage of multiple CPU cores, enabling your program to perform tasks in parallel and potentially speeding up the execution time.

2. Concurrency: Multithreading allows your program to handle multiple tasks simultaneously, making it easier to write programs that can respond to multiple inputs or events at the same time.

3. Asynchronous programming: Multithreading enables you to perform tasks asynchronously, which is useful for handling tasks that may take a long time to complete without blocking the main thread of execution.

4. Responsive user interfaces: Multithreading allows you to keep your application's user interface responsive while performing long-running tasks in the background.

5. Resource sharing: Multithreading allows multiple threads to share resources, such as memory, enabling efficient resource utilization.

1. start(): This method is used to start the execution of a thread. When the start() method is called, the JVM calls the run() method of the thread.

2. run(): This method contains the code that is executed by the thread. You should override this method in your subclass to define the behavior of the thread.

3. sleep(long millis): This method causes the current thread to sleep for the specified number of milliseconds. It is used to introduce a delay in the execution of a thread.

4. join(): This method waits for the thread on which it is called to die. It is used to ensure that a thread has completed its execution before continuing with the rest of the program.

5. interrupt(): This method interrupts the execution of a thread. It is typically used to gracefully stop a thread by setting a flag that the thread checks periodically.

6. isAlive(): This method returns true if the thread is still alive (i.e., has been started and has not yet died), otherwise it returns false.

class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized void decrement() {
        count--;
    }

    public synchronized int getCount() {
        return count;
    }
}

public class Main {
    public static void main(String[] args) {
        Counter counter = new Counter();

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.decrement();
            }
        });

        t1.start();
        t2.start();

        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Final count: " + counter.getCount());
    }
}

public class DeadlockExample {
    private static final Object resource1 = new Object();
    private static final Object resource2 = new Object();

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            synchronized (resource1) {
                System.out.println("Thread 1: Holding resource 1");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread 1: Waiting for resource 2");
                synchronized (resource2) {
                    System.out.println("Thread 1: Holding resource 1 and resource 2");
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (resource2) {
                System.out.println("Thread 2: Holding resource 2");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread 2: Waiting for resource 1");
                synchronized (resource1) {
                    System.out.println("Thread 2: Holding resource 2 and resource 1");
                }
            }
        });

        thread1.start();
        thread2.start();
    }
}

1. Avoid nested locks: Try to avoid acquiring multiple locks in a nested manner. If you must, ensure that all locks are acquired in the same order across all threads.

2. Use a timeout: When acquiring locks, use tryLock() instead of synchronized blocks and specify a timeout. If a lock cannot be acquired within the timeout, release all locks and retry later.

3. Avoid long-running operations inside synchronized blocks: Long-running operations inside synchronized blocks increase the likelihood of deadlocks. Try to keep synchronized blocks short and simple.

4. Avoid waiting for resources while holding a lock: If a thread needs to wait for a resource, it should release any locks it holds to avoid potential deadlocks.

5. Use higher-level concurrency utilities: Instead of using low-level synchronization primitives like synchronized blocks, consider using higher-level concurrency utilities provided by Java, such as java.util.concurrent classes. These classes often provide built-in mechanisms to avoid deadlocks.

public class Box<T> {
    private T value;

    public void setValue(T value) {
        this.value = value;
    }

    public T getValue() {
        return value;
    }

    public static void main(String[] args) {
        // Creating a Box for Integer
        Box<Integer> integerBox = new Box<>();
        integerBox.setValue(10);
        System.out.println("Integer value: " + integerBox.getValue());

        // Creating a Box for String
        Box<String> stringBox = new Box<>();
        stringBox.setValue("Hello, World!");
        System.out.println("String value: " + stringBox.getValue());
    }
}

1. Socket Class:
• The Socket class represents a client-side socket that connects to a server-side socket.
• It provides methods for connecting to a server, sending and receiving data, and closing the connection.
• To create a socket, you need to specify the IP address and port number of the server to connect to.
Important methods of the Socket class include:
• Socket(String host, int port): Constructor to create a new socket and connect it to the specified host and port.
• InputStream getInputStream(): Returns an input stream for this socket, which can be used to read data from the socket.
• OutputStream getOutputStream(): Returns an output stream for this socket, which can be used to write data to the socket.
• void close(): Closes the socket and releases any resources associated with it.

2. ServerSocket Class:
• The ServerSocket class represents a server-side socket that listens for incoming connections from client sockets.
• It provides methods for accepting incoming connections, sending and receiving data, and closing the server socket.
• To create a ServerSocket, you need to specify the port number on which the server will listen for incoming connections.
Important methods of the ServerSocket class include:
• ServerSocket(int port): Constructor to create a new server socket that listens on the specified port.
• Socket accept(): Listens for a connection to be made to this socket and accepts it. The method blocks until a connection is made.
• InputStream getInputStream(): Returns an input stream for this server socket, which can be used to read data from the accepted socket.
• OutputStream getOutputStream(): Returns an output stream for this server socket, which can be used to write data to the accepted socket.
• void close(): Closes the server socket and releases any resources associated with it.

// Server side
ServerSocket serverSocket = new ServerSocket(12345);
Socket clientSocket = serverSocket.accept();
InputStream inputStream = clientSocket.getInputStream();
OutputStream outputStream = clientSocket.getOutputStream();

// Client side
Socket socket = new Socket("localhost", 12345);
InputStream inputStream = socket.getInputStream();
OutputStream outputStream = socket.getOutputStream();

import java.io.FileReader;
import java.io.IOException;

public class CharacterCounter {
    public static void main(String[] args) {
        if (args.length < 1) {
            System.out.println("Usage: java CharacterCounter <filename>");
            return;
        }

        String fileName = args[0];
        int count = countCharacter(fileName, 'a');

        System.out.println("Number of occurrences of 'a': " + count);
    }

    public static int countCharacter(String fileName, char character) {
        int count = 0;
        try (FileReader reader = new FileReader(fileName)) {
            int c;
            while ((c = reader.read()) != -1) {
                if (Character.toLowerCase((char) c) == Character.toLowerCase(character)) {
                    count++;
                }
            }
        } catch (IOException e) {
            System.err.println("Error reading file: " + e.getMessage());
        }
        return count;
    }
}

1. Socket: A socket is an endpoint for communication between two machines over a network. It is identified by an IP address and a port number. Sockets can be used to establish connections, send and receive data, and close connections.

2. Port: A port is a logical endpoint on a machine that is used to uniquely identify a specific process or service. Ports are numbered from 0 to 65535, and certain port numbers are reserved for specific purposes (e.g., port 80 for HTTP, port 443 for HTTPS).

3. Protocol: A protocol is a set of rules and conventions that govern the communication between devices on a network. Common network protocols include TCP (Transmission Control Protocol), UDP (User Datagram Protocol), HTTP (Hypertext Transfer Protocol), and FTP (File Transfer Protocol).

4. IPAddress: An IP address is a unique numerical label assigned to each device connected to a network that uses the Internet Protocol for communication. IP addresses are used to identify and locate devices on a network.

5. URL (Uniform Resource Locator): A URL is a reference to a web resource that specifies the protocol used to access the resource (e.g., HTTP, HTTPS), the domain name or IP address of the server, and the path to the resource on the server. Example: https://www.example.com/index.html.

import java.util.LinkedList;

public class LinkedListExample {
    public static void main(String[] args) {
        // Creating a LinkedList
        LinkedList<String> linkedList = new LinkedList<>();

        // Adding elements to the LinkedList
        linkedList.add("Alice");
        linkedList.add("Bob");
        linkedList.add("Charlie");

        // Adding an element at the beginning of the LinkedList
        linkedList.addFirst("David");

        // Adding an element at the end of the LinkedList
        linkedList.addLast("Eve");

        // Removing an element from the LinkedList
        linkedList.remove("Bob");

        // Iterating over the LinkedList
        System.out.println("LinkedList elements:");
        for (String element : linkedList) {
            System.out.println(element);
        }

        // Getting the size of the LinkedList
        System.out.println("Size of the LinkedList: " + linkedList.size());

        // Checking if an element is present in the LinkedList
        System.out.println("Is 'Charlie' present? " + linkedList.contains("Charlie"));

        // Getting the first and last elements of the LinkedList
        System.out.println("First element: " + linkedList.getFirst());
        System.out.println("Last element: " + linkedList.getLast());

        // Removing the first and last elements of the LinkedList
        linkedList.removeFirst();
        linkedList.removeLast();

        // Clearing the LinkedList
        linkedList.clear();

        // Checking if the LinkedList is empty
        System.out.println("Is the LinkedList empty? " + linkedList.isEmpty());
    }
}

1. Byte Streams:
• Byte streams are used for reading and writing raw bytes of data.
• They are suitable for handling binary data, such as images, audio, video, etc.
• Byte streams are represented by classes like InputStream and OutputStream.
• Example classes: FileInputStream, FileOutputStream.

2. Character Streams:
• Character streams are used for reading and writing text data as characters.
• They are suitable for handling text files, where characters are represented using a character encoding (e.g., UTF-8).
• Character streams are represented by classes like Reader and Writer.
• Example classes: FileReader, FileWriter.

1. FileReader:
• FileReader is used for reading text files.
• It reads data from a file as a stream of characters.
• Example usage:

try (FileReader reader = new FileReader("example.txt")) {
    int character;
    while ((character = reader.read()) != -1) {
        System.out.print((char) character);
    }
} catch (IOException e) {
    e.printStackTrace();
}

2. FileWriter:
• FileWriter is used for writing text files.
• It writes data to a file as a stream of characters.
• Example usage:

try (FileWriter writer = new FileWriter("output.txt")) {
    writer.write("Hello, World!");
} catch (IOException e) {
    e.printStackTrace();
}