What is the key difference in approach between the Merge Sort and Quick Sort algorithms?

  • Merge Sort is a comparison-based sorting algorithm that divides the array into smaller subarrays, sorts them, and then merges them back together.
  • Merge Sort is an in-place sorting algorithm that rearranges elements within the original array.
  • Quick Sort is a stable sorting algorithm that maintains the relative order of equal elements.
  • Quick Sort uses a divide-and-conquer approach and selects a pivot element to partition the array into two subarrays.
The key difference in approach between Merge Sort and Quick Sort lies in how they divide and conquer. Merge Sort divides the array into smaller subarrays, sorts them, and then merges them back together. Quick Sort, on the other hand, selects a pivot element and partitions the array into two subarrays, which are then sorted independently. Merge Sort is not an in-place sorting algorithm, while Quick Sort typically is.

The primitive data type boolean in Java can have the values ________ or ________.

  • Yes, No
  • True, False
  • 0, 1
  • Positive, Negative
In Java, the boolean data type can only have two possible values: true or false. These values represent binary logic where true means "yes" or "on," and false means "no" or "off." It is essential to understand the fundamental concept of boolean data type for conditional expressions and logical operations in Java.

How does Java restrict a class from being used to create objects?

  • By declaring it as an abstract class
  • By marking its constructor as private
  • By specifying it as a singleton class
  • By using the final keyword
In Java, when you mark a class constructor as private, it prevents the class from being instantiated from outside the class, effectively restricting the creation of objects. Abstract classes can't be instantiated directly, but this is not the primary means of restriction. The final keyword prevents subclassing but doesn't restrict object creation. A singleton pattern controls object creation, but it's not the typical way to restrict a class.

Considering memory usage and performance, what is the impact of using += for string concatenation in a loop?

  • += creates a new string object in each iteration, leading to high memory usage and poor performance.
  • += is optimized by the Java compiler, resulting in low memory usage and good performance.
  • += is suitable for small string concatenations but not recommended for large-scale operations.
  • += is the same as using StringBuilder and is always the best choice for string concatenation.
Using += for string concatenation in a loop can have a significant impact on memory usage and performance. It creates a new string object in each iteration, leading to increased memory consumption and reduced performance, especially for large-scale operations. It is not optimized by the Java compiler, unlike using StringBuilder, which is more efficient for concatenating strings in a loop.

When a thread acquires a lock for a synchronized method, it ________ the entry of other threads for all synchronized methods.

  • blocks
  • ignores
  • permits
  • suspends
When a thread acquires a lock for a synchronized method, it blocks the entry of other threads for all synchronized methods in the same object or class. This means that while one thread is inside a synchronized method, other threads attempting to enter any synchronized method of the same object or class will be blocked until the lock is released by the executing thread. This ensures exclusive access to synchronized methods, preventing data corruption in multi-threaded scenarios.

Which method should be used to release the resources held by a Statement object immediately?

  • close()
  • execute()
  • finalize()
  • release()
In JDBC, the close() method should be used to release the resources held by a Statement object immediately. This method should be called when you're done using a Statement to free up resources, like database connections and memory. The other options do not serve this purpose.

Which of the following classes are byte stream classes in Java?

  • FileInputStream and FileOutputStream
  • FileInputStream and Reader
  • FileReader and FileOutputStream
  • FileReader and Writer
Byte stream classes in Java are used for handling binary data. The correct options are FileInputStream and FileOutputStream, as they are used to read and write binary data to files. FileReader and Reader are character stream classes used for reading text data, not binary data.

What is the difference between an abstract class and an interface when Java 8 introduced default methods in interfaces?

  • An abstract class can contain both abstract and concrete methods, whereas an interface can only have abstract methods.
  • An abstract class cannot be extended, but an interface can be implemented.
  • An abstract class cannot have any methods with default implementations, while an interface can have default methods.
  • An abstract class cannot have constructors, but an interface can have default constructors.
In Java 8, interfaces were enhanced to support default methods, which provide a default implementation. The key difference between an abstract class and an interface is that an abstract class can have both abstract and concrete methods, whereas an interface can only have abstract methods. This allows for multiple inheritance of behavior through interfaces while maintaining the ability to inherit state through abstract classes.

Which sorting algorithm repeatedly steps through the list, compares adjacent elements, and swaps them if they are in the wrong order?

  • Bubble Sort
  • Insertion Sort
  • Merge Sort
  • Quick Sort
Bubble Sort is a simple sorting algorithm that repeatedly steps through the list to be sorted, compares adjacent elements, and swaps them if they are in the wrong order. It is known for its simplicity but is less efficient than other sorting algorithms like Quick Sort and Merge Sort in terms of time complexity.

What is the impact of using Lambda expressions on Java's Garbage Collection?

  • Lambda-generated objects are never collected by Garbage Collection.
  • Lambda-generated objects may lead to more frequent Garbage Collection.
  • Lambdas are directly managed by Garbage Collection.
  • Lambdas have no impact on Garbage Collection.
Lambda expressions in Java can generate additional objects, known as "captured variables" or "closure instances." These objects may lead to more frequent Garbage Collection, as they are subject to memory management. However, Java's Garbage Collection system is designed to efficiently handle short-lived objects, so the impact is often minimal. Understanding this impact is essential for optimizing memory usage in applications that heavily use Lambdas.