Java Core Classes and Threads

Java has robust built-in support for multithreaded programming through the Thread class, Runnable interface, and synchronized keyword. The language was designed from the ground up to support concurrent programming, making it one of the core strengths of the Java platform.

The default value of lazy loading in Hibernate is 'true'. This means associations are loaded on-demand when first accessed, not eagerly when the parent object is loaded. This lazy loading improves performance by avoiding unnecessary database queries for data that might never be used.

Overloaded methods are distinct methods and can throw any checked exceptions. However, overridden methods in subclasses cannot throw new or broader checked exceptions than the original method. Thus, the statement is false.

session.contains() checks if an instance exists in the session cache (first-level cache), not whether it's in the database. An entity can be in session cache without being persisted, or exist in database without being in cache.

createQuery().scroll() returns ScrollableResult, not ResultSet types. ScrollableResult allows cursor-like navigation over large result sets without loading everything into memory. ListResultSet is not a Hibernate interface.

While both monitor multiple file descriptors, poll() is event-driven and scales better because it uses a structure array instead of bitmasks, whereas select() requires rebuilding the descriptor sets every time.

In Hibernate, mapping a property with access="field" tells Hibernate to bypass the setter method and access the instance variable directly using reflection. This is useful when you have non-trivial setter logic that shouldn't execute during object loading. The 'variable' and 'onlyfield' values are not valid access strategies.

To understand the difference between session.load(Emp.class) and session.createCriteria(Emp.class), the user needs to know about Hibernate, an ORM (Object-Relational Mapping) framework that provides a way to map Java objects to database tables.

session.load(Emp.class) and session.createCriteria(Emp.class) are two different ways to retrieve data from the database using Hibernate.

session.load(Emp.class) is used to load an object from the database using its identifier. It returns a proxy object of the requested entity and the actual database query is executed only when the proxy object is accessed for the first time. If the identifier is not found in the database, then it throws the ObjectNotFoundException exception.

On the other hand, session.createCriteria(Emp.class) is used to create a Criteria object that can be used to retrieve data from the database. It provides a way to construct a query using a set of criteria such as restrictions, projections, and ordering. It returns a list of objects that match the criteria specified in the query.

Now let's go through each option and explain why it is right or wrong:

A. a) On session close session.load() Emp Object unavailable to access: This option is partially correct. When the session is closed before accessing the Emp object loaded using session.load(), then the ObjectNotFoundException exception is thrown. However, the Emp object is still available to access until the session is closed.

B. b) On session close session.createCriteria() Emp unavailable to access: This option is incorrect. When the session is closed before accessing the Emp object retrieved using session.createCriteria(), then the LazyInitializationException exception is thrown. However, the Emp object is still available to access until the session is closed.

C. c) None: This option is incorrect. There is a difference between session.load() and session.createCriteria() as explained above.

D. Both a & b: This option is incorrect. Option A is partially correct and option B is incorrect.

Therefore, the correct answer is:

The Answer is: A

In Hibernate, evict() removes an object and its associated collections from the first-level cache (session cache). This detaches the object from the session, making changes no longer tracked. It does NOT affect second-level cache or the database.

The refresh() method re-loads an object and all its collections from the database, overwriting the current state in the Session. This is particularly useful when database triggers initialize or modify properties after the initial save - refresh() retrieves those trigger-generated values. Option A correctly identifies refresh(). Option B (flush) synchronizes the Session state to the database (writes to DB, not reads from it). Options C and D are incorrect because there's no standard fetch() method, and load() retrieves only if already in Session or throws exception.

Option B directly mutates the Item object inside the HashMap by accessing it via get() and setting its name field. This changes the value object's content without replacing the reference. Option C creates a new Item but doesn't prevent other references to the old one.

Option D uses an Iterator to traverse the list, which avoids repeated get(i) calls and index recalculation. For LinkedList, get(i) is O(n), making B and C O(n²). Iterator provides consistent O(1) traversal regardless of List implementation. Options A, B, C all work but D is most efficient.

Declaring a reference variable as null and then assigning it to an existing object from a list avoids allocating unnecessary memory for a new object that would immediately be discarded and garbage collected.

In option B, the function reassigns the local parameter im to a new Item, but Java passes parameters by value for object references. The reassignment doesn't affect the caller's reference - the original Item object remains unchanged. Options A and C both mutate or return the actual object.