test3qna Flashcards
- What is an ArrayList in Java?
An ArrayList is a dynamic, resizable array provided by Java’s Collections Framework. It allows storage of objects with automatic resizing when items are added or removed, which makes it more flexible than standard arrays. (Week 8–9 ArrayList–Notes )
- How do you declare and create an ArrayList?
To declare an ArrayList, import java.util.ArrayList and use generics to specify the type of elements stored. For example:
ArrayList<String> list = new ArrayList<>();</String>
You can also set an initial capacity (e.g., new ArrayList<>(100)) and, in Java 10+, use var for type inference. (Week 8–9 ArrayList–Notes )
- What is the diamond operator (<>) and how does it simplify ArrayList declarations?
The diamond operator, introduced in Java 7, allows the compiler to infer the generic type, eliminating the need to explicitly repeat it. For example, ArrayList<String> list = new ArrayList<>(); is equivalent to new ArrayList<String>();. (Week 8–9 ArrayList–Notes )</String></String>
- How do you add, insert, remove, and replace elements in an ArrayList?
• Add: Use add(element) to append at the end.
• Insert: Use add(index, element) to insert at a specific position.
• Remove: Use remove(index) to delete an element.
• Replace: Use set(index, element) to update an element at a given index.
• Access: Use get(index) to retrieve an element. (Week 8–9 ArrayList–Notes )
- How does the ArrayList’s toString() method work?
The toString() method returns a string representation of the ArrayList’s contents, displaying elements enclosed in square brackets and separated by commas, which is useful for debugging and logging. (Week 8–9 ArrayList–Notes )
- What is the Java Collections Framework?
The Java Collections Framework is a unified architecture for representing and manipulating collections of objects. It includes interfaces (List, Set, Map), their implementations, and algorithms for operations like sorting and searching. (Week 10 Collections–Notes )
- What is a Java interface and how is it used in collections?
An interface in Java defines a “contract” by declaring method signatures without implementations. In collections, interfaces such as List, Set, and Map allow different implementations to adhere to the same API, ensuring interoperability and flexibility. (Week 10 Collections–Notes )
- How do generics enhance type safety in Java collections?
Generics allow you to specify the type of elements a collection can contain, ensuring compile-time type checking and reducing runtime errors. This eliminates the need for casting when retrieving elements from a collection. (Outside context & Week 8–9 ArrayList–Notes )
- What are the differences between ArrayList and LinkedList?
• ArrayList: Backed by a dynamic array; offers fast random access (O(1) for index lookup) but slower insertion or deletion in the middle of the list.
• LinkedList: Implements a doubly linked list; allows fast insertions/deletions at both ends but slower random access (O(n)). (Week 10 Collections–Notes )
- What is the Vector class, and how does it differ from ArrayList?
The Vector class is similar to ArrayList but includes synchronized methods to ensure thread safety, which can result in slower performance compared to ArrayList that is not synchronized by default. (Week 10 Collections–Notes )
- How does the Stack class work in Java?
The Stack class, which extends Vector, implements a last-in-first-out (LIFO) data structure. It provides operations such as push(), pop(), peek(), and search() to manage elements in a stack. (Week 10 Collections–Notes )
- What is a Queue in Java and what are its primary uses?
A Queue is a first-in-first-out (FIFO) data structure defined by the Queue interface. It is used for scheduling tasks, buffering data, and implementing algorithms such as breadth-first search. (Week 10 Collections–Notes )
- What is the Map interface and what are its common implementations?
The Map interface maps keys to values, allowing keys of any object type rather than just integers. Common implementations include:
• HashMap: Fast lookups based on hash codes.
• TreeMap: Maintains sorted order of keys using a red–black tree. (Week 10 Collections–Notes )
- What is linear (sequential) search and its time complexity?
Linear search sequentially checks each element in a collection until the target is found or the end is reached. Its worst-case time complexity is O(n), where n is the number of elements. (Week 11 Algorithms Analysis–Notes )
- What is binary search and when should it be used?
Binary search is an efficient method for finding an element in a sorted array by repeatedly dividing the search interval in half. It has a time complexity of O(log n) and is ideal for large, sorted data sets. (Week 11 Algorithms Analysis–Notes )
- What is selection sort and what is its performance?
Selection sort repeatedly finds the minimum element from the unsorted portion and places it at the beginning of the list. It has a time complexity of O(n²), making it inefficient for large datasets compared to advanced algorithms. (Week 11 Algorithms Analysis–Notes )
- What is Big O notation and why is it important?
Big O notation expresses the upper bound of an algorithm’s growth rate as input size increases. It abstracts away constant factors and lower-order terms, allowing comparison of algorithm efficiency. (Week 11 Algorithms Analysis–Notes )
- How do best-case, worst-case, and average-case analyses differ in algorithm performance?
• Best-case: Minimum operations required for optimal input.
• Worst-case: Maximum operations required, providing a guarantee of performance.
• Average-case: Expected operations over all inputs; more complex to calculate but useful for probabilistic analysis. (Week 11 Algorithms Analysis–Notes )
- What does “ignoring multiplicative constants and non-dominating terms” mean in Big O analysis?
Big O notation focuses on the dominant term that grows fastest as the input size increases, so constants and lower-order terms are dropped. For example, O(2n) and O(n - 5) are both simplified to O(n). (Week 11 Algorithms Analysis–Notes )
- How do nested loops affect an algorithm’s time complexity?
When loops are nested, their complexities multiply. For example, a loop inside a loop that each runs n times results in O(n²) complexity. If an inner loop runs a constant number of times, the complexity remains O(n). (Week 11 Algorithms Analysis–Notes )
- What are common growth functions used to classify algorithm performance?
Common growth functions include:
• O(1): Constant time
• O(log n): Logarithmic time
• O(n): Linear time
• O(n log n): Log-linear time
• O(n²): Quadratic time
• O(2ⁿ): Exponential time
These classifications help understand how an algorithm scales as input size increases. (Week 11 Algorithms Analysis–Notes )
- What is amortized analysis and how does it relate to ArrayList operations?
Amortized analysis looks at the average cost per operation over a sequence of operations. For example, while an ArrayList may occasionally require an expensive resize operation, the cost is spread out so that the average time per insertion remains constant (O(1)). (Outside context)
- What are recurrence relations and how are they used in algorithm analysis?
Recurrence relations express the running time of recursive algorithms in terms of smaller input sizes. They are used to derive closed-form expressions for the time complexity, such as T(n) = 2T(n/2) + O(n) for merge sort, which resolves to O(n log n). (Week 11 Algorithms Analysis–Notes )
- Why is constant time (O(1)) significant in algorithm design?
An algorithm with O(1) complexity performs its operation in constant time, regardless of input size. This is crucial for operations like array indexing or hash table lookups, ensuring high performance even with large datasets. (Week 11 Algorithms Analysis–Notes )
- How do logarithmic algorithms (O(log n)) work, and why are they efficient?
Logarithmic algorithms reduce the problem size by a constant factor with each step. Binary search is a prime example, as it halves the search interval with every comparison. This efficiency makes logarithmic algorithms extremely scalable for large inputs. (Week 11 Algorithms Analysis–Notes )
- What modern sorting algorithms are generally preferred over selection sort and why?
Modern sorting algorithms such as QuickSort, MergeSort, and TimSort (used by Java’s built-in sort) typically offer average-case complexities of O(n log n), making them much more efficient than selection sort’s O(n²) for larger datasets. (Additional outside information)
What is an exception in Java?
An unexpected error that occurs during program execution, which can halt the program if not handled (e.g., ArrayIndexOutOfBoundsException).
What happens when an exception is thrown?
An exception object is created, containing error details. The program halts unless the exception is caught and handled.
How can you avoid an ArrayIndexOutOfBoundsException?
Check if the index is within bounds: if (index >= 0 && index < array.length).
Exception Handling Mechanisms
What is the purpose of a try block?
It encloses code that might throw an exception. If an exception occurs, control transfers to the matching catch block.
What is the structure of a try-catch statement?
java try { /* code / } catch (ExceptionType e) { / handle error */ }
How does a catch block work?
It catches exceptions of a specified type. The parameter (e.g., InputMismatchException e) references the exception object, allowing access to error details.
What happens if an exception type does not match any catch block?
The exception propagates up the call stack, potentially crashing the program (as if no try block existed).
Checked vs. Unchecked Exceptions
What are checked exceptions?
Exceptions that must be handled or declared (e.g., IOException). They are checked at compile time.
What are unchecked exceptions?
Exceptions that do not require handling (e.g., RuntimeException, NullPointerException). They are often caused by logical errors.
Which classes are unchecked exceptions derived from?
Error (e.g., OutOfMemoryError) or RuntimeException (e.g., ArithmeticException).
Advanced Handling
How do you handle multiple exceptions in a try block?
Use multiple catch clauses or a multi-catch clause: `catch (IOException
What is the purpose of the finally block?
Code in finally executes whether an exception occurs or not. It is often used for cleanup (e.g., closing files).
Can a try block exist without a catch or finally block?
No. A try must be followed by at least one catch or finally block.
Exception Hierarchy and API
What is the root class of all exceptions?
Throwable. Its subclasses are Error and Exception.
How do you retrieve the default error message of an exception?
Use e.getMessage() (e.g., NumberFormatException returns “For input string: ‘abc’”).
Where is InputMismatchException located in the Java API?
In the java.util package. Import it with import java.util.InputMismatchException;.
Additional Concepts (Outside Notes)
What is the difference between throw and throws?
throw explicitly throws an exception (e.g., throw new IOException()). throws declares that a method might throw an exception (e.g., void readFile() throws IOException).
How do you create a custom exception?
Extend Exception (checked) or RuntimeException (unchecked):
class CustomException extends Exception { … }.
What is “try-with-resources”?
A Java 7+ feature for automatic resource management. Resources declared in try (e.g., FileReader) are closed automatically:
try (FileReader fr = new FileReader(file)) { … }.
What is exception propagation?
If an exception is not caught in a method, it propagates to the caller method, continuing until handled or crashing the program.
What is a best practice for logging exceptions?
Log exceptions with details (e.g., e.printStackTrace()) and avoid empty catch blocks that “swallow” errors.
Examples
How would you handle division by zero?
Check the divisor first:
if (number2 != 0) quotient = number1 / number2;
or use try-catch for ArithmeticException.
How would you handle invalid input from Scanner.nextDouble()?
Use try-catch for InputMismatchException:
java<br></br>try {<br></br> double sales = scanner.nextDouble();<br></br>} catch (InputMismatchException e) {<br></br> System.out.println(“Invalid input!”);<br></br>}
Stack Trace and Debugging
What is a stack trace?
A list of methods called before the exception occurred, showing the execution path. Useful for debugging.
How do you print a stack trace?
Use e.printStackTrace() in a catch block.
