C and Java Programming Fundamentals

Serialization is the process of converting an object's state into a byte stream for storage or transmission. Deserialization is the reverse process - reconstructing the object from the byte stream. Option B correctly identifies that writing object state to a byte stream is called serialization.

In Java web applications, the deployment descriptor file used to define servlet mappings is standardly named web.xml, which resides in the WEB-INF directory. A file named servlet.xml is not standardly used for this purpose, making the statement false.

Encapsulation is the object-oriented programming concept of wrapping data and code into a single unit and restricting access to class members using modifiers like private, protected, and public. Distractors like inheritance, class, or polymorphism do not directly restrict access to members.

Java requires that public class names match the source file name exactly. If a source file contains a public class named Test, the file must be named Test.java. Package statements and imports are optional - java.lang is imported automatically by default.

Collections.reverseOrder() accepts a Comparator and returns a new Comparator that imposes the reverse ordering. When passed to Collections.sort(), it sorts the list in the opposite order of the original comparator. This is the standard way to reverse sort order in Java.

The method append accepts a raw List and adds a String object to it. Although the generic type of intList is Integer, Java uses type erasure at runtime, allowing the String to be inserted into the list. When intList.get(0) attempts to cast the retrieved element to an Integer, a ClassCastException is thrown at runtime.

In Java generics, List can be assigned to List<?> because the unbounded wildcard accepts any type. List can be assigned to List<? extends B> because D extends B. List<? extends B> can be assigned to List<? extends A> because B extends A. Option A is false because generics are invariant - List is not assignable to List. Option E is false because List cannot be assigned to List due to invariance.

java.util.LinkedList implements the List interface and stores elements in a doubly-linked list, allowing O(1) time complexity when adding elements to the beginning via add(0, object). However, it does not support quick random access (O(N)), meeting all requirements. ArrayList has O(N) insertion at index 0.

When forwarding requests between servlets in different web applications, the session and servlet context are not shared. HttpServletRequest attributes are preserved during forward operations and are accessible only to the target servlet, making them the ideal mechanism for data sharing in this scenario. HttpSession and ServletContext are shared within the same web application, not across applications.

The loop iterates 3 times (for 'm','a','n'). In each iteration, four expressions print the same character: s[i] (array indexing), *(s+i) (pointer dereference), *(i+s) (pointer arithmetic with reversed order), and i[s] (array indexing with swapped indices). This is valid C syntax. Each character prints 4 times sequentially: mmmm aaa nnnn.

The variable 'var' is static, meaning it retains its value between recursive calls of main(). In each call, printf prints 'var' before it is decremented post-evaluation (post-decrement). If 'var' is non-zero after decrement, main() is called again. The sequence printed is 5, 4, 3, 2, 1, stopping when 'var' becomes 0.

The array c is initialized with float values that are truncated to integers: {2, 3, 4, 6, 5}. The first loop prints *c (which is c[0], i.e., 2) five times, outputting ' 2 2 2 2 2 '. The second loop prints the dereferenced pointer p (which starts at c and increments), outputting the individual elements ' 2 3 4 6 5 ' sequentially. Combined, this outputs ' 2 2 2 2 2 2 3 4 6 5 '.

The expression evaluates left-to-right with short-circuit: i++&&j++&&k++||l++. First, i++ uses -1 (false), so i becomes 0 and the entire AND chain short-circuits (j++, k++ don't execute). Since -1 is false, the OR evaluates l++, making l=3. m = (-1) || 3 = 1. Final: i=0, j=-1, k=0, l=3, m=1.