Design Patterns and Collections in Java

Inter-service Communication in Distributed Systems

• Implement inter-service communication in a distributed system using tools or protocols.

Design Patterns

• Singleton vs. Prototype:

  • Singleton: one instance per JVM
  • Prototype: a new instance for each request

• Factory Method vs. Abstract Factory:

  • Factory Method: creates objects of one type
  • Abstract Factory: creates families of related objects

• Observer Pattern Benefits: Promotes loose coupling between subjects and observers.

• Caching Mechanism (Decorator Pattern):

  • Wrap the original service with a caching layer to store results

• Real-World Problem (Command Pattern):

  • Encapsulate booking logic into commands and execute them using an invoker for better flexibility

Collections Framework

• HashMap vs. ConcurrentHashMap:
  • HashMap: not thread-safe
  • ConcurrentHashMap: thread-safe

TreeSet vs. HashSet

• TreeSet: maintains elements in sorted order
• HashSet: does not maintain order but provides O(1) time complexity for add,remove, and contains

ArrayList vs. LinkedList

• ArrayList: dynamic array, better for random access
• LinkedList: doubly linked list, better for frequent insertions and deletions

Duplicate Handling in HashSet

• HashSet uses HashMap internally to ensure uniqueness based on hashCode and equals methods

Designing a Data Structure for Unique Items

• Use HashSet for constant-time operations.
• Use ConcurrentHashMap for thread-safe operation. If needed, use Collections.synchronizedSet

Fail-Fast vs. Fail-Safe Iterators

• Fail-fast iterators (e.g., in ArrayList) throw ConcurrentModificationException if the collection is modified structurally during iteration.
• Fail-safe iterators (e.g., in CopyOnWriteArrayList) operate on a snapshot of the collection.

Stream API

• map vs. flatMap:

  • map: transforms each element into another object, maintaining a one-to-one mapping
  • flatMap: flattens streams of streams into a single stream

• collect Method:

  • accumulates elements of a Stream into a container (e.g., List, Set) or custom structures.

• Sequential vs. Parallel Streams:

  • Sequential: processes elements in order, using a single thread
  • Parallel: splits the work into multiple threads, but adds overhead for thread management

Group Employees by Department 

• Use streams to group employees by department and calculate average salary for each department.

Find Second Highest Number

• Use streams to find the second highest number in a list of numbers.

Java 8 Features

• Optional: helps avoid NullPointerException by explicitly representing the presence or absence of a value

• Functional Interfaces: (Function, Consumer, Supplier)

  • Function: Accepts an input and produces a result.
  • Consumer: Accepts an input but produces no result.
  • Supplier: Produces a result with no input.

• default Keyword: Introduced to add methods to interfaces without breaking existing implementations.

• Refactoring Legacy Code:

  • Replace loops with streams
  • Use lambda expressions for anonymous classes implementing functional interfaces

• Method References Example:

  • Use method references (e.g., System.out::println) for cleaner code.

Concurrency

• synchronized vs. ReentrantLock:

  • ReentrantLock: provides more control (e.g., try-lock, fairness)
  • synchronized: easier to use but less flexible

• ForkJoinPool: a pool for tasks that can be broken into smaller subtasks recursively

• CompletableFuture: used for asynchronous programming.

Multi-threaded Transaction Processing

• Use a BlockingQueue for task submission to a thread pool.
• Use Atomic classes (or StampedLock) for contention minimization.

Thread-safe Singleton

• Example implementation of a thread-safe Singleton class in Java

Spring Framework

• Annotations:

  • @Component: General stereotype for Spring-managed components
  • @Service: Specifically for business logic/service layer
  • @Repository: Specifically for persistence layer

• Bean Lifecycle: Instantiation, Dependency Injection, Initialization, Destruction.

• @Transactional: Manages transactions declaratively, ensuring atomicity and consistency

REST API Design

• Use annotations (@RestController, @RequestMapping, @ExceptionHandler, @Valid) for REST API design.
• Use OAuth2 or JWT for authentication.
• Implement role-based access control using @PreAuthorize or @Secured.

Microservices

• API Gateway: acts as a single entry point for microservices, handling routing, load balancing, and authentication
• Synchronous vs. Asynchronous Communication:
  • Synchronous: immediate response needed (e.g., REST API)
  • Asynchronous: decoupled communication (e.g., messaging systems like Kafka)
• Service Discovery: Automatically locates services in a distributed system. Tools: Eureka, Consul, Zookeeper.
• High Availability: Use load balancers, redundant instances, circuit breakers, and retries.
• Inter-service Communication: Use REST (synchronous) or message queues (asynchronous)