Java Interview Flashcards

Question

How is LinkedHashMap implemented internally in Java?

Answer 1

LinkedHashMap extends HashMap and adds a doubly-linked list connecting entries in insertion order (or access order if enabled). This preserves predictable iteration order. Slightly more memory than HashMap.

Answer 2

TreeMap uses a Red-Black Tree (a self-balancing binary search tree). Keys are sorted either by natural order or a custom Comparator. Operations like get, put, remove are O(log n).

Answer 3

Single Responsibility — one reason to change. Open/Closed — open for extension, closed for modification. Liskov Substitution — derived classes should substitute base classes. Interface Segregation — many small interfaces > one large. Dependency Inversion — depend on abstractions, not concretions.

Answer 4

Keep It Simple, Stupid.

Answer 5

You Aren’t Gonna Need It.

Answer 6

1xx — Informational 2xx — Success 3xx — Redirection 4xx — Client error 5xx — Server error

Answer 7

REST (Representational State Transfer) is an architectural style for APIs. Principles: Uses standard HTTP methods (GET, POST, PUT, DELETE). Stateless communication. Resources identified by URLs. Often uses JSON for data exchange.

Answer 8

JSON (JavaScript Object Notation) is a lightweight data format for representing structured data. It’s easy to read, language-independent, and widely used in REST APIs.

Answer 9

POST → creates a new resource (server assigns ID). PUT → replaces an existing resource entirely (or creates it if missing). PATCH → updates part of a resource (partial change). POST = create PUT = replace PATCH = modify

Answer 10

For primitives, the actual value is copied — changing it inside the method does not affect the original variable. For objects, a copy of the reference is passed — you can modify the object’s fields (affects the original), but reassigning the parameter to a new object affects only the local copy of the reference, not the caller’s variable.

Answer 11

Wrapper types in Java (like Integer, Double, Boolean) are immutable objects. When passed to a method, the reference to the wrapper is passed by value (just like any object). However, since wrappers are immutable, you cannot change their internal value — any operation that looks like a modification actually creates a new object. Reassigning the parameter inside the method does not affect the original variable outside the method.

Answer 12

A Trie (pronounced “try”) — also called a prefix tree — is a tree-based data structure used to store and search strings efficiently by their prefixes. Each node represents a character, and paths from the root represent words.

Answer 13

Any object can be used as a key — but it must satisfy certain requirements for correct behavior: 1. equals() and hashCode() contract For maps like HashMap, LinkedHashMap, or HashSet (which rely on hashing): The key must implement equals() and hashCode() consistently. Two keys that are equal according to equals() must produce the same hash code. The key’s fields used in equals()/hashCode() should be immutable while the key is in the map.

Answer 14

list.size()

Answer 15

System.out.println(Arrays.toString(arr));

Answer 16

array.length

Answer 17

Start from the second element (index 1), treating the first element as a sorted subarray. For each element, compare it with the elements to its left in the sorted part. Shift all larger elements one position to the right to make space. Insert the current element in its correct position. Repeat until the entire array is sorted.

Answer 18

Yes. Arrays in Java are reference types. When passed to a method, a copy of the reference is passed, not a copy of the array. Both variables point to the same array object in memory, so modifying an element affects the original array.

Answer 19

Yes. In Java, arrays are objects that live on the heap. They have a runtime type (e.g. int[], String[]) and contain fields like .length. You can check this with array.getClass() or instanceof Object, both of which return true.

Answer 20

The overriding method is chosen at runtime based on the parameters.

Answer 21

Encapsulation is the bundling of data (attributes) and methods (functions) that operate on that data into a single unit (class). It restricts direct access to some components and protects the internal state of an object by using access modifiers (private, protected, public). This promotes data hiding and allows controlled access through getters and setters.

Answer 22

Abstraction is the concept of hiding complex implementation details and showing only the essential features of an object. It focuses on what an object does rather than how it does it. This is achieved through abstract classes and interfaces, allowing developers to work with simplified models of complex systems and reduce code complexity.

Answer 23

Polymorphism means 'many forms' and allows objects of different classes to be treated as objects of a common parent class. It enables a single interface to represent different underlying forms (data types). There are two types: compile-time polymorphism (method overloading) and runtime polymorphism (method overriding), allowing flexibility and code reusability.

Answer 24

Inheritance is a mechanism where a new class (child/derived class) derives properties and behaviors from an existing class (parent/base class). It promotes code reusability and establishes a hierarchical relationship between classes. The child class inherits all accessible members of the parent class and can add new features or override existing ones.

Answer 25

The Singleton pattern ensures that a class has only one instance throughout the application and provides a global point of access to it. It's implemented by making the constructor private and providing a static method to get the instance. Common uses include database connections, logging, and configuration managers.

Answer 26

The Observer pattern defines a one-to-many dependency between objects where when one object (subject) changes state, all its dependents (observers) are notified automatically. The subject maintains a list of observers and notifies them of state changes. This pattern is widely used in event handling system.

Answer 27

The Strategy pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable. It allows the algorithm to vary independently from clients that use it. In Java, this is typically implemented using interfaces where different classes implement different strategies. Common use cases include sorting algorithms, payment methods, compression algorithms, and validation rules. It promotes the Open/Closed Principle by allowing new strategies without modifying existing code.

Answer 28

The Decorator pattern allows behavior to be added to individual objects dynamically without affecting other objects of the same class. It wraps an object with decorator classes that add new functionality while maintaining the same interface. Java's I/O streams are a classic example (BufferedReader wrapping FileReader). This pattern provides a flexible alternative to subclassing for extending functionality and follows the Single Responsibility Principle.

Answer 29

The Builder pattern separates the construction of a complex object from its representation, allowing step-by-step object creation. It's especially useful for objects with many optional parameters, avoiding telescoping constructors and improving code readability. In Java, it typically uses method chaining with a static inner Builder class that has methods for each parameter and a build() method that returns the final object. Common examples include StringBuilder and building complex objects like HTTP requests or database queries.

Answer 30

The Factory pattern provides an interface for creating objects without specifying their exact classes. It encapsulates object creation logic in a separate factory class or method, promoting loose coupling. Instead of using 'new' directly, clients request objects from the factory. This makes code more flexible and easier to maintain when adding new types. Common in Java for creating different types of database connections, UI components, or document types.

Java Interview Flashcards

Prepare for Java interviews (54 cards)