Unit 6: Collections and Java Database Programming - Practice Quiz

Generics enforce type constraints at compile time, ensuring that you can only add objects of a specific type to a collection. This prevents runtime errors like ClassCastException.

The correct syntax for generics uses angle brackets <> to specify the type parameter. The diamond operator <> on the right side infers the type from the declaration.

The get(int index) method returns the element at the specified position in the list. It is the standard way to access elements by their index.

ArrayList is an ordered collection, meaning it preserves the order in which elements are added. It allows duplicates and can dynamically resize.

A TreeSet is a sorted set implementation. Elements are ordered either by their natural ordering (if they implement Comparable) or by a Comparator provided at set creation time.

The Comparable interface is used to define the natural ordering of a class by implementing its compareTo() method. TreeSet uses this method by default to sort its elements.

A Comparator provides an external, custom sorting logic. It's useful when you cannot or do not want to modify the source code of the class you are sorting, or if you need multiple different sorting orders.

HashMap implements the Map interface and is designed to store entries as key-value pairs. Each key must be unique.

The put() method is used to associate a value with a key in a HashMap. If the map previously contained a mapping for the key, the old value is replaced.

Deque is an acronym for Double Ended Queue. It's a data structure that allows insertion and removal of elements from both ends (front and back).

The addLast() or offerLast() methods are used to insert an element at the tail (end) of the deque. addFirst() adds to the front, push() adds to the front (for stack behavior), and peek() retrieves but does not remove an element.

JDBC is an acronym for Java Database Connectivity. It is a standard Java API for connecting Java applications to relational databases.

A Connection object represents a connection (session) with a database. All communication with the database is done through this object.

A JDBC driver is a piece of software that acts as a bridge, enabling a Java application to communicate with a specific database by translating standard JDBC calls into the database's native language or protocol.

The java.sql.DriverManager class is the backbone of the JDBC architecture. It manages a list of database drivers and provides the getConnection() method to establish a connection.

CRUD stands for the four basic operations of persistent storage: Create, Read, Update, and Delete. 'Read' refers to retrieving or querying data.

The 'Create' operation involves adding new data to the database. In SQL, this is accomplished using the INSERT statement to add new rows to a table.

A ResultSet object holds the tabular data returned by a SQL query. You use methods like next() to move to the next row and getString(), getInt(), etc., to retrieve column data.

MongoDB is a document-oriented NoSQL database, which is considered non-conventional compared to traditional relational databases like MySQL, PostgreSQL, and Oracle.

Most NoSQL databases provide their own native Java drivers (e.g., MongoDB Java Driver, Jedis for Redis) that are optimized for their specific data models and features, rather than using the relational-focused JDBC API.

The wildcard ? extends Number specifies an upper bound. This means the method can accept a List of Number or any subtype of Number (like Integer, Double, Float). Object is a supertype of Number, not a subtype, so passing a List<Object> will cause a compile-time error.

Java generics are not covariant for collections. You cannot assign a List<String> to a variable of type List<Object>. This is a key safety feature of generics that prevents heap pollution. If this assignment were allowed, you could add non-String objects to a list that is supposed to hold only Strings, leading to a ClassCastException later. The compiler prevents this error from happening in the first place.

1. The initial list is [A, B, C].
2. list.add(1, "D") inserts "D" at index 1, shifting subsequent elements. The list becomes [A, D, B, C].
3. list.remove("B") removes the first occurrence of the element "B". The list becomes [A, D, C].
   Finally, System.out.println(list) prints the final state of the list.

Adding an element to the beginning of an ArrayList is an O(n) operation, where n is the number of elements. This is because all existing elements must be shifted one position to the right to make space. In contrast, adding an element to the beginning of a LinkedList is an O(1) operation, as it only involves creating a new node and updating the head reference and one other pointer. Therefore, for large lists, LinkedList is significantly faster for this specific operation.

