Unit6 - Subjective Questions

Generics in Java allow types (classes and interfaces) to be parameters when defining classes, interfaces, and methods. It provides stronger type checks at compile time and eliminates the need for explicit type casting.

Benefits:

• Type Safety: It ensures that you only insert the specific type of objects into a collection.
• Elimination of Casting: No need to cast the object while retrieving it from the collection.

Creating a Generic Collection:
To create a collection using generics, specify the type of object inside angle brackets < >.

java
import java.util.ArrayList;

public class GenericExample {
public static void main(String[] args) {
// Creating a generic ArrayList that only accepts Strings
ArrayList<String> list = new ArrayList<String>();

    list.add("Java");
    list.add("Generics");
    // list.add(10); // This would cause a compile-time error

    for(String s : list) {
        System.out.println(s);
    }
}

}

ArrayList Implementation:
ArrayList is a resizable-array implementation of the List interface. Internally, it uses a dynamic array to store the elements. It allows duplicate elements and ensures the insertion order.

Key Characteristics:

• Dynamic Resizing: When the array becomes full, a new array (usually 50% larger) is created, and elements are copied over.
• Not Synchronized: It is not thread-safe by default.

Performance (Time Complexity):

1. Access (get): Random access is very fast because it works on an index basis. The time complexity is .
2. Insertion (add):
   • Adding at the end is amortized .
   • Adding at a specific index is because elements must be shifted.
3. Deletion (remove): Deleting an element is because subsequent elements must be shifted left to fill the gap.

Therefore, ArrayList is best suited for scenarios where read operations outnumber write operations.

Both interfaces are used to sort collection objects, which is essential for a TreeSet as it stores elements in sorted order.

java
import java.util.*;

class Student {
int id;
String name;

public Student(int id, String name) {
    this.id = id;
    this.name = name;
}

@Override
public String toString() {
    return id + ": " + name;
}

}

// Custom Comparator to sort by Name
class NameComparator implements Comparator<Student> {
@Override
public int compare(Student s1, Student s2) {
return s1.name.compareTo(s2.name);
}
}

public class TreeSetExample {
public static void main(String[] args) {
// Pass the Comparator instance to the TreeSet constructor
TreeSet<Student> set = new TreeSet<>(new NameComparator());

    set.add(new Student(101, "Alice"));
    set.add(new Student(103, "Charlie"));
    set.add(new Student(102, "Bob"));

    System.out.println("Students sorted by Name:");
    for (Student s : set) {
        System.out.println(s);
    }
}

}

Output:

Students sorted by Name:
101: Alice
102: Bob
103: Charlie

Internal Working of HashMap:
HashMap works on the principle of hashing. It uses an internal array of nodes (buckets), where each node is an entry containing: Key, Value, Hash, and Next pointer.

1. put(K, V):

   • It calculates the hash of the Key using the hashCode() method.
   • It calculates the index using index = hash & (n-1).
   • It places the object in that bucket.

2. get(K):

   • It calculates the hash of the Key.
   • It goes to the specific index and compares keys using equals() to retrieve the value.

Handling Collisions:
A collision occurs when two different keys generate the same hash code/index.

• Chaining (Before Java 8): HashMap uses a LinkedList to store multiple entries in the same bucket. The new entry is appended to the list.
• Balanced Trees (Java 8+): If the number of items in a bucket exceeds a threshold (TREEIFY_THRESHOLD = 8), the LinkedList is converted into a Red-Black Tree. This improves the worst-case search time from to .

Deque (Double Ended Queue):
A Deque is a linear collection that supports element insertion and removal at both ends. It can function as both a Queue (FIFO) and a Stack (LIFO).

ArrayDeque Implementation:
ArrayDeque is a resizable-array implementation of the Deque interface. It has no capacity restrictions and grows as necessary to support usage.

Advantages over LinkedList:

1. Memory Efficiency: LinkedList requires extra memory for node objects and pointers (prev/next addresses) for every element. ArrayDeque uses a simple object array, resulting in lower memory overhead.
2. Performance: ArrayDeque is generally faster than LinkedList for queue and stack operations because it benefits from better cache locality (elements are stored contiguously in memory).
3. No Nulls: ArrayDeque does not permit null elements, whereas LinkedList does.

Usage:
java
Deque<String> stack = new ArrayDeque<>();
stack.push("A");
stack.pop();

JDBC (Java Database Connectivity) provides a standard API for Java applications to interact with various relational databases. The architecture consists of two main layers:

1. JDBC API (Application Layer):

   • Used by the Java application to communicate with the JDBC Manager.
   • Includes interfaces like Connection, Statement, ResultSet, and Driver.
   • Package: java.sql and javax.sql.

2. JDBC Driver Manager:

   • Acts as a bridge between the user application and the database drivers.
   • It manages a list of database drivers and establishes a connection using the appropriate driver.

3. JDBC Driver API (Driver Layer):

   • Implemented by third-party database vendors (e.g., Oracle, MySQL).
   • It handles the communication with the specific database server.

Flow:
Java App JDBC API DriverManager JDBC Driver Database.

This architecture ensures that the Java application remains independent of the specific database being used.

There are four types of JDBC drivers defined by Oracle:

1. Type 1: JDBC-ODBC Bridge Driver:

   • Translates JDBC calls into ODBC calls. Relies on the client machine having an ODBC driver installed.
   • Disadvantage: Platform dependent and slow.

2. Type 2: Native-API Driver (Partially Java):

   • Converts JDBC calls into client-side API calls of the database (e.g., Oracle OCI). Requires native binary code on the client.
   • Disadvantage: Installation of client libraries required on every machine.

3. Type 3: Network Protocol Driver (Middleware):

   • Pure Java driver that converts JDBC calls into a middleware protocol. The middleware server then translates this to the DBMS protocol.
   • Advantage: No client-side installation needed; flexible.

4. Type 4: Thin Driver (Pure Java):

   • Converts JDBC calls directly into the vendor-specific database protocol.
   • It is implemented entirely in Java.
   • Advantage: Highest performance, platform-independent, and no client-side software required. It is the most commonly used driver today.

Type-4 (Thin Driver) Efficiency:

1. Pure Java: It is written entirely in Java, making it platform-independent. The driver can be downloaded dynamically (e.g., via Maven or JAR inclusion).
2. Direct Communication: It communicates directly with the database server using the database's native protocol (via sockets). It does not require any intermediate layers like ODBC or middleware servers, reducing latency.
3. No Client Installation: Unlike Type 1 and Type 2 drivers, it does not require native libraries or client-side software (like Oracle Client) to be installed on the machine running the application.
4. Performance: Because there is no translation to ODBC or intermediate formats, the conversion overhead is minimal, resulting in better performance for typical web applications.

The standard steps to perform database operations in Java are:

1. Import Packages: Import java.sql.*.
2. Load and Register the Driver: Use Class.forName() to load the driver class.
   • Example: Class.forName("com.mysql.cj.jdbc.Driver");
3. Establish Connection: Use DriverManager.getConnection() with the URL, username, and password.
   • Example: Connection con = DriverManager.getConnection(url, user, pass);
4. Create Statement: Create a Statement or PreparedStatement object from the connection.
   • Example: Statement stmt = con.createStatement();
5. Execute Query: Execute the SQL query using methods like executeQuery() (for SELECT) or executeUpdate() (for INSERT/UPDATE/DELETE).
6. Process Results: If fetching data, iterate through the ResultSet.
7. Close Connection: Explicitly close the ResultSet, Statement, and Connection to release resources.

Differences:

1. Compilation:

   • Statement: The SQL query is compiled by the database every time it is executed. Useful for static queries.
   • PreparedStatement: The SQL query is pre-compiled by the database. Only the parameters change. It is faster for queries executed multiple times.

2. Parameters:

   • Statement: Does not support input parameters at runtime; values must be concatenated into the string.
   • PreparedStatement: Supports positional parameters defined by ? placeholders.

3. Security (SQL Injection):

   • Statement: Vulnerable to SQL Injection because user input is concatenated directly into the query string.
   • PreparedStatement: Protects against SQL Injection. It treats user input as data, not as executable code, by escaping special characters automatically.

java
import java.sql.*;

public class InsertExample {
public static void main(String[] args) {
String url = "jdbc:mysql://localhost:3306/school";
String user = "root";
String pass = "password";

    String sql = "INSERT INTO students (name, age, grade) VALUES (?, ?, ?)";

    try (Connection con = DriverManager.getConnection(url, user, pass);
         PreparedStatement pstmt = con.prepareStatement(sql)) {

        // Setting values for the placeholders
        pstmt.setString(1, "John Doe");
        pstmt.setInt(2, 20);
        pstmt.setString(3, "A");

        // Executing the update
        int rowsAffected = pstmt.executeUpdate();

        if (rowsAffected > 0) {
            System.out.println("A new student was inserted successfully!");
        }

    } catch (SQLException e) {
        e.printStackTrace();
    }
}

}

ResultSet:
The ResultSet interface represents the result set of a database query. It acts as an iterator to allow the program to move through the data rows generated by the query.

Comparison of Execute Methods:

1. executeQuery(String sql):

   • Usage: Used for SELECT statements.
   • Returns: A ResultSet object containing the data retrieved.

2. executeUpdate(String sql):

   • Usage: Used for INSERT, UPDATE, DELETE, or DDL statements (like CREATE TABLE).
   • Returns: An int value representing the number of rows affected (or 0 for DDL statements).

3. execute(String sql):

   • Usage: Used when the type of SQL statement is unknown (can be anything).
   • Returns: A boolean. Returns true if the first result is a ResultSet, and false if it is an update count.
   • You must subsequently call getResultSet() or getUpdateCount() to retrieve the actual result.

java
import java.sql.*;

public class SelectExample {
public static void main(String[] args) {
// Database credentials
String url = "jdbc:mysql://localhost:3306/company";
String user = "admin";
String pass = "1234";

    String query = "SELECT id, name, salary FROM Employees";

    try (Connection con = DriverManager.getConnection(url, user, pass);
         Statement stmt = con.createStatement();
         ResultSet rs = stmt.executeQuery(query)) {

        System.out.println("ID\tName\t\tSalary");
        System.out.println("---------------------------------");

        // Iterating through the ResultSet
        while (rs.next()) {
            int id = rs.getInt("id");
            String name = rs.getString("name");
            double salary = rs.getDouble("salary");

            System.out.println(id + "\t" + name + "\t" + salary);
        }

    } catch (SQLException e) {
        e.printStackTrace();
    }
}

}

Non-conventional Databases:
This refers to connecting Java applications to databases that do not follow the traditional Relational (SQL) model. These are typically NoSQL databases designed for high scalability, unstructured data, and distributed systems (e.g., MongoDB, Cassandra, Redis).

Connecting to NoSQL (MongoDB example):
Unlike JDBC which provides a unified API for SQL databases, NoSQL databases often require specific drivers provided by the vendor, as there is no single standard like SQL.

Process for MongoDB:

1. Add Dependency: Include the MongoDB Java Driver JAR (or Maven dependency).
2. Create Client: Use MongoClient to establish a connection.
3. Access Database/Collection: Select the database and the collection (equivalent to a table).
4. Create Document: Data is represented as Document objects (JSON-like BSON format).
5. Insert/Find: Use methods like insertOne() or find().

Example Snippet:
java
MongoClient mongoClient = MongoClients.create("mongodb://localhost:27017");
MongoDatabase database = mongoClient.getDatabase("mydb");
MongoCollection<Document> collection = database.getCollection("test");

Since HashMap is not a Collection (it implements the Map interface), it cannot be iterated directly. We must iterate over its views.

1. Iterating over Keys (keySet()):

   • Returns a Set of keys. You can iterate this set and use get(key) to retrieve values.
     java
     for (String key : map.keySet()) { ... }

2. Iterating over Entries (entrySet()):

   • Most Efficient. Returns a Set of Map.Entry objects. Gives access to both key and value simultaneously.
     java
     for (Map.Entry<String, String> entry : map.entrySet()) {
     System.out.println(entry.getKey() + " : " + entry.getValue());
     }

3. Iterating over Values (values()):

   • Returns a Collection of values. Useful if keys are not needed.
     java
     for (String val : map.values()) { ... }

4. Using forEach (Java 8+):

   • Uses a BiConsumer functional interface.
     java
     map.forEach((k, v) -> System.out.println(k + ":" + v));

Transaction Management:
A transaction is a group of operations that are treated as a single unit of work. They must satisfy ACID properties (Atomicity, Consistency, Isolation, Durability).

By default, JDBC is in Auto-Commit mode (every SQL statement is committed immediately).

Handling Transactions:
To manage transactions manually (e.g., to ensure money is deducted from Account A and added to Account B simultaneously):

1. Disable Auto-Commit:
   con.setAutoCommit(false);

2. Perform Operations: execute multiple SQL updates.

3. Commit: If all operations are successful, save changes permanently.
   con.commit();

4. Rollback: If any exception occurs during the operations, revert all changes to the state before the transaction started.
   con.rollback();

This ensures data integrity.

ListIterator:
ListIterator is an interface in the Java Collection framework that extends Iterator. It is used to traverse elements in a List implementation (like ArrayList, LinkedList).

Differences:

The core of the framework is based on the Iterable interface.

Hierarchy Overview:

1. Collection Interface (extends Iterable): The root interface for most collections.

   • List: Ordered collection, allows duplicates. (Impl: ArrayList, LinkedList, Vector).
   • Set: Unordered collection, no duplicates. (Impl: HashSet, LinkedHashSet).
     • SortedSet: Sorted version of Set. (Impl: TreeSet).
   • Queue: Holds elements for processing (FIFO). (Impl: PriorityQueue).
     • Deque: Double-ended queue. (Impl: ArrayDeque).

2. Map Interface: (Note: Does not extend Collection). Stores Key-Value pairs.

   • Impl: HashMap, LinkedHashMap.
   • SortedMap: Keys are sorted. (Impl: TreeMap).

The separation allows different data structures (Trees, Hash Tables, Arrays) to be manipulated through a standard set of methods.