Question 1

Which Java class inherits its equals() and hashCode() directly from java.lang.Object (i.e., does not override them)?

Accepted Answer

Introduction / Context: Many core Java classes override equals() and hashCode() to provide value-based equality. Others, notably mutable sequence classes, keep identity-based equality from Object. Recognizing which is which is a common exam topic. Given Data / Assumptions: We compare several classes from java.lang. We must identify the one that does not override equals() and hashCode(). Concept / Approach: String, Integer, Double, and Character are value types and override equals()/hashCode() to compare by content/value. StringBuffer, being a mutable buffer, inherits identity-based equality from Object, meaning two different buffers with the same characters are not considered equal unless they are the same instance. Step-by-Step Reasoning: Check class docs/behavior: String → overrides (content-based).Double, Integer, Character → wrapper types, also override.StringBuffer → does not override; identity equality. Verification / Alternative check: Printing new StringBuffer("a").equals(new StringBuffer("a")) yields false, confirming identity equality. Why Other Options Are Wrong: Each of them defines value-based equality and a corresponding hash code implementation. Common Pitfalls: Confusing StringBuffer with StringBuilder (neither overrides equals/hashCode) versus String which does. Final Answer: java.lang.StringBuffer

Question 2

Which Java collection lets you associate elements with keys while iterating in insertion (FIFO) order?

Accepted Answer

Introduction / Context: Different Java collections provide different ordering guarantees. The question asks for a map (key–value association) that also preserves insertion order, enabling FIFO-style iteration. Given Data / Assumptions: We need key–value association (i.e., a Map). We want predictable iteration order: specifically insertion order (FIFO-like). Concept / Approach: LinkedHashMap combines a hash table with a doubly-linked list to maintain predictable iteration order. By default, it preserves insertion order; alternatively, it can be configured for access order. Other map implementations either do not preserve order (HashMap) or impose a sort order by key (TreeMap), not insertion order. Step-by-Step Reasoning: Eliminate non-Map types: ArrayList and PriorityQueue are not maps.Consider map types: HashMap → no order guarantee; TreeMap → sorted by key; LinkedHashMap → preserves insertion order. Verification / Alternative check: Quick test inserting keys A, B, C into a LinkedHashMap and iterating shows A, B, C order. Why Other Options Are Wrong: ArrayList lacks keys; HashMap is unordered; TreeMap orders by key comparator; PriorityQueue is a heap, not key–value store. Common Pitfalls: Confusing insertion order with sorted order; assuming HashMap iteration order is stable (it is not guaranteed). Final Answer: java.util.LinkedHashMap

Question 3

Java — Which interface does java.util.Hashtable implement?

Accepted Answer

Introduction / Context: The java.util.Hashtable class is one of the legacy collection classes in Java. Understanding which interfaces it implements is key to using it correctly in modern Java programming. Given Data / Assumptions: Hashtable is a dictionary-like data structure storing key-value pairs. Located in java.util package. Modern usage often prefers HashMap, but Hashtable remains important historically. Concept / Approach: Hashtable implements the Map interface, which defines methods for mapping keys to values without duplicates. Step-by-Step Reasoning: Hashtable extends Dictionary (legacy) but implements Map.Map ensures unique keys, allows value lookup, insertion, and removal.List and Collection are not correct because they do not define key-value mapping. Why Other Options Are Wrong: List → ordered sequence, not key-value mapping. HashTable (spelled incorrectly) is not an interface. Collection is more general, but Hashtable implements Map, not Collection directly. Final Answer: java.util.Map

Question 4

Java — What is the numerical range of the char data type?

Accepted Answer

Introduction / Context: The char type in Java is a 16-bit unsigned integer representing a Unicode character. Unlike C/C++, Java chars are not signed and cover a wide range of Unicode code points. Given Data / Assumptions: char size: 16 bits (2 bytes). Unsigned, not negative. Stores Unicode characters. Concept / Approach: The range of a 16-bit unsigned integer is 0 to (2^16 - 1) = 65535. Step-by-Step Solution: Minimum: 0 → represents null character '\u0000'.Maximum: 65535 → corresponds to '\uffff'. Why Other Options Are Wrong: 32767 is max for signed 16-bit, but char is unsigned. -256 to 255 describes byte range incorrectly. -32768 to 32767 describes signed short, not char. Final Answer: 0 to 65535

Question 5

Java — Store elements with no duplicates and natural order. Which interface provides this capability?

Accepted Answer

Introduction / Context: Different collection interfaces in Java define different rules for storage: duplicates, ordering, and key-value mappings. Given Data / Assumptions: Requirement: no duplicates. Requirement: natural order access. Concept / Approach: Set interface represents collections with no duplicate elements. SortedSet (e.g., TreeSet) provides natural ordering. Step-by-Step Reasoning: Map → stores key-value pairs, not individual elements.List → allows duplicates, preserves insertion order, not natural ordering.Collection → general root interface; does not guarantee uniqueness or order. Why Other Options Are Wrong: Only Set ensures uniqueness; TreeSet (implementation) also provides natural order. Final Answer: java.util.Set

Question 6

Java — Which Map implementation maintains iteration order of an existing Map?

Accepted Answer

Introduction / Context: This question tests knowledge of different Map implementations in Java and their ordering characteristics. Concept / Approach: HashMap → no ordering guarantee. TreeMap → natural or custom comparator order, not iteration order. LinkedHashMap → maintains insertion order or access order. Step-by-Step Reasoning: If you want the iteration order of an existing Map to be preserved, use LinkedHashMap and construct it with the existing Map. Why Other Options Are Wrong: TreeMap re-sorts keys, HashMap randomizes order, and "depends on implementation" is too vague. Final Answer: LinkedHashMap

Question 7

Java — Which collection class allows resizing, provides indexed access, but is not synchronized?

Accepted Answer

Introduction / Context: This checks understanding of ArrayList vs other collections in terms of resizing, indexing, and synchronization. Concept / Approach: ArrayList → resizable array, indexed access, not synchronized. Vector → synchronized, older alternative. HashSet/LinkedHashSet → no indexing, store unique elements. List → interface, not a class. Final Answer: java.util.ArrayList

Question 8

Java — What line of code should replace the missing statement to compile this program? public class foo  {     public static void main(String[]args)throws Exception      {         java.io.PrintWriter out = new java.io.PrintWriter();          new jav…

Accepted Answer

Introduction / Context: This question evaluates knowledge of Java import statements and compilation requirements for using java.io classes. Concept / Approach: In Java, include is invalid (C/C++ feature). If classes are referenced with full package names (java.io.PrintWriter), no import is necessary. But the constructor new java.io.PrintWriter() is invalid without arguments — it requires a Writer or OutputStream. Step-by-Step Reasoning: Given options, the most reasonable fix is using import java.io.*; so that PrintWriter and OutputStreamWriter are available without full qualification. Final Answer: import java.io.*;

Question 9

Java — Which interface provides capability to store objects using key-value pairs?

Accepted Answer

Introduction / Context: This tests knowledge of the Map interface in the Java Collections Framework. Concept / Approach: Map defines methods to store key-value pairs, where keys are unique and values can be retrieved by keys. Why Other Options Are Wrong: Set → stores unique elements only, no key-value. List → ordered collection of elements, allows duplicates. Collection → root interface, but no key-value mapping. Final Answer: java.util.Map

Question 10

Java — Which of the following are Java reserved words? (run, import, default, implement)

Accepted Answer

Introduction / Context: This question checks memory of Java reserved keywords, which cannot be used as identifiers. Concept / Approach: import → reserved word (used for package imports). default → reserved word (used in switch and interfaces). run → not reserved; just a common method name. implement → not reserved; correct word is implements. Final Answer: 2 and 3

Question 11

Java — Which collection class allows key-value associations and provides synchronization?

Accepted Answer

Introduction / Context: This checks knowledge of synchronized collections and legacy classes. Concept / Approach: Hashtable is synchronized, meaning its methods are thread-safe. It stores key-value pairs like HashMap but synchronizes all methods. TreeMap → ordered keys, but not synchronized. SortedMap → interface, not a class. TreeSet → stores unique values, not key-value pairs. Final Answer: java.util.Hashtable

Question 12

Java — Which is a valid declaration of a float value?

Accepted Answer

Introduction / Context: This evaluates the correct way of declaring floating-point literals in Java. Concept / Approach: By default, floating literals like 1.0 are treated as double in Java. To assign to a float, append f or F. d or D indicates double explicitly. String literals like "1" cannot be assigned directly to float. Step-by-Step: Option A: Correct. "1F" explicitly declares a float.Option B: Incorrect. 1.0 defaults to double.Option C: Invalid type mismatch.Option D: Declares double literal with d. Final Answer: float f = 1F;

Question 13

Java TreeSet iteration order and duplicate handling: what sequence is printed?

TreeSet map = new TreeSet();
map.add("one");
map.add("two");
map.add("three");
map.add("four");
map.add("one"); // duplicate
Iterator it = map.iterator();
while…

Accepted Answer

Introduction / Context: This question examines how java.util.TreeSet orders elements and deals with duplicates. TreeSet stores elements in a sorted order (natural ordering for String) and does not allow duplicates. Given Data / Assumptions: Inserted strings: "one", "two", "three", "four", then "one" again. Iteration is via Iterator over the TreeSet (ascending order). Natural order for Strings is lexicographical (dictionary order). Concept / Approach: Compute the lexicographic order among the distinct values. The duplicate "one" has no effect because sets ignore duplicates. Sorted order for the distinct elements is determined by standard String comparison rules. Step-by-Step Solution: Distinct elements are { "four", "one", "three", "two" }. Lexicographic ascending order: "four" < "one" < "three" < "two". Iteration prints: four one three two with spaces. Verification / Alternative check: Try a Comparator.reverseOrder() TreeSet; you would then see the reverse sequence. Or use a HashSet to show undefined iteration order. Why Other Options Are Wrong: “one two three four” would be insertion order, not TreeSet’s sorted order; “... one” at the end implies duplicates are printed, which sets prevent. Common Pitfalls: Confusing HashSet (unordered) with TreeSet (sorted); assuming duplicates are kept; expecting insertion order. Final Answer: four one three two

Question 14

Static array reference default value vs element access: what happens when printing x[0]?

public class Test {
 private static int[] x; // reference not initialized → null
 public static void main(String[] args) {
 System.out.println(x[0]);
 }\…

Accepted Answer

Introduction / Context: This checks the difference between an array reference's default value and the default values of array elements. A static array reference that is not explicitly initialized remains null. Accessing an element through a null reference causes a runtime exception. Given Data / Assumptions: x is a static field of type int[] and is never assigned → defaults to null. Main tries to print x[0]. Concept / Approach: In Java, object references default to null. Although an allocated int[] would have elements defaulting to 0, here the array object does not exist. Any attempt to index a null array reference throws NullPointerException. Step-by-Step Solution: Field initialization: x == null. Expression x[0] requires dereferencing x first. Dereferencing null triggers NullPointerException at runtime. Verification / Alternative check: Initialize x = new int[1]; then x[0] prints 0 because the element defaults to 0. The distinction is between the reference and the array instance. Why Other Options Are Wrong: “0” would require an allocated array; “null” is not printed because the code never reaches printing a value; compilation is valid. Common Pitfalls: Assuming default element values apply even when the array reference is null; forgetting that arrays are objects. Final Answer: NullPointerException at runtime

Question 15

Which interfaces does Vector.elements() return, and how do instanceof tests evaluate?

import java.util.*;
class H {
 public static void main (String[] args) {
 Object x = new Vector().elements();
 System.out.print((x instanceof Enumeration) +…

Accepted Answer

Introduction / Context: This tests knowledge of legacy collections vs. modern iterators. Vector.elements() returns an Enumeration, not an Iterator or ListIterator. Given Data / Assumptions: x = new Vector().elements() produces a legacy Enumeration. The program checks three instanceof relations and prints their boolean results separated by commas. Concept / Approach: Enumeration pre-dates the Java Collections Framework. It is distinct from Iterator and ListIterator. Therefore, only the first check is true. Step-by-Step Solution: x instanceof Enumeration → true. x instanceof Iterator → false. x instanceof ListIterator → false. Printed line: true,false,false. Verification / Alternative check: Replace elements() with iterator() from a modern collection (e.g., new ArrayList().iterator()) and observe the changed results. Why Other Options Are Wrong: Any output claiming Iterator or ListIterator is true misunderstands the return type of elements(). Common Pitfalls: Equating Enumeration with Iterator; forgetting that ListIterator is a specialized bidirectional iterator available via listIterator(), not iterator() or elements(). Final Answer: Prints: true,false,false

Question 16

Packages, access modifiers, and top-level classes: will this code compile?

package foo;
import java.util.Vector; // Line 2
private class MyVector extends Vector {
 int i = 1; // Line 5
 public MyVector() {
 i = 2;
 }
}
public class MyNewV…

Accepted Answer

Introduction / Context: Here we test Java's rules for top-level class access modifiers within a package. Only public or package-private (no modifier) are allowed for top-level classes; private and protected are illegal at the top level. Given Data / Assumptions: File declares package foo;. MyVector is declared as private class MyVector at top level (Line 3). MyNewVector is a public class extending MyVector. Concept / Approach: The Java Language Specification allows only two choices for top-level class visibility: public or no modifier (package-private). Any attempt to mark a top-level class as private is a compile-time error. Step-by-Step Solution: Encounter private class MyVector extends Vector at line 3. Compiler flags: “modifier private not allowed here” (or similar message). Compilation halts; subsequent lines are not relevant. Verification / Alternative check: Change private to no modifier (package-private) or move MyVector to a nested class inside another type if private scope is required. Why Other Options Are Wrong: There is nothing illegal at lines 5, 15, or 19 once line 3 is fixed. The failure is specifically due to the top-level private modifier. Common Pitfalls: Confusing inner class modifiers with top-level class modifiers; forgetting that only one public top-level class per file is allowed (matching file name). Final Answer: Compilation will fail at line 3.

Question 17

Default values in a newly allocated float array: what exactly prints for f[0]?

public class Test {
 private static float[] f = new float[2];
 public static void main (String[] args) {
 System.out.println("f[0] = " + f[0]);
 }
}

Accepted Answer

Introduction / Context: This item tests default initialization for primitive array elements in Java. When you allocate an array of a primitive type, each element is set to that type’s default value. Given Data / Assumptions: f is allocated as new float[2]. No further writes occur before printing f[0]. Concept / Approach: For float, the default element value is 0.0f. When converted to String in concatenation, it prints as 0.0. This differs from reference types, which default to null, and from unallocated arrays (which would throw on indexing). Step-by-Step Solution: Allocate f → elements initialized to 0.0f. Access f[0] → value 0.0f. String concatenation prints “f[0] = 0.0”. Verification / Alternative check: Write f[0] = 1.5f; and re-run; output becomes f[0] = 1.5. For double[], the default is 0.0 as well, shown with double precision. Why Other Options Are Wrong: “0” is an int-looking presentation; Java prints a float/double as “0.0”. The code compiles and runs fine; there is no exception. Common Pitfalls: Confusing default array element values with default reference values; mixing up formatting vs. numeric value. Final Answer: f[0] = 0.0

Question 18

Which interfaces does ArrayList.iterator() implement? Evaluate the instanceof results.

import java.util.*;
class I {
 public static void main (String[] args) {
 Object i = new ArrayList().iterator();
 System.out.print((i instanceof List) + ",…

Accepted Answer

Introduction / Context: This question distinguishes between Iterator, ListIterator, and collection types. The object returned by new ArrayList().iterator() is an Iterator but not a List and not a ListIterator. Given Data / Assumptions: i holds the iterator returned from an empty ArrayList. Three instanceof checks are printed as booleans. Concept / Approach: An Iterator is produced by iterator(). A ListIterator—which supports bidirectional traversal and index operations—is produced by listIterator(), not iterator(). Also, an iterator is not a collection, so it is not a List. Step-by-Step Solution: i instanceof List → false. i instanceof Iterator → true. i instanceof ListIterator → false. Output is false, true, false. Verification / Alternative check: Replace iterator() with listIterator() and the third check becomes true for many list implementations. Why Other Options Are Wrong: Any claim that List is true confuses data structures with iterators; claiming ListIterator is true ignores the specific method used. Common Pitfalls: Assuming all list iterators are bidirectional; forgetting distinct factory methods in the collections API. Final Answer: Prints: false, true, false

Question 19

Using NULL vs null in Java: what does this program do?

public class Test {
 public static void main (String args[]) {
 String str = NULL;
 System.out.println(str);
 }
}

Accepted Answer

Introduction / Context: This question targets the correct spelling and case-sensitivity of Java’s null literal. In Java, the literal is null (all lowercase). Writing NULL attempts to reference an identifier named NULL, which does not exist by default. Given Data / Assumptions: Declares String str = NULL; in main. No NULL constant is defined anywhere. Concept / Approach: Java is case-sensitive. Literals like null, true, and false are reserved lowercase tokens. Using uppercase NULL is interpreted as an undeclared variable or constant, causing a compile-time “cannot find symbol” error. Step-by-Step Solution: The compiler reads NULL as an identifier, not a literal. Because it is undeclared, the compiler reports: “cannot find symbol: variable NULL” (or similar). Compilation fails; program does not run. Verification / Alternative check: Change to String str = null; and the code compiles; it prints null because printing a null reference writes the string “null”. Why Other Options Are Wrong: There is no runtime because compilation fails; printing “NULL” or “null” requires a successful run. Common Pitfalls: Confusing literals with identifiers; carrying over uppercase NULL from other languages or SQL; overlooking Java’s strict case sensitivity. Final Answer: Compile Error

Question 20

In Java command-line arguments, what is printed by this program when executed as shown?

public class Test 
{ 
 public static void main (String[] args) 
 {
 String foo = args[1]; 
 String bar = args[2]; 
 String baz = args[3]; 
 System.out.…

Accepted Answer

Introduction / Context: This question tests Java command-line argument indexing and what happens when you access an array element that does not exist. The code prints the value of args[3] after assigning several variables from the args array. Understanding zero-based indexing and the number of arguments passed is crucial. Given Data / Assumptions: Program is executed with: java Test red green blue Therefore: args[0] = "red", args[1] = "green", args[2] = "blue" The code reads args[1], args[2], args[3] Concept / Approach: Java arrays are zero-indexed. If the length is 3, valid indices are 0, 1, and 2. Any attempt to access args[3] when only three elements are present will throw ArrayIndexOutOfBoundsException at runtime. This occurs before the print statement executes, so no normal output line is printed. Step-by-Step Solution: Length of args = 3Read foo = args[1] → "green" (valid)Read bar = args[2] → "blue" (valid)Read baz = args[3] → index 3 out of bounds (invalid)Runtime throws ArrayIndexOutOfBoundsException; System.out.println is never reached Verification / Alternative check: If the invocation had four tokens after the class name (e.g., java Test a b c d), then args[3] would be "d" and the print would succeed. The provided invocation has only three arguments. Why Other Options Are Wrong: baz = or baz = null: No line prints because the exception occurs before printing. baz = blue: That would require args[3] to exist; it does not. No output is produced: While effectively true in terms of normal output, the precise outcome is a runtime exception, which is the most accurate choice. Common Pitfalls: Forgetting zero-based indexing and assuming the first argument is args[1]; or assuming Java silently ignores out-of-range accesses (it does not). Final Answer: Runtime Exception

Objects and Collections Questions