TreeSet maintains its elements in a sorted order. To sort custom objects, the class must either implement the Comparable interface (natural ordering) or a Comparator must be supplied to the TreeSet's constructor. Since the Employee class does neither, the TreeSet does not know how to compare two Employee objects. When the second element is added, the TreeSet attempts to compare it with the first, which fails and results in a ClassCastException at runtime.

The TreeSet is initialized with a Comparator that sorts Product objects based on their price. The lambda expression (p1, p2) -> Double.compare(p2.price, p1.price) compares the prices in descending order (notice p2 is compared to p1). Therefore, the products will be ordered from the highest price to the lowest: Laptop (1200.0), Keyboard (75.0), and then Mouse (25.0). The toString() method is used to print the name of each product.

TreeSet uses the compareTo method (or a Comparator) to determine both the order of elements and their equality for the purpose of the set. If compareTo returns 0, the TreeSet considers the elements to be equal and will not add the duplicate. In this case, since both Alice and Bob have an age of 30, compareTo will return 0 for them. Therefore, only the first Person object added with age 30 will be present in the set.

1. map.put("A", 1) adds the key "A" with value 1.
2. map.put("B", 2) adds the key "B" with value 2.
3. map.put("A", 3) attempts to add key "A" again. Since the key already exists, it updates the value to 3 and returns the old value, which was 1. So oldValue becomes 1.
4. map.put(null, 4) adds a null key with value 4.
5. map.put("C", null) adds key "C" with a null value.
   At the end, the map contains four key-value pairs: {"A"=3, "B"=2, null=4, "C"=null}. The size is 4. The output is the value of oldValue (which is 1) followed by the map's size (which is 4).

The contract between equals() and hashCode() requires that if two objects are equal according to equals(), they must have the same hash code. If hashCode() is not overridden, it will use the default implementation from the Object class, which typically returns a distinct integer for each distinct object in memory. Therefore, s1.hashCode() and s2.hashCode() will be different. The HashMap will look for s2 in a different bucket than where s1 is stored, and will not find it, thus returning null. Even though s1.equals(s2) is true, the get method won't even reach the point of calling equals because the hash codes don't match.

1. map.compute(1, ...): Key 1 exists, so the function is applied. The value becomes "OnePlus".
2. map.computeIfAbsent(4, ...): Key 4 does not exist, so the function is applied and the key-value pair (4, "Four") is inserted.
3. map.computeIfPresent(2, ...): Key 2 exists, so the function is applied. The function returns null, which causes the entire entry for key 2 to be removed from the map.
   Therefore, the final map contains entries for keys 1, 3, and 4.

Let's trace the state of the deque (head is on the left):

1. deque.push(10) (addFirst): [10]
2. deque.offerLast(20) (addLast): [10, 20]
3. deque.push(30) (addFirst): [30, 10, 20]
4. deque.offerFirst(40) (addFirst): [40, 30, 10, 20]
5. deque.pollFirst() removes and returns the head element, which is 40. It prints 40,. The deque is now [30, 10, 20].
6. deque.pop() (removeFirst) removes and returns the new head element, which is 30. It prints 30. The deque is now [10, 20].

For a LIFO stack, you should consistently add and remove from the same end, typically the head (front) of the deque. The push()/pop() methods are conventional for stacks and are equivalent to addFirst()/removeFirst(). The addFirst() and removeFirst() methods are defined in the Deque interface to throw an exception if the operation fails (e.g., adding to a full capacity-restricted deque or removing from an empty deque). In contrast, offerFirst() and pollFirst() return a special value (false or null) in these situations.

A Type 3 driver is a pure Java driver that communicates with a middle-tier application server. The client sends JDBC calls to the middleware, which then translates them into the database-specific protocol. This matches the description perfectly, as the client is thin (no vendor libraries) and it communicates through a middleware server, not directly to the database.

Type 4 drivers, often called 'Thin' drivers, are written entirely in Java. They convert JDBC calls directly into the vendor-specific database protocol. This means they are platform-independent and do not require any native database libraries to be installed on the client machine. In contrast, Type 2 'Native-API' drivers require vendor-specific native code on the client machine, making the application less portable and harder to deploy across different operating systems.

The executeUpdate() method is used for SQL Data Manipulation Language (DML) statements like INSERT, UPDATE, or DELETE. For UPDATE and DELETE statements, the integer it returns is the count of rows that were successfully modified or deleted by the SQL command. For INSERT, it's usually the number of rows added (typically 1). It does not return a simple success/failure code or an auto-generated key (which is retrieved differently).

This code is a classic example of SQL injection vulnerability. It concatenates untrusted user input directly into the SQL query string. An attacker can provide input like ' OR '1'='1 to manipulate the query's logic, potentially bypassing authentication or retrieving unauthorized data. The correct and safe way to handle user input in SQL queries is to use PreparedStatement with parameter placeholders (?), which ensures that the input is treated as literal data and not executable SQL code.

The key operations are conn.setAutoCommit(false), which starts a transaction, and conn.rollback(). The rollback() call explicitly undoes all changes made within the current transaction since the last commit. Therefore, even though the DELETE statement was executed, the rollback() call reverts the database to the state it was in before the transaction began. The subsequent conn.commit() has no changes to commit. The table remains unchanged.

The JDBC specification dictates that when you call a getter method (like getString, getInt, etc.) on a ResultSet for a column whose value is SQL NULL, the method returns a null reference for object types (like String), or 0 for primitive numeric types. To differentiate between a returned 0 and a SQL NULL, you should first check rs.wasNull() after calling the getter.

While the core JDBC interfaces (Connection, Statement, ResultSet) are generally implemented by the driver to provide a standard API, the underlying connection details are highly specific. The JDBC URL contains the protocol, host, port, and other database-specific information (e.g., keyspace for Cassandra). The driver class (e.g., com.cassandra.jdbc.CassandraDriver) must also be loaded. These two components are the primary way a Java application specifies which database it wants to connect to, and they will be completely different for a NoSQL database compared to a traditional RDBMS.

The DriverManager is the backbone of the JDBC connection process. Its main responsibility is to manage the set of available JDBC drivers. When DriverManager.getConnection() is called with a JDBC URL, it iterates through the registered drivers and asks each one if it can handle that specific URL. The first driver that recognizes the URL format is used to establish the connection. The other options describe the roles of Statement, Connection, and DatabaseMetaData respectively.

The HashMap put() operation first calculates the hash code to find the bucket. If multiple entries exist in the bucket (a collision), it iterates through them, using the equals() method to check if the new key already exists. Since the equals() method defaults to reference equality (==), it will compare object memory addresses. Two distinct objects, even with the same content, will have different addresses, so equals() will return false. Consequently, the HashMap concludes it's a new key and adds a new entry, leading to the map containing duplicate logical keys.

A TreeSet uses the compareTo() method (or a Comparator's compare() method) to determine both the ordering and uniqueness of its elements. It considers two objects to be duplicates if e1.compareTo(e2) returns 0. In this scenario, since both products have the same price, compareTo() will return 0. The TreeSet will therefore consider the second product a duplicate of the first and will not add it. The equals() method is not used for uniqueness determination in a TreeSet.

When autoCommit is true, each statement is typically treated as a separate transaction. When executeBatch() is called, the driver sends the batch to the database. If an error occurs midway, a BatchUpdateException is thrown. Crucially, any statements in the batch that were successfully executed before the error-causing statement are likely already committed to the database. The BatchUpdateException contains an update count array for the successfully executed commands, allowing the developer to know how many succeeded before the failure.

This is a classic example of the PECS (Producer Extends, Consumer Super) principle. A list declared with ? extends T is a producer. You can get elements out of it, and they are guaranteed to be of type T. However, you cannot add elements to it (except for the literal null) because the compiler doesn't know the exact type of the list. The list lo could be pointing to a List<String>, a List<Integer>, or any other List. Adding a String would be unsafe if it were, for example, a List<Integer>. Therefore, the compiler prohibits the add operation to ensure type safety.

Type 4 drivers are written entirely in Java and communicate directly with the database using its native network protocol. This makes them platform-independent and self-contained within a single JAR file. In a containerized environment like Docker, this is a huge advantage. You can simply include the JAR in your application's build, and the container will have everything it needs to connect to the database, without requiring any installation of native libraries or ODBC drivers on the container's OS. This greatly simplifies the CI/CD pipeline and ensures portability.

When an ArrayList exceeds its capacity, it must resize its internal array. The growth strategy is to create a new, larger array and copy all the elements from the old array to the new one. The new capacity is typically calculated as oldCapacity + (oldCapacity >> 1), which is equivalent to oldCapacity * 1.5. This resizing operation is expensive ( where k is the current size). However, because the capacity grows geometrically, these expensive operations happen infrequently. When the total cost is averaged over all N insertions, the time complexity per insertion becomes constant, leading to an amortized time complexity of for adding N elements.

Let's analyze the options. push() and addFirst() on ArrayDeque will throw an IllegalStateException if the deque is full (if capacity is restricted, which requires a custom subclass as ArrayDeque itself is not capacity-constrained). LinkedList has no capacity restriction. LinkedBlockingDeque is a capacity-constrained implementation of Deque. The offerFirst() method is specifically designed for this purpose: it attempts to insert an element at the front and returns true on success and false if the deque is full, without throwing an exception. This perfectly matches the requirements.

The TRANSACTION_SERIALIZABLE isolation level is the highest level and protects against dirty reads, non-repeatable reads, and phantom reads. To prevent phantom reads (where new rows matching a query's WHERE clause are inserted by another transaction), the database system typically uses range locks or predicate locks. When T1 reads all employees in 'sales', the database locks the 'sales' department index or range. T2's attempt to insert a new employee into this range will be blocked until T1's transaction finishes, ensuring that T1's view of the data remains consistent throughout its lifecycle.

clear() is an operation that iterates through the internal array, sets all element references from index 0 to size-1 to null to help the garbage collector, and then resets the size variable to 0. It does not change the capacity of the internal array. trimToSize() is an operation that adjusts the capacity of the internal array to be equal to the current number of elements (size). If capacity > size, it creates a new array of size size and copies the elements over. This is done to minimize storage. If capacity == size, it does nothing.

JDBC's transaction model (commit(), rollback(), setAutoCommit(), isolation levels) is deeply rooted in the relational/SQL world of ACID compliance. Most key-value stores like Redis offer limited, often single-key, atomic operations (e.g., via MULTI/EXEC blocks) but do not provide the kind of multi-statement, cross-key ACID transactions that are standard in relational databases. A JDBC driver for such a database must either severely limit transaction support, emulate it on the client side (which is not truly ACID), or simply not support it at all. This mapping is far more problematic than managing connections, simple lookups, or even representing multiple results.

First, let's analyze the HashSet. Because Person does not override equals(), the default Object.equals() (reference equality) is used. Therefore, new Person(1) and new Person(1) are two distinct objects, and the HashSet will contain two elements. Next, treeSet.addAll(set) is called. The TreeSet is constructed with a Comparator that compares persons by their id. When the two Person objects from the HashSet are added to the TreeSet, the comparator will find that p1.id is equal to p2.id. Since TreeSet uses its comparator to determine uniqueness, it will consider the two objects to be duplicates. Thus, only the first Person(1) object will be successfully added to the TreeSet, and its final size will be 1.

The conversion to a balanced tree is a performance optimization for the worst-case scenario where many keys have the same hash code, causing them to all land in the same bucket. Searching a linked list is an operation, where N is the number of items in the bucket. A balanced tree provides performance for search, insertion, and deletion. This conversion only happens when two conditions are met: the number of nodes in the bucket reaches TREEIFY_THRESHOLD (8), AND the overall map capacity is at least MIN_TREEIFY_CAPACITY (64). If the map is too small, it will resize instead of treeifying, as resizing is cheaper than the overhead of tree nodes in a small map.

The key performance benefit of PreparedStatement comes from pre-compilation. When the PreparedStatement is created, the SQL query with placeholders (?) is sent to the database management system (DBMS). The DBMS parses, compiles, and generates an execution plan for this query once. For each subsequent execute() call, only the parameter values are sent over the network to the DBMS, which then re-uses the existing execution plan. This avoids the overhead of parsing and planning the same SQL structure 1000 times, significantly reducing both network traffic and database CPU load compared to sending 1000 complete, distinct SQL strings with a Statement.

This question highlights a key convention in the Java Collections Framework. For many interfaces (like Queue and Deque), there are two sets of methods for core operations. One set (e.g., add(), remove(), element()) throws an exception if the operation fails (e.g., trying to remove from an empty collection). The other set (e.g., offer(), poll(), peek()) returns a special value (typically null or false) to indicate failure. Therefore, calling remove() on an empty ArrayDeque will throw a NoSuchElementException, whereas calling poll() will simply return null.

This demonstrates a core concept of generics in Java: type erasure. During compilation, the generic type information (<String>, <Integer>) is erased and replaced by its upper bound (in this case, Object). To the JVM, both method signatures become process(List list). Since it's illegal to have two methods with the same name and the same parameter types in a single class, the compiler detects this clash and reports a compilation error. You cannot overload methods based solely on a difference in their generic type parameters.

The single most important reason is connection pooling. Establishing a database connection is a resource-intensive and time-consuming operation involving network communication, authentication, and session setup. In a high-concurrency application, creating a new connection for every request would be extremely inefficient and would not scale. DataSource is an interface whose implementations (provided by application servers or standalone libraries like HikariCP, c3p0) manage a pool of open database connections. When the application requests a connection, it gets a pre-existing one from the pool, and when it's done, the connection is returned to the pool instead of being closed. This reuse dramatically improves performance. DriverManager, by contrast, provides no pooling mechanism and creates a new physical connection each time it is called.

The subList() method does not create a copy; it returns a view backed by the original list. The documentation states that if the original list is structurally modified (i.e., its size changes by adding or removing elements) in any way other than through the returned sublist, the sublist becomes invalid. The ArrayList implementation tracks modifications using a modCount field. When the original list is modified, its modCount is incremented. The sublist view retains the modCount value from when it was created. When any method on the sublist is called, it checks if its saved modCount matches the original list's current modCount. If they don't match, it throws a ConcurrentModificationException to indicate that its backing source has changed.

A HashMap resizes when its size exceeds the threshold. The threshold is calculated as capacity * loadFactor. With an initial capacity of 16 and a load factor of 0.75, the threshold is 16 * 0.75 = 12. The check for resizing happens before a new element is added in the put() method. This means the map can hold up to 12 elements without resizing. When the attempt to add the 13th element is made, the size (which is currently 12) will be compared against the threshold (12). Since size >= threshold, the resize operation is triggered before the 13th element is actually inserted. The map's capacity will be doubled to 32.

TYPE_SCROLL_SENSITIVE creates a scrollable result set that attempts to reflect the current state of the database. This means that if another transaction updates or deletes a row that is in your result set, or inserts a row that would match your query, your ResultSet object should reflect that change. This "live" view is very powerful but comes at a significant cost. To maintain this sensitivity, the JDBC driver and database must do extra work, potentially keeping locks or repeatedly re-fetching data, which can be very expensive in terms of performance and database resources.

The TreeSet relies on its underlying balanced binary search tree (a red-black tree) for ordering and uniqueness. The core assumption of a binary search tree is that the comparison function is transitive (if a > b and b > c, then a > c). A non-transitive compareTo method violates this fundamental contract. While the add operations might appear to succeed without an immediate exception, they will place the elements incorrectly within the tree structure. This breaks the tree's invariants, leading to a corrupted state. Subsequent operations that rely on the tree's structure, like contains(), remove(), or even iteration, can then fail in unpredictable ways, potentially returning incorrect results or even entering an infinite loop, without necessarily throwing an exception.