Java follows four OOP principles:

• Encapsulation
• Inheritance
• Polymorphism
• Abstraction

Same method name with different parameter lists.

class Calculator {

  int add(int a, int b) {
    return a + b;
  }

  int add(int a, int b, int c) {
    return a + b + c;
  }

}

class Animal {

  void sound() {
    System.out.println("Animal");
  }

}

class Dog extends Animal {

  @Override
  void sound() {
    System.out.println("Bark");
  }

}

String a = new String("Java");
String b = new String("Java");

System.out.println(a == b);
System.out.println(a.equals(b));

class Employee {

  Employee() {
    System.out.println("Created");
  }

}

class Vehicle {

  void start() {}

}

class Car extends Vehicle {

}

class Employee {

  private String name;

  public void setName(String name) {
    this.name = name;
  }

  public String getName() {
    return name;
  }

}

abstract class Shape {

  abstract void draw();

}

interface Payment {

  void pay();

}

class CreditCardPayment implements Payment {

  public void pay() {
    System.out.println("Paid");
  }

}

HashMap stores data using key-value pairs.

1. Calculate hashCode()
2. Find bucket index
3. Store entry in bucket
4. Handle collisions using LinkedList or Tree

Map map = new HashMap<>();

map.put(1, "Java");

map.put(2, "Spring");

Set<Integer> numbers = new TreeSet<>();

numbers.add(10);

numbers.add(5);

numbers.add(20);

employees.sort(

  Comparator.comparing(Employee::getSalary)

);

StringBuilder sb = new StringBuilder();

sb.append("Java");

sb.append(" Interview");

Lambda expressions provide a concise way to represent anonymous functions.

List names = List.of("Java", "Spring");

names.forEach(

  name -> System.out.println(name)

);

An interface with exactly one abstract method.

@FunctionalInterface

interface Calculator {

  int add(int a, int b);

}

• Predicate
• Function
• Consumer
• Supplier

Stream API enables functional-style processing of collections.

List<Integer> numbers = List.of(1,2,3,4,5);

numbers.stream()

  .filter(n -> n % 2 == 0)

  .forEach(System.out::println);

• Readable Code
• Functional Programming
• Parallel Processing

Optional helps avoid NullPointerException.

Optional name =

Optional.ofNullable(null);

System.out.println(

  name.orElse("Guest")

);

• of()
• ofNullable()
• orElse()
• orElseGet()
• isPresent()

JVM memory is divided into several areas used during program execution.

Employee employee = new Employee();

int age = 30;

employee object is stored in Heap while age is stored in Stack.

Garbage Collection automatically removes objects that are no longer reachable.

• Automatic Memory Management
• Reduces Memory Leaks
• Improves Stability

ClassLoader dynamically loads Java classes into memory.

• Bootstrap ClassLoader
• Platform ClassLoader
• Application ClassLoader

Serialization converts an object into a byte stream.

public class Employee

implements Serializable {

  private String name;

}

• Caching
• Messaging Systems
• File Storage
• Network Transfer

Reflection allows inspection and modification of classes at runtime.

Class<?> clazz = Employee.class;

Method[] methods = clazz.getMethods();

• Spring Framework
• Hibernate
• JUnit

Synchronization prevents multiple threads from accessing critical sections simultaneously.

public synchronized void deposit() {

  balance += 100;

}

ConcurrentHashMap provides thread-safe access without locking the entire map.

Map users =

new ConcurrentHashMap<>();

users.put(1, " Vijay"); 

• Thread Safe
• Better Performance Than Hashtable
• High Concurrency Support

Write a program to reverse a string without using built-in reverse methods.

String input = "Java";

String reversed = new StringBuilder(input)
  .reverse()
  .toString();

System.out.println(reversed);

A palindrome reads the same forwards and backwards.

String input = "madam";

String reversed = new StringBuilder(input)
  .reverse()
  .toString();

System.out.println(
  input.equals(reversed)
);

String str = "java";

Map map = new HashMap<>();

for(char ch : str.toCharArray()) {

  map.put(
    ch,
    map.getOrDefault(ch, 0) + 1
  );

}

System.out.println(map);

Array contains numbers 1 to N with one missing number.

int[] numbers = {1,2,3,5};

int expected = 5 * (5 + 1) / 2;

int actual = Arrays.stream(numbers).sum();

System.out.println(expected - actual);

int a = 0;
int b = 1;

for(int i = 0; i < 10; i++) {

  System.out.print(a + " ");

  int temp = a + b;

  a = b;

  b = temp;

}

int[] numbers = {1,2,3,2,4,1};

Set unique = new HashSet<>();

for(int number : numbers){

  if(!unique.add(number)){

    System.out.println(number);

  }

}

Create a thread-safe Singleton.

public class Singleton {

  private static final Singleton INSTANCE =
      new Singleton();

  private Singleton() {}

  public static Singleton getInstance() {

    return INSTANCE;

  }

}

public final class Employee {

  private final String name;

  public Employee(String name) {

    this.name = name;

  }

  public String getName() {

    return name;

  }

}

employees.stream()

  .sorted(
    Comparator.comparing(
      Employee::getSalary
    )
  )

  .forEach(System.out::println);

Explain how you would implement an LRU Cache in Java.

Map cache =
new LinkedHashMap<>(
  16,
  0.75f,
  true
);

• HashMap
• Doubly Linked List
• Collections Framework
• Design Skills

• Order Service
• Inventory Service
• Payment Service
• Notification Service
• Message Queue
• Cache Layer

Expected Discussion

• Database Transactions
• Event Driven Architecture
• Scalability
• Failure Handling

• Email
• SMS
• Push Notifications
• In-App Notifications

Architecture

Client
  ↓
Notification API
  ↓
Message Queue
  ↓
Email / SMS / Push Workers

Services communicate by publishing and consuming events.

Order Created Event

      ↓

Kafka Topic

      ↓

Inventory Service
Payment Service
Notification Service

• Loose Coupling
• Scalability
• Resilience
• Independent Deployments

Prevents cascading failures when dependent services are unavailable.

• Closed
• Open
• Half Open

• Two Phase Commit (2PC)
• Saga Pattern
• Compensating Transactions

• Application Cache
• Redis
• CDN Cache
• Database Cache

Cache Patterns

• Cache Aside
• Write Through
• Write Behind
• Read Through

• Heap Size
• GC Logs
• Thread Dumps
• Memory Leaks
• CPU Profiling

-Xms2G
-Xmx4G

-XX:+UseG1GC

-XX:MaxGCPauseMillis=200

• URL Generator
• Database
• Cache
• Analytics
• Redirect Service

Scalability Considerations

• Read Replicas
• Redis Cache
• Rate Limiting
• Load Balancing

• Spring Boot
• WebSocket
• Redis Pub/Sub
• Kafka
• MySQL/PostgreSQL

Client

   ↕

WebSocket Server

   ↕

Redis Pub/Sub

   ↕

Chat Service

   ↕

Database

Features

• Presence Detection
• Typing Indicators
• Read Receipts
• Message Persistence
• Horizontal Scaling