DEV Community: Vivek Nishant

Crash Course : Core Java

Vivek Nishant — Wed, 14 Oct 2026 01:59:14 +0000

Complete Core Java Tutorial — All Topics with Examples

A full end-to-end Core Java tutorial. Each section is self-contained with runnable examples.

📚 Table of Contents

Basics & Syntax
Variables, Data Types & Wrappers
Operators
Control Flow
Arrays & Varargs
Strings
OOP — Classes & Objects
OOP — 4 Pillars
Keywords (static, final, this, super, instanceof)
Access Modifiers
Packages & Imports
Object Class Methods
Inner Classes
Enums
Interfaces (Advanced) & Functional Interfaces
Abstract Classes
Exceptions
Generics
Collections Framework
Comparable & Comparator
Iterator
Lambda Expressions
Streams API
Optional
Date & Time API
Regular Expressions
File I/O & NIO
Serialization
Multithreading Basics
Concurrency Utilities
Annotations
Reflection
JVM, Memory & Garbage Collection
Modern Java (var, records, sealed, text blocks)
Interview Essentials

1. Basics & Syntax

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, Java!");
    }
}

Class name = filename (for public class)
main = JVM entry point
Compile: javac HelloWorld.java → Run: java HelloWorld

2. Variables, Data Types & Wrappers

public class DataTypes {
    public static void main(String[] args) {
        // Primitives
        byte b = 127;              // 1 byte
        short s = 32000;           // 2 bytes
        int i = 100_000;           // 4 bytes
        long l = 8_000_000_000L;   // 8 bytes
        float f = 3.14f;           // 4 bytes
        double d = 3.14159;        // 8 bytes
        char c = 'A';              // 2 bytes
        boolean flag = true;       // 1 bit

        // Wrappers
        Integer boxed = 42;        // autoboxing
        int unboxed = boxed;       // unboxing
        Integer parsed = Integer.parseInt("123");
        Double dbl = Double.valueOf("3.14");

        // Constants
        final double PI = 3.14159;
    }
}

Wrapper classes: Byte, Short, Integer, Long, Float, Double, Character, Boolean

3. Operators

public class Operators {
    public static void main(String[] args) {
        int a = 10, b = 3;

        // Arithmetic
        System.out.println(a + b);  // 13
        System.out.println(a / b);  // 3
        System.out.println(a % b);  // 1

        // Relational
        System.out.println(a > b);  // true
        System.out.println(a == b); // false

        // Logical
        System.out.println(a > 5 && b < 5);  // true
        System.out.println(a > 5 || b > 5);  // true
        System.out.println(!(a > 5));        // false

        // Bitwise
        System.out.println(5 & 3);  // 1
        System.out.println(5 | 3);  // 7
        System.out.println(5 ^ 3);  // 6
        System.out.println(~5);     // -6
        System.out.println(5 << 1); // 10
        System.out.println(5 >> 1); // 2

        // Increment
        int x = 5;
        System.out.println(x++);  // 5, x=6
        System.out.println(++x);  // 7

        // Ternary
        String r = (a > b) ? "a" : "b";
    }
}

4. Control Flow

public class ControlFlow {
    public static void main(String[] args) {
        int score = 85;

        // if-else
        if (score >= 90) System.out.println("A");
        else if (score >= 80) System.out.println("B");
        else System.out.println("C");

        // switch (traditional)
        int day = 2;
        switch (day) {
            case 1: System.out.println("Mon"); break;
            case 2: System.out.println("Tue"); break;
            default: System.out.println("Other");
        }

        // switch expression (Java 14+)
        String type = switch (day) {
            case 1, 7 -> "Weekend";
            case 2, 3, 4, 5, 6 -> "Weekday";
            default -> "Invalid";
        };

        // for
        for (int i = 1; i <= 3; i++) System.out.print(i + " ");

        // while
        int n = 3;
        while (n > 0) { System.out.print(n-- + " "); }

        // do-while (runs at least once)
        int k = 0;
        do { System.out.print(k++ + " "); } while (k < 3);

        // for-each
        int[] arr = {1, 2, 3};
        for (int v : arr) System.out.print(v + " ");

        // break / continue
        for (int i = 0; i < 5; i++) {
            if (i == 2) continue;   // skip
            if (i == 4) break;      // exit
            System.out.print(i + " ");
        }
    }
}

5. Arrays & Varargs

import java.util.Arrays;

public class ArrayDemo {
    // Varargs
    static int sum(int... nums) {
        int total = 0;
        for (int n : nums) total += n;
        return total;
    }

    public static void main(String[] args) {
        // 1D
        int[] arr = {5, 2, 8, 1};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));

        // 2D
        int[][] matrix = {{1, 2}, {3, 4}};
        for (int[] row : matrix)
            for (int v : row)
                System.out.print(v + " ");

        // Jagged array
        int[][] jagged = new int[3][];
        jagged[0] = new int[]{1};
        jagged[1] = new int[]{2, 3};

        // Varargs
        System.out.println(sum(1, 2, 3, 4));  // 10
    }
}

6. Strings

public class StringDemo {
    public static void main(String[] args) {
        String s = "Hello World";

        // Common methods
        System.out.println(s.length());                  // 11
        System.out.println(s.charAt(0));                 // H
        System.out.println(s.substring(0, 5));           // Hello
        System.out.println(s.toUpperCase());             // HELLO WORLD
        System.out.println(s.toLowerCase());             // hello world
        System.out.println(s.contains("World"));         // true
        System.out.println(s.startsWith("He"));          // true
        System.out.println(s.endsWith("ld"));            // true
        System.out.println(s.indexOf("o"));              // 4
        System.out.println(s.replace("World", "Java"));  // Hello Java
        System.out.println(s.trim());
        System.out.println(s.split(" ")[0]);             // Hello
        System.out.println(s.equals("Hello World"));     // true
        System.out.println(s.equalsIgnoreCase("HELLO WORLD")); // true
        System.out.println("  ".isBlank());              // true
        System.out.println(String.join("-", "a", "b"));  // a-b

        // String immutability
        String a = "abc";
        a.concat("def");        // "abcdef" discarded
        System.out.println(a);  // abc

        // StringBuilder (fast, mutable)
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 5; i++) sb.append(i).append(",");
        System.out.println(sb);  // 0,1,2,3,4,

        // StringBuffer (thread-safe)
        StringBuffer sbf = new StringBuffer("Hi");
        sbf.append(" there");

        // String pool
        String x = "hi";
        String y = "hi";
        System.out.println(x == y);          // true (pool)
        String z = new String("hi");
        System.out.println(x == z);          // false (new object)
        System.out.println(x.equals(z));     // true
    }
}

Rule: Use StringBuilder in loops, String for constants, StringBuffer for threads.

7. OOP — Classes & Objects

class Student {
    // Fields (encapsulation)
    private String name;
    private int age;

    // Static field
    private static int totalStudents = 0;

    // Constructor
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        totalStudents++;
    }

    // Copy constructor
    public Student(Student other) {
        this(other.name, other.age);
    }

    // Getters / Setters
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }

    // Instance method
    public void display() {
        System.out.println(name + ", " + age);
    }

    // Static method
    public static int getTotalStudents() { return totalStudents; }
}

public class OOPDemo {
    public static void main(String[] args) {
        Student s1 = new Student("Alice", 20);
        Student s2 = new Student(s1);
        s1.display();
        System.out.println("Total: " + Student.getTotalStudents());
    }
}

8. OOP — 4 Pillars

8.1 Encapsulation

class Account {
    private double balance;
    public double getBalance() { return balance; }
    public void deposit(double amt) {
        if (amt > 0) balance += amt;
    }
}

8.2 Inheritance

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

class Dog extends Animal {
    @Override
    void sound() { System.out.println("Woof"); }
    void fetch() { System.out.println("Fetching"); }
}

8.3 Polymorphism

// Compile-time (overloading)
class MathUtil {
    int add(int a, int b) { return a + b; }
    double add(double a, double b) { return a + b; }
    int add(int a, int b, int c) { return a + b + c; }
}

// Runtime (overriding)
public class Poly {
    public static void main(String[] args) {
        Animal a = new Dog();  // upcasting
        a.sound();             // Woof (runtime)
    }
}

8.4 Abstraction

abstract class Shape {
    abstract double area();
    void info() { System.out.println("Area = " + area()); }
}

class Circle extends Shape {
    double r;
    Circle(double r) { this.r = r; }
    @Override double area() { return Math.PI * r * r; }
}

9. Keywords

public class Keywords {
    static int staticVar = 10;       // shared
    final int FINAL_VAR = 100;       // constant
    String name = "A";
    String name2 = name;             // this.name equivalent

    static { System.out.println("Static block"); }  // runs once

    Keywords() {
        // this() — call another constructor
        this("default");
    }

    Keywords(String name) {
        this.name = name;             // this — refers to current object
    }

    void show() {
        System.out.println(this.name);  // this keyword
    }

    public static void main(String[] args) {
        Object o = "hello";
        if (o instanceof String s) {     // pattern matching
            System.out.println(s.length());
        }
    }
}

class Base { void greet() { System.out.println("Base"); } }
class Child extends Base {
    @Override void greet() {
        super.greet();                 // super — parent method
        System.out.println("Child");
    }
}

Keyword	Purpose
`static`	Belongs to class, not instance
`final`	Constant / no override / no inherit
`this`	Current object
`super`	Parent class
`instanceof`	Type check

10. Access Modifiers

Modifier	Same Class	Same Package	Subclass	Anywhere
`private`	✅	❌	❌	❌
default	✅	✅	❌	❌
`protected`	✅	✅	✅	❌
`public`	✅	✅	✅	✅

11. Packages & Imports

package com.myapp.models;

import java.util.List;
import java.util.*;                     // wildcard
import static java.lang.Math.PI;       // static import
import static java.lang.Math.*;        // static wildcard

public class User { }

12. Object Class Methods

class Person {
    String name;
    int age;

    Person(String name, int age) { this.name = name; this.age = age; }

    @Override public String toString() { return name + " (" + age + ")"; }

    @Override public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Person p)) return false;
        return age == p.age && name.equals(p.name);
    }

    @Override public int hashCode() { return 31 * name.hashCode() + age; }
}

public class ObjectDemo {
    public static void main(String[] args) {
        Person p1 = new Person("A", 20);
        Person p2 = new Person("A", 20);
        System.out.println(p1.equals(p2));   // true
        System.out.println(p1.hashCode() == p2.hashCode()); // true
        System.out.println(p1);              // uses toString()
    }
}

Contract: If a.equals(b), then a.hashCode() == b.hashCode().

13. Inner Classes

public class Outer {
    private int x = 10;

    // Member inner
    class Inner {
        void show() { System.out.println(x); }
    }

    // Static nested
    static class StaticNested {
        void show() { System.out.println("Static nested"); }
    }

    void method() {
        // Local
        class Local { void show() { System.out.println("Local"); } }
        new Local().show();

        // Anonymous
        Runnable r = new Runnable() {
            public void run() { System.out.println("Anonymous"); }
        };
        r.run();
    }

    public static void main(String[] args) {
        Outer o = new Outer();
        Outer.Inner in = o.new Inner();
        in.show();
        new Outer.StaticNested().show();
    }
}

14. Enums

enum Day {
    MON, TUE, WED, THU, FRI, SAT, SUN;

    boolean isWeekend() { return this == SAT || this == SUN; }
}

enum Status {
    SUCCESS(200), NOT_FOUND(404), ERROR(500);

    private final int code;
    Status(int code) { this.code = code; }
    int getCode() { return code; }
}

public class EnumDemo {
    public static void main(String[] args) {
        Day d = Day.SAT;
        System.out.println(d.isWeekend());         // true
        System.out.println(d.name());              // SAT
        System.out.println(d.ordinal());           // 5

        for (Day day : Day.values()) System.out.print(day + " ");
        System.out.println(Day.valueOf("MON"));    // MON

        System.out.println(Status.ERROR.getCode()); // 500
    }
}

15. Interfaces (Advanced) & Functional Interfaces

interface Vehicle {
    void start();                             // abstract
    default void stop() { System.out.println("Stopped"); }  // default
    static void info() { System.out.println("Vehicle"); }   // static
}

@FunctionalInterface
interface Calculator { int operate(int a, int b); }

public class InterfaceDemo {
    public static void main(String[] args) {
        Vehicle v = () -> System.out.println("Car started");  // lambda
        v.start();
        v.stop();
        Vehicle.info();

        Calculator add = (a, b) -> a + b;
        Calculator mul = (a, b) -> a * b;
        System.out.println(add.operate(2, 3));  // 5
        System.out.println(mul.operate(2, 3));  // 6
    }
}

Built-in functional interfaces:

Interface	Method	Purpose
`Function<T,R>`	`apply`	T → R
`Predicate<T>`	`test`	T → boolean
`Supplier<T>`	`get`	() → T
`Consumer<T>`	`accept`	T → void
`BiFunction<T,U,R>`	`apply`	(T,U) → R

16. Abstract Classes vs Interfaces

Feature	Abstract Class	Interface
Fields	Any	`public static final` only
Constructors	✅	❌
Methods	Abstract + concrete	Abstract + default + static
Multiple inheritance	❌	✅
When to use	Shared state/code	Capability/contract

abstract class Shape {
    abstract double area();
    void show() { System.out.println("Area: " + area()); }
}

interface Drawable { void draw(); }

class Circle extends Shape implements Drawable {
    double r;
    Circle(double r) { this.r = r; }
    @Override double area() { return Math.PI * r * r; }
    @Override public void draw() { System.out.println("O"); }
}

17. Exceptions

// Custom checked exception
class InsufficientBalanceException extends Exception {
    InsufficientBalanceException(String msg) { super(msg); }
}

// Custom unchecked
class InvalidAgeException extends RuntimeException {
    InvalidAgeException(String msg) { super(msg); }
}

public class ExceptionDemo {
    static void withdraw(double bal, double amt) throws InsufficientBalanceException {
        if (amt > bal) throw new InsufficientBalanceException("Low balance");
        System.out.println("Withdrawn: " + amt);
    }

    public static void main(String[] args) {
        try {
            withdraw(100, 500);
        } catch (InsufficientBalanceException e) {
            System.out.println("Caught: " + e.getMessage());
        } finally {
            System.out.println("Cleanup");
        }

        // Multi-catch
        try {
            int[] a = new int[2];
            a[5] = 10;
        } catch (ArrayIndexOutOfBoundsException | NullPointerException e) {
            System.out.println("Error: " + e.getClass().getSimpleName());
        }

        // try-with-resources
        try (var reader = new java.io.StringReader("hi")) {
            System.out.println(reader.read());
        } catch (Exception e) { }

        // Nested try
        try {
            try { throw new RuntimeException("inner"); }
            finally { System.out.println("inner finally"); }
        } catch (RuntimeException e) { System.out.println("outer catch"); }
    }
}

Hierarchy: Throwable → Error, Exception → RuntimeException (unchecked) & others (checked).

18. Generics

// Generic class
class Box<T> {
    private T value;
    void set(T v) { value = v; }
    T get() { return value; }
}

// Bounded type
class NumberBox<T extends Number> {
    T value;
    double asDouble() { return value.doubleValue(); }
}

// Generic method
class Util {
    static <T> void printArray(T[] arr) {
        for (T t : arr) System.out.print(t + " ");
    }

    // Wildcards
    static void printList(List<?> list) { }
    static void sumList(List<? extends Number> list) { }
    static void addInt(List<? super Integer> list) { }
}

public class GenericsDemo {
    public static void main(String[] args) {
        Box<String> b = new Box<>();
        b.set("Hello");
        System.out.println(b.get());

        NumberBox<Integer> nb = new NumberBox<>();
        nb.value = 5;
        System.out.println(nb.asDouble());

        Util.printArray(new Integer[]{1, 2, 3});
    }
}

Wildcards: ? extends T (producer) | ? super T (consumer) — PECS principle.

19. Collections Framework

import java.util.*;

public class CollectionsDemo {
    public static void main(String[] args) {
        // LIST
        List<String> list = new ArrayList<>();
        list.add("A"); list.add("B"); list.add("A");
        System.out.println(list.get(0));
        System.out.println(list.contains("B"));
        list.remove("A");

        LinkedList<String> ll = new LinkedList<>();
        ll.addFirst("X"); ll.addLast("Y");

        // SET
        Set<Integer> set = new HashSet<>();       // no order
        set.add(1); set.add(2); set.add(1);
        System.out.println(set);                  // [1, 2]

        Set<Integer> linkedSet = new LinkedHashSet<>();  // insertion order
        Set<Integer> treeSet = new TreeSet<>();          // sorted

        // QUEUE / DEQUE
        Queue<Integer> q = new LinkedList<>();
        q.offer(1); q.offer(2);
        System.out.println(q.poll());             // 1

        Deque<Integer> dq = new ArrayDeque<>();
        dq.addFirst(1); dq.addLast(2);

        PriorityQueue<Integer> pq = new PriorityQueue<>();  // min-heap
        pq.offer(5); pq.offer(1); pq.offer(3);
        System.out.println(pq.poll());            // 1

        // MAP
        Map<String, Integer> map = new HashMap<>();
        map.put("A", 1); map.put("B", 2);
        System.out.println(map.get("A"));
        System.out.println(map.getOrDefault("Z", 0));
        map.forEach((k, v) -> System.out.println(k + "=" + v));

        TreeMap<String, Integer> tm = new TreeMap<>();      // sorted keys
        LinkedHashMap<String, Integer> lhm = new LinkedHashMap<>();  // order

        // Utility class
        Collections.sort(list);
        Collections.reverse(list);
        Collections.max(set);
    }
}

Type	Order	Duplicates	Null	Use case
ArrayList	insertion	✅	✅	Fast random access
LinkedList	insertion	✅	✅	Fast insert/delete
HashSet	none	❌	✅ (1)	Fast lookup
LinkedHashSet	insertion	❌	✅ (1)	Order + uniqueness
TreeSet	sorted	❌	❌	Sorted unique
HashMap	none	keys ❌	1 null key	Fast KV
TreeMap	sorted keys	—	❌	Sorted KV
PriorityQueue	heap	✅	❌	Min/max heap

20. Comparable & Comparator

import java.util.*;

class Employee implements Comparable<Employee> {
    String name; int salary;
    Employee(String n, int s) { name = n; salary = s; }

    // Natural ordering by salary
    @Override public int compareTo(Employee e) {
        return Integer.compare(this.salary, e.salary);
    }

    @Override public String toString() { return name + ":" + salary; }
}

public class SortDemo {
    public static void main(String[] args) {
        List<Employee> list = new ArrayList<>(List.of(
            new Employee("A", 5000),
            new Employee("B", 3000),
            new Employee("C", 7000)
        ));

        Collections.sort(list);                     // uses compareTo
        System.out.println(list);

        // Comparator - custom
        list.sort(Comparator.comparing(e -> e.name));
        list.sort(Comparator.comparingInt((Employee e) -> e.salary).reversed());
        list.sort(Comparator.comparing(Employee::getName)
                            .thenComparing(Employee::getSalary));
    }
}

21. Iterator

import java.util.*;

public class IteratorDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(List.of("A", "B", "C"));

        // Iterator
        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            String s = it.next();
            if (s.equals("B")) it.remove();  // safe removal
        }

        // ListIterator (bidirectional)
        ListIterator<String> lit = list.listIterator();
        while (lit.hasNext()) lit.next();
        while (lit.hasPrevious()) System.out.print(lit.previous() + " ");

        // for-each uses iterator internally
        for (String s : list) System.out.print(s + " ");
    }
}

22. Lambda Expressions

import java.util.function.*;

public class LambdaDemo {
    public static void main(String[] args) {
        // No params
        Runnable r = () -> System.out.println("Running");
        r.run();

        // One param
        Consumer<String> c = s -> System.out.println(s);
        c.accept("Hi");

        // Multiple params
        BiFunction<Integer, Integer, Integer> sum = (a, b) -> a + b;
        System.out.println(sum.apply(2, 3));

        // Block body
        Function<Integer, Integer> square = n -> {
            int result = n * n;
            return result;
        };

        // Method reference
        Function<String, Integer> len = String::length;
        Supplier<List<String>> listMaker = ArrayList::new;
        BiFunction<Integer, Integer, Integer> maxFn = Math::max;

        // Predicate
        Predicate<Integer> isEven = n -> n % 2 == 0;
        System.out.println(isEven.test(4));  // true
    }
}

23. Streams API

import java.util.*;
import java.util.stream.*;

public class StreamDemo {
    public static void main(String[] args) {
        List<Integer> nums = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // Filter + map + collect
        List<Integer> evensSquared = nums.stream()
            .filter(n -> n % 2 == 0)
            .map(n -> n * n)
            .collect(Collectors.toList());
        System.out.println(evensSquared);  // [4, 16, 36, 64, 100]

        // Reduce
        int sum = nums.stream().reduce(0, Integer::sum);
        System.out.println(sum);  // 55

        // count, min, max
        long count = nums.stream().filter(n -> n > 5).count();
        Optional<Integer> max = nums.stream().max(Integer::compare);

        // sorted, distinct, limit, skip
        List<Integer> sorted = nums.stream().sorted(Comparator.reverseOrder()).limit(3).collect(Collectors.toList());

        // anyMatch, allMatch, noneMatch
        System.out.println(nums.stream().anyMatch(n -> n > 9));   // true
        System.out.println(nums.stream().allMatch(n -> n > 0));   // true

        // groupingBy
        Map<Boolean, List<Integer>> grouped = nums.stream()
            .collect(Collectors.groupingBy(n -> n % 2 == 0));
        System.out.println(grouped);

        // joining
        String csv = nums.stream().map(String::valueOf).collect(Collectors.joining(","));

        // parallel stream
        long cnt = nums.parallelStream().filter(n -> n % 2 == 0).count();

        // IntStream
        IntStream.range(1, 6).forEach(System.out::print);
        IntStream.rangeClosed(1, 5).sum();

        // flatMap
        List<List<Integer>> nested = List.of(List.of(1, 2), List.of(3, 4));
        List<Integer> flat = nested.stream().flatMap(List::stream).collect(Collectors.toList());
    }
}

24. Optional

import java.util.Optional;

public class OptionalDemo {
    static Optional<String> findName(int id) {
        return id == 1 ? Optional.of("Alice") : Optional.empty();
    }

    public static void main(String[] args) {
        Optional<String> name = findName(1);

        name.ifPresent(System.out::println);
        System.out.println(name.orElse("Unknown"));
        System.out.println(name.orElseGet(() -> "Default"));
        System.out.println(name.map(String::toUpperCase).orElse("N/A"));
        System.out.println(name.filter(s -> s.startsWith("A")).isPresent());

        // orElseThrow
        String n = findName(1).orElseThrow(() -> new RuntimeException("Not found"));
    }
}

25. Date & Time API

import java.time.*;
import java.time.format.DateTimeFormatter;

public class DateTimeDemo {
    public static void main(String[] args) {
        LocalDate today = LocalDate.now();
        LocalTime time = LocalTime.now();
        LocalDateTime dt = LocalDateTime.now();
        ZonedDateTime zdt = ZonedDateTime.now(ZoneId.of("Asia/Kolkata"));

        LocalDate birthday = LocalDate.of(1995, Month.JUNE, 15);
        LocalDate nextWeek = today.plusWeeks(1);
        LocalDate lastMonth = today.minusMonths(1);

        System.out.println(today.isAfter(birthday));
        System.out.println(birthday.getDayOfWeek());
        System.out.println(birthday.lengthOfMonth());

        // Duration / Period
        Duration d = Duration.between(LocalTime.of(10, 0), LocalTime.of(12, 30));
        Period p = Period.between(birthday, today);

        // Format / parse
        DateTimeFormatter fmt = DateTimeFormatter.ofPattern("dd-MM-yyyy HH:mm");
        System.out.println(dt.format(fmt));
        LocalDate parsed = LocalDate.parse("15-06-1995", DateTimeFormatter.ofPattern("dd-MM-yyyy"));

        // Instant (timestamp)
        Instant now = Instant.now();
        System.out.println(now.toEpochMilli());
    }
}

26. Regular Expressions

import java.util.regex.*;

public class RegexDemo {
    public static void main(String[] args) {
        String text = "Contact: alice@example.com, bob@test.org";

        Pattern p = Pattern.compile("[a-z]+@[a-z]+\\.[a-z]+");
        Matcher m = p.matcher(text);
        while (m.find()) System.out.println(m.group());

        // Common methods
        System.out.println("abc123".matches("\\w+"));            // true
        System.out.println("123".replaceAll("\\d", "X"));        // XXX
        System.out.println("a,b,c".split(",").length);           // 3

        // Validate email
        String email = "user@mail.com";
        System.out.println(email.matches("^[\\w.]+@[\\w.]+\\.[a-z]{2,}$"));
    }
}

Common patterns: \\d digit, \\w word, \\s space, . any, * 0+, + 1+, ? optional, {n,m} range, [] class, () group.

27. File I/O & NIO

import java.io.*;
import java.nio.file.*;
import java.util.List;

public class FileDemo {
    public static void main(String[] args) throws IOException {
        Path path = Path.of("demo.txt");

        // Write (NIO)
        Files.writeString(path, "Line 1\nLine 2\n");

        // Read (NIO)
        String content = Files.readString(path);
        List<String> lines = Files.readAllLines(path);

        // Stream lines
        Files.lines(path).forEach(System.out::println);

        // Check / delete
        System.out.println(Files.exists(path));
        // Files.delete(path);

        // BufferedWriter (classic)
        try (BufferedWriter bw = new BufferedWriter(new FileWriter("out.txt"))) {
            bw.write("Hello");
            bw.newLine();
        }

        // BufferedReader (classic)
        try (BufferedReader br = new BufferedReader(new FileReader("out.txt"))) {
            String line;
            while ((line = br.readLine()) != null) System.out.println(line);
        }

        // Byte streams
        try (FileInputStream in = new FileInputStream("out.txt")) {
            int b;
            while ((b = in.read()) != -1) { /* process */ }
        }
    }
}

28. Serialization

import java.io.*;

class User implements Serializable {
    private static final long serialVersionUID = 1L;
    String name;
    transient String password;   // not serialized
    static String role = "user"; // not serialized

    User(String name, String pwd) { this.name = name; this.password = pwd; }
}

public class SerializationDemo {
    public static void main(String[] args) throws Exception {
        User u = new User("Alice", "secret");

        // Serialize
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("user.ser"))) {
            oos.writeObject(u);
        }

        // Deserialize
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("user.ser"))) {
            User restored = (User) ois.readObject();
            System.out.println(restored.name + " / " + restored.password);  // password null
        }
    }
}

29. Multithreading Basics

class MyThread extends Thread {
    public void run() {
        for (int i = 0; i < 3; i++)
            System.out.println(Thread.currentThread().getName() + ": " + i);
    }
}

class MyRunnable implements Runnable {
    public void run() { System.out.println("Runnable running"); }
}

public class ThreadDemo {
    public static void main(String[] args) throws InterruptedException {
        MyThread t1 = new MyThread();
        t1.setName("T1");
        t1.start();

        Thread t2 = new Thread(new MyRunnable());
        t2.start();

        // Lambda
        Thread t3 = new Thread(() -> System.out.println("Lambda thread"));
        t3.start();

        // Lifecycle methods
        t1.join();           // wait
        Thread.sleep(100);   // pause

        // Thread states: NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED

        // Synchronization
        Counter c = new Counter();
        Thread a = new Thread(() -> { for (int i = 0; i < 1000; i++) c.increment(); });
        Thread b = new Thread(() -> { for (int i = 0; i < 1000; i++) c.increment(); });
        a.start(); b.start();
        a.join(); b.join();
        System.out.println(c.getCount());  // 2000
    }
}

class Counter {
    private int count = 0;
    public synchronized void increment() { count++; }  // thread-safe
    public int getCount() { return count; }
}

30. Concurrency Utilities

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

public class ConcurrencyDemo {
    public static void main(String[] args) throws Exception {
        // Thread pool
        ExecutorService pool = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 5; i++) {
            pool.submit(() -> System.out.println(Thread.currentThread().getName()));
        }
        pool.shutdown();
        pool.awaitTermination(1, TimeUnit.SECONDS);

        // Callable + Future
        ExecutorService ex = Executors.newSingleThreadExecutor();
        Future<Integer> future = ex.submit(() -> 2 + 3);
        System.out.println(future.get());  // 5
        ex.shutdown();

        // Atomic classes
        AtomicInteger counter = new AtomicInteger(0);
        counter.incrementAndGet();
        counter.compareAndSet(1, 10);

        // Concurrent collections
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
        CopyOnWriteArrayList<String> cowList = new CopyOnWriteArrayList<>();
        BlockingQueue<Integer> queue = new LinkedBlockingQueue<>();
        queue.put(1);
        queue.take();

        // Locks
        ReentrantLock lock = new ReentrantLock();
        lock.lock();
        try { /* critical section */ }
        finally { lock.unlock(); }

        // CountDownLatch
        CountDownLatch latch = new CountDownLatch(3);
        // ... latch.countDown(); latch.await();
    }
}

31. Annotations

import java.lang.annotation.*;
import java.lang.reflect.*;

// Custom annotation
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface MyAnnotation {
    String value() default "default";
    int priority() default 1;
}

class Service {
    @MyAnnotation(value = "hello", priority = 5)
    public void doWork() { }

    @Deprecated
    public void oldMethod() { }

    @Override
    public String toString() { return "Service"; }

    @SuppressWarnings("unchecked")
    public void unchecked() { }
}

public class AnnotationDemo {
    public static void main(String[] args) throws Exception {
        Method m = Service.class.getMethod("doWork");
        MyAnnotation ann = m.getAnnotation(MyAnnotation.class);
        System.out.println(ann.value() + " / " + ann.priority());
    }
}

Built-in: @Override, @Deprecated, @SuppressWarnings, @FunctionalInterface, @SafeVarargs

32. Reflection

import java.lang.reflect.*;

class Employee {
    private String name = "Alice";
    public int age = 25;
    public Employee() { }
    public Employee(String name) { this.name = name; }
    public void greet() { System.out.println("Hi " + name); }
    private void secret() { System.out.println("Secret"); }
}

public class ReflectionDemo {
    public static void main(String[] args) throws Exception {
        Class<?> cls = Class.forName("Employee");

        // Fields
        for (Field f : cls.getDeclaredFields())
            System.out.println(f.getName() + " : " + f.getType());

        // Methods
        for (Method m : cls.getDeclaredMethods())
            System.out.println(m.getName());

        // Create instance
        Object obj = cls.getDeclaredConstructor().newInstance();

        // Access private field
        Field nameField = cls.getDeclaredField("name");
        nameField.setAccessible(true);
        nameField.set(obj, "Bob");

        // Invoke method
        Method greet = cls.getMethod("greet");
        greet.invoke(obj);
    }
}

33. JVM, Memory & Garbage Collection

public class MemoryDemo {
    public static void main(String[] args) {
        Runtime rt = Runtime.getRuntime();
        System.out.println("Max: " + rt.maxMemory() / 1024 / 1024 + " MB");
        System.out.println("Total: " + rt.totalMemory() / 1024 / 1024 + " MB");
        System.out.println("Free: " + rt.freeMemory() / 1024 / 1024 + " MB");

        // Trigger GC (hint only)
        System.gc();

        // Create garbage
        for (int i = 0; i < 100000; i++) { Object o = new Object(); }
    }
}

JVM Memory:
| Area | Stores |
|------|--------|
| Heap | Objects, class instances |
| Stack | Method frames, local variables, references |
| Metaspace | Class metadata |
| PC Register | Current instruction |
| Native Stack | Native method calls |

Class Loading: Bootstrap → Extension → Application

GC Collectors: Serial, Parallel, G1, ZGC

34. Modern Java Features

// var (Java 10) - local type inference
var list = new java.util.ArrayList<String>();
var map = new java.util.HashMap<String, Integer>();

// Text blocks (Java 15)
String json = """
    {
        "name": "Alice",
        "age": 25
    }
    """;

// Records (Java 16) - immutable data carriers
record Point(int x, int y) {
    Point { if (x < 0) throw new IllegalArgumentException(); }  // compact ctor
}

// Sealed classes (Java 17)
sealed interface Shape permits Circle, Square { }
record Circle(double r) implements Shape { }
record Square(double s) implements Shape { }

// Pattern matching for instanceof (Java 16)
Object obj = "hello";
if (obj instanceof String s) System.out.println(s.length());

// Pattern matching for switch (Java 21)
String describe(Object o) {
    return switch (o) {
        case Integer i -> "int: " + i;
        case String s -> "str: " + s;
        case null -> "null";
        default -> "unknown";
    };
}

public class ModernJava {
    public static void main(String[] args) {
        Point p = new Point(3, 4);
        System.out.println(p.x() + "," + p.y());  // accessors
        System.out.println(p);                    // auto toString
    }
}

35. Interview Essentials — Quick Reference

Difference Tables

Topic	A	B
`String` vs `StringBuilder`	Immutable	Mutable
`ArrayList` vs `LinkedList`	Fast access	Fast insert/delete
`HashMap` vs `Hashtable`	Not sync, 1 null key	Sync, no null
`==` vs `equals`	Reference	Content
`final` vs `finally` vs `finalize`	Constant	Cleanup block
Abstract class vs Interface	State + methods	Contract only
`wait()` vs `sleep()`	Releases lock	Holds lock
Checked vs Unchecked	Compile-time	Runtime
`Comparator` vs `Comparable`	External	Internal
`throw` vs `throws`	Throw exception	Declare exception

Common Concepts

Immutability: final fields, defensive copies, no setters
PECS: Producer extends, Consumer super
SOLID principles
Fail-fast vs Fail-safe iterators
Shallow vs Deep copy
Stack vs Heap
Method overloading vs overriding

🎯 Suggested Learning Path

Week 1-2 : Sections 1-8    (basics + OOP)
Week 3   : Sections 9-17   (keywords, enums, exceptions, interfaces)
Week 4   : Sections 18-23  (generics, collections, lambdas, streams)
Week 5   : Sections 24-33  (Optional, I/O, concurrency, JVM)
Week 6   : Sections 34-35  (modern Java + interview prep)

💡 Mini Projects to Practice

Bank Management System — OOP + exceptions + collections
Library Management — Comparator + File I/O
Employee CRUD API — Collections + streams
Multi-threaded File Downloader — Concurrency
Student Result Analyzer — Streams + grouping

2026 - Backend Interview Questions

Vivek Nishant — Sat, 26 Sep 2026 04:49:46 +0000

1. Core Java & OOP

Write an immutable class in Java
Comparable vs Comparator with examples
What is a Functional Interface? Can it have default and static methods?
Explain try-with-resources. What happens if both try and close() throw exceptions?

2. JVM, Memory & Performance

JVM memory management
Your Java application has high GC pauses in production — what would you investigate?
How would you identify a memory leak in a Java application?

3. Concurrency & Multithreading

Multithreading
Producer–Consumer problem
Deadlock example in Java
Implement a thread-safe Singleton using double-checked locking

4. Collections & Internals

Collections internal working
HashMap internal working
How does HashMap handle collisions internally?
ConcurrentHashMap vs HashMap — scenario-based
Explain the internal working of ConcurrentHashMap
Process a large ConcurrentHashMap using multiple threads safely

5. Java 8 & Streams

How does Java 8 Stream API work internally?
Difference between map() vs flatMap() with a real-world example
Write a Java 8 program using flatMap() to flatten a nested list
Sort Employee list using Comparator & Streams
Sort employees by salary
Find Top N highest salaries using Streams
Find employee with highest salary
Find employee with second highest salary
Find the highest-paid employee from each department using Streams
Group employees by department
Count employees by department
Convert List to Map using Streams
Remove duplicates using Streams
Find duplicate elements using Streams
Find highest number in a list using Streams
Find second highest number in a list using Streams
Find first non-repeating character using Streams
Find second non-repeating character using Streams
Count character frequency using Streams
Find employees joining after a given year

6. Data Structures — Arrays & Lists

Find duplicate elements in an array
Merge two sorted arrays
Find all unique triplets whose sum equals a given target
Find duplicate elements in a list
Remove duplicates from a list
Find the highest number in a list
Find the second highest number in a list

7. Data Structures — Strings

Find first non-repeating character in a string
Find second non-repeating character in a string
Find first repeating character in a string
Reverse a string without using inbuilt methods
Reverse words in a sentence
Find longest substring without repeating characters
Find the length of the longest substring containing at most K distinct characters
How would you optimize the K-distinct substring problem to O(n)?
What changes if K = 2?
How would you manage character frequencies efficiently?
Count frequency of characters using HashMap
Remove duplicate characters from a string
String rotation (ajith → thaji)

8. Data Structures — Stacks, Caching & Classic Problems

Balanced parentheses problem using Stack
Implement LRU Cache

9. Algorithms & Sorting

Implement Merge Sort and explain its time and space complexity

10. Spring Boot & REST APIs

CompletableFuture real-time scenario
Retry failed REST API calls
Pagination implementation in Spring Boot
Rate Limiter implementation
Spring Boot exception handling
REST API best practices
How would you design an API that can handle 10K+ requests per second?
How would you prevent duplicate orders if the same request is received twice?
How would you design an API so that it remains backward compatible when the response structure changes?
How does @Transactional work internally in Spring Boot?
How does Dependency Injection work internally in Spring?

11. SQL & Databases

Find the second-highest salary from an Employee table
Find nth highest salary
Find employees having the same salary
Department-wise maximum salary query
Count employees department-wise
Remove duplicate records from a table
Find duplicate rows in a table
Difference between WHERE and HAVING
INNER JOIN vs LEFT JOIN
Pagination using LIMIT & OFFSET
How would you design pagination for millions of records?
SQL optimization
Indexing, composite indexes, and query execution plans
How would you optimize a slow query running on millions of records?
Your database has 100 million records and a query suddenly becomes slow — how would you investigate?
What happens when your database becomes unavailable for 30 seconds?
Two requests update the same DB record simultaneously — how would you handle the race condition?

12. Kafka & Asynchronous Messaging

How would you prevent duplicate processing of Kafka messages?
Kafka is receiving messages faster than consumers can process them — how would you solve it?
How would you handle a Kafka message that repeatedly fails?

13. Microservices & System Design

Microservices communication
How would you design microservices for high availability?
API Gateway vs Load Balancer — what is the difference?
How would you handle failures between two microservices?
One microservice is down — how should dependent services behave?
Explain Circuit Breaker, Retry and Timeout patterns
Retry vs Timeout vs Circuit Breaker — when would you use each?
How would you design a retry mechanism without creating a retry storm?
How would you prevent one slow downstream service from exhausting your application's threads?
How would you maintain consistency when a business operation spans multiple microservices?
How would you handle distributed transactions?
How would you handle duplicate requests?
Designing a scalable payment/transaction backend
What happens if the payment succeeds, but your service crashes before sending the response?
Duplicate payments, idempotency, consistency, retries, and event-driven processing
How would you migrate a Java application from on-premise to Cloud?

14. Debugging, Observability & Performance Tuning

Your API is slow, but CPU and memory are normal — how would you find the bottleneck?
An API's latency suddenly increases from 200ms to 5 seconds — how would you debug it?
Your system works perfectly at normal traffic but fails during a sudden traffic spike — walk me through your debugging approach.
How would you monitor and troubleshoot a production microservices application?

Kafka Top 10 Interview Questions

Vivek Nishant — Wed, 08 Jan 2025 12:24:46 +0000

Here are 10 commonly asked interview questions on Apache Kafka:

1. What is Apache Kafka, and what are its key components?

Answer: Kafka is a distributed event-streaming platform used for building real-time data pipelines and applications.
- Key components:
- Producer: Sends data to topics.
- Consumer: Reads data from topics.
- Broker: Kafka server storing messages.
- Topic: Categories where records are sent.
- Zookeeper/Controller: Manages the Kafka cluster metadata (Zookeeper is being replaced by Kafka Raft in newer versions).

2. How does Kafka ensure message durability and fault tolerance?

Answer: Kafka achieves durability and fault tolerance through:
- Replication: Topics are divided into partitions, and each partition is replicated across multiple brokers.
- Acknowledgements: Producers can request acknowledgments (acks) to ensure messages are written.
- Commit Log: Messages are stored in a log, making them recoverable even after crashes.

3. What is a Kafka partition, and how does it work?

Answer:
- Partitions are the basic unit of parallelism in Kafka.
- Each partition is an ordered sequence of records, and a topic can have one or more partitions.
- Data is distributed across partitions using key-based partitioning or round-robin (default).
- Consumers read data in order within a partition.

4. How does Kafka handle data retention?

Answer:
- Kafka retains data for a configured period (log.retention.ms) or until a storage size limit (log.retention.bytes) is reached.
- Old records are deleted based on these configurations.
- The cleanup policy can also be set to compact to keep only the latest key-value pairs.

5. What is the role of Zookeeper in Kafka?

Answer:
- Zookeeper manages Kafka metadata, including:
- Tracking brokers in the cluster.
- Leader election for partitions.
- Storing configurations for topics and ACLs.
- Starting from Kafka 2.8, Zookeeper is being replaced by KRaft (Kafka Raft) for metadata management.

6. How is Kafka different from traditional message queues like RabbitMQ?

Answer:
- Kafka is designed for distributed systems and focuses on scalability, durability, and high throughput.
- Unlike RabbitMQ, Kafka:
- Retains messages for a configurable period.
- Decouples producers and consumers.
- Supports event replay from logs.

7. Explain the consumer group mechanism in Kafka.

Answer:
- Consumers subscribe to topics as part of a consumer group.
- Kafka ensures that each partition is consumed by only one consumer in a group for parallelism.
- If a consumer fails, another in the group takes over its partitions.

8. What is Kafka’s ISR (In-Sync Replica) mechanism?

Answer:
- ISR refers to replicas of a partition that are fully synchronized with the leader partition.
- Kafka writes only to partitions where all ISR members have acknowledged the write.

9. How do you monitor Kafka performance?

Answer: Common monitoring tools include:
- Metrics: Kafka exposes JMX metrics, such as throughput, replication lag, and disk usage.
- Tools: Prometheus, Grafana, Confluent Control Center.
- Logs: Analyze broker, producer, and consumer logs for issues.

10. What are the common challenges with Kafka, and how can they be mitigated?

Answer:
- Data loss: Configure proper replication and acknowledgment.
- Consumer lag: Monitor lag and scale consumer groups if needed.
- Partition imbalance: Use partition rebalancing tools.
- High latency: Optimize producer/consumer configurations (e.g., batch size, compression).

Angular Interview Questions

Vivek Nishant — Mon, 30 Dec 2024 05:57:06 +0000

Here’s a curated list of the top 20 most-asked Angular interview questions, covering a mix of basic, intermediate, and advanced topics:

1. What is Angular?

Explain Angular as a TypeScript-based framework used for building web applications, focusing on features like modularity, components, and dependency injection.

2. What is the architecture of Angular?

Discuss the structure of Angular applications, including Modules, Components, Templates, Services, Directives, and Routing.

3. What is a Component in Angular?

Explain that a Component is the building block of an Angular application, containing logic (TypeScript), view (HTML), and styling (CSS).

4. What are Directives in Angular?

Define Directives as classes used to modify DOM elements. Differentiate between:

Structural directives (e.g., *ngIf, *ngFor)
Attribute directives (e.g., [ngClass], [ngStyle]).

5. What are the types of Data Binding in Angular?

Explain the four types:

Interpolation: {{expression}}
Property Binding: [property]="value"
Event Binding: (event)="handler()"
Two-way Binding: [(ngModel)]="value"

6. What is Dependency Injection in Angular?

Describe how Angular provides services to components and other services using its built-in dependency injection mechanism.

7. What are Angular Modules?

Discuss how NgModules group related components, directives, pipes, and services into cohesive blocks. Mention the @NgModule decorator.

8. What is the difference between `Template-driven` and `Reactive` forms?

Highlight key differences:

Template-driven forms: Simpler, uses HTML and directives like ngModel.
Reactive forms: More robust, uses FormGroup and FormControl.

9. What are Angular Lifecycle Hooks?

Discuss hooks like:

ngOnInit()
ngOnChanges()
ngAfterViewInit()
ngOnDestroy().

10. What is Angular Routing?

Explain how Angular uses the RouterModule to define routes, navigate between views, and implement lazy loading for performance optimization.

11. What is `HttpClient` in Angular?

Describe it as the Angular service for making HTTP requests. Mention its support for Observables and methods like get(), post(), put(), and delete().

12. What are Pipes in Angular?

Explain how Pipes transform data in templates. Mention built-in pipes (| currency, | date, | async) and how to create custom pipes.

13. What is Change Detection in Angular?

Explain how Angular’s Change Detection checks for updates in the application’s state and updates the DOM accordingly. Mention Zone.js.

14. What is the difference between `ViewChild` and `ContentChild`?

ViewChild: Accesses elements or components in the template.
ContentChild: Accesses projected content inside <ng-content>.

15. What are Angular Guards?

Discuss different guards (CanActivate, CanDeactivate, Resolve, CanLoad) and how they manage navigation and route access.

16. What is the purpose of `RxJS` in Angular?

Explain how RxJS provides Observables for reactive programming, allowing you to handle asynchronous operations efficiently.

17. What is the difference between JIT and AOT Compilation?

JIT (Just-in-Time): Compiles code in the browser at runtime.
AOT (Ahead-of-Time): Compiles code during the build process, leading to faster runtime.

18. What is the difference between `Subject`, `BehaviorSubject`, and `ReplaySubject`?

Explain:

Subject: Basic observable emitting data to subscribers.
BehaviorSubject: Emits the latest value and initial value.
ReplaySubject: Emits a specific number of last values to new subscribers.

19. How do you implement Lazy Loading in Angular?

Discuss splitting the application into feature modules and using loadChildren in the route configuration.

20. How do you handle error scenarios in Angular applications?

Talk about:

Using HttpInterceptor for centralized error handling.
Implementing catchError in RxJS.

Database Interview Questions

Vivek Nishant — Fri, 20 Dec 2024 11:43:51 +0000

Here are the top 20 most commonly asked interview questions for SQL and NoSQL, along with their answers:

SQL Interview Questions with Answers

What is SQL?
- Answer: SQL (Structured Query Language) is a standardized programming language used to manage and manipulate relational databases. It is used for tasks such as querying data, updating data, inserting records, and deleting records.
What is the difference between SQL and NoSQL?
- Answer: SQL databases are relational, structured, and use tables to store data, while NoSQL databases are non-relational, flexible, and can store data in a variety of formats such as key-value, document, columnar, or graph formats. SQL is typically used in applications requiring strong consistency, while NoSQL is better suited for unstructured data and large-scale applications.
What are the different types of JOINs in SQL?
- Answer:
  - INNER JOIN: Returns records that have matching values in both tables.
  - LEFT JOIN (OUTER): Returns all records from the left table and matched records from the right table. Unmatched records from the right table will be NULL.
  - RIGHT JOIN (OUTER): Returns all records from the right table and matched records from the left table. Unmatched records from the left table will be NULL.
  - FULL OUTER JOIN: Returns records when there is a match in either the left or right table. Unmatched records will be NULL.
  - CROSS JOIN: Returns the Cartesian product of both tables (every combination of rows from both tables).
What is normalization and denormalization?
- Answer:
  - Normalization is the process of organizing data in a way that reduces redundancy and dependency, typically through multiple tables linked by foreign keys.
  - Denormalization is the process of combining tables to improve read performance at the cost of redundancy and additional storage.
What is the difference between WHERE and HAVING?
- Answer: WHERE is used to filter rows before grouping (used in SELECT, UPDATE, DELETE queries), while HAVING is used to filter groups after using aggregate functions (used with GROUP BY).
What are aggregate functions in SQL?
- Answer: Aggregate functions operate on a set of values to return a single value. Common aggregate functions are:
  - COUNT()
  - SUM()
  - AVG()
  - MAX()
  - MIN()
What is a primary key and foreign key?
- Answer:
  - Primary Key uniquely identifies each record in a table. It must be unique and cannot contain NULL values.
  - Foreign Key is a field in one table that is a primary key in another table, used to create a relationship between the two tables.
What is an index?
- Answer: An index is a database object that improves the speed of data retrieval operations on a table at the cost of additional space and maintenance time. It is created on columns that are frequently searched.
What are subqueries and how do they differ from joins?
- Answer: A subquery is a query nested within another query. It is used to retrieve data that will be used by the outer query. A join combines data from two or more tables based on a related column, whereas a subquery provides a result that is used in another query (SELECT, INSERT, UPDATE, DELETE).
What is a stored procedure?
- Answer: A stored procedure is a precompiled collection of one or more SQL statements that can be executed as a single unit. It helps in encapsulating business logic, improving performance, and enhancing security.
What are triggers in SQL?
- Answer: A trigger is a special type of stored procedure that automatically executes or fires when certain events occur, such as an INSERT, UPDATE, or DELETE operation on a table.
What is a transaction in SQL?
- Answer: A transaction is a sequence of one or more SQL operations that are treated as a single unit. It ensures data consistency using the ACID properties:
  - Atomicity
  - Consistency
  - Isolation
  - Durability
Explain the difference between UNION and UNION ALL.
- Answer:
  - UNION returns unique rows from multiple SELECT queries (removes duplicates).
  - UNION ALL returns all rows, including duplicates.
What is a view in SQL?
- Answer: A view is a virtual table created by a SELECT query that presents data from one or more tables. It does not store data itself but provides a way to simplify complex queries or secure data access.
What is the difference between a clustered and a non-clustered index?
- Answer:
  - Clustered Index determines the physical order of data in the table and can only have one per table.
  - Non-clustered Index creates a separate object that points to the table’s data and can have multiple indexes per table.
What is data integrity and how is it ensured in SQL?
- Answer: Data integrity ensures the accuracy and consistency of data. It is enforced using constraints like PRIMARY KEY, FOREIGN KEY, UNIQUE, CHECK, and NOT NULL.
What is a schema in SQL?
- Answer: A schema is a logical container for database objects such as tables, views, and procedures. It is used to organize database elements and manage security.
Explain the difference between CHAR and VARCHAR data types.
- Answer:
  - CHAR is a fixed-length character data type. If the data is shorter than the specified length, it is padded with spaces.
  - VARCHAR is a variable-length character data type, which uses only the necessary space to store the data.
What is a composite key?
- Answer: A composite key is a combination of two or more columns in a table that uniquely identifies a record. It is used when no single column can uniquely identify a row.
What are transactions and what is their importance?
- Answer: A transaction is a sequence of operations performed as a single unit. They are important for ensuring the database's ACID properties, ensuring data consistency and reliability in multi-step operations.

NoSQL Interview Questions with Answers

What is NoSQL?
- Answer: NoSQL (Not Only SQL) refers to a class of databases that do not use the traditional relational model. NoSQL databases are flexible, scalable, and can handle unstructured or semi-structured data.
What are the types of NoSQL databases?
- Answer:
  - Key-Value Stores: Store data as key-value pairs (e.g., Redis, DynamoDB).
  - Document Stores: Store data as documents (e.g., MongoDB, CouchDB).
  - Column-Family Stores: Store data in columns rather than rows (e.g., Cassandra, HBase).
  - Graph Databases: Store data as nodes and relationships (e.g., Neo4j).
What is the CAP Theorem?
- Answer: The CAP Theorem states that a distributed database system can provide only two of the following three properties:
  - Consistency: Every read operation will return the most recent write.
  - Availability: Every request will receive a response (either success or failure).
  - Partition Tolerance: The system can handle network partitions.
What is sharding in NoSQL databases?
- Answer: Sharding is the process of distributing data across multiple machines to improve scalability and performance. Each shard contains a portion of the data.
What is denormalization in NoSQL?
- Answer: Denormalization in NoSQL refers to storing data in a way that reduces the need for joins, often by storing repeated or redundant data to optimize read performance.
What is the difference between SQL and NoSQL?
- Answer: SQL databases are relational, table-based, and enforce a fixed schema, whereas NoSQL databases are non-relational, schema-less, and support a variety of data models like key-value, document, column-family, and graph databases.
What is a document store in NoSQL?
- Answer: A document store is a type of NoSQL database that stores data as documents (e.g., JSON, BSON, or XML) rather than rows and columns, making it highly flexible (e.g., MongoDB, CouchDB).
What is a key-value store in NoSQL?
- Answer: A key-value store is a NoSQL database that stores data as key-value pairs, where the key is a unique identifier and the value is the associated data (e.g., Redis, DynamoDB).
What is a column-family store?
- Answer: A column-family store is a type of NoSQL database where data is stored in columns rather than rows. Each column family is a set of rows with a shared schema (e.g., Cassandra, HBase).
What is a graph database?
- Answer: A graph database uses graph structures for semantic queries. Data is stored in nodes (entities) and edges (relationships) with properties (e.g., Neo4j).
What is eventual consistency in NoSQL?
- Answer: Eventual consistency is the consistency

model used in many NoSQL databases, where updates to the data are propagated to all nodes eventually but not necessarily immediately.

What is data replication in NoSQL?
- Answer: Data replication is the process of copying data across multiple nodes or servers to ensure high availability and fault tolerance in NoSQL databases.
What is an index in NoSQL databases?
- Answer: An index in NoSQL databases speeds up data retrieval by creating a reference (lookup table) for specific values, similar to indexing in relational databases.
How do you scale NoSQL databases?
- Answer: NoSQL databases scale horizontally by adding more servers or nodes to handle increased load and distribute data. This is often done via sharding and replication.
What is MapReduce in NoSQL?
- Answer: MapReduce is a programming model used for processing large datasets in parallel. It divides the task into a "Map" step (distribute data) and a "Reduce" step (aggregate results).
What are the limitations of NoSQL databases?
- Answer: NoSQL databases may lack full ACID transactions, making them less suitable for applications requiring strict consistency. They can also struggle with complex queries and relational data models.
What is a document in MongoDB?
- Answer: A document in MongoDB is a record stored in BSON (Binary JSON) format. It is flexible, schema-less, and can contain nested structures.
How does CouchDB handle conflicts in distributed systems?
- Answer: CouchDB uses Multi-Version Concurrency Control (MVCC) and resolves conflicts during replication by using versioning and allowing developers to manually resolve conflicting changes.
What is an atomic operation in NoSQL?
- Answer: An atomic operation ensures that a database operation is completed entirely or not at all, preventing partial updates that could cause data inconsistencies.
What is the role of a NoSQL database in big data?
- Answer: NoSQL databases are ideal for handling big data because they support horizontal scaling, flexible data models, and high availability, making them suitable for processing large volumes of unstructured or semi-structured data.

Microservice Interview Questions

Vivek Nishant — Fri, 20 Dec 2024 11:40:35 +0000

Here are the Top 20 Most Asked Microservices Interview Questions along with detailed answers:

1. What are microservices, and how do they differ from monolithic architectures?

Answer:

Microservices are an architectural style where an application is composed of small, independent services that communicate over a network. Each microservice handles a specific business capability and is independently deployable, scalable, and testable.

In contrast, a monolithic architecture is a traditional design where the application is built as a single unit. This can lead to scalability and maintenance challenges as the application grows.

2. What are the advantages and disadvantages of a microservices architecture?

Answer:

Advantages:

Scalability: Each service can be scaled independently based on its load.
Resilience: Failures in one service do not directly affect others.
Flexibility: Services can use different technologies, programming languages, or databases.
Faster development: Smaller teams can work on different services independently.

Disadvantages:

Complexity: Managing many services can become difficult.
Data consistency: Ensuring consistency between services can be challenging.
Network overhead: Communication between services introduces latency.

3. How does a microservices architecture improve scalability and fault tolerance?

Answer:

Microservices can be scaled independently. If one service experiences high load, it can be scaled without affecting other services. Fault tolerance is improved by isolating failures: if one service fails, it doesn’t bring down the entire application. Techniques like circuit breakers, retries, and replication are used to ensure resilience.

4. What is an API Gateway, and why is it important in a microservices architecture?

Answer:

An API Gateway is a server that acts as an entry point for all client requests in a microservices-based system. It routes requests to the appropriate service, handles authentication, and aggregates responses. It simplifies the client-side logic by providing a single endpoint, reducing the need for clients to manage multiple service endpoints.

5. How do microservices communicate with each other?

Answer:

Microservices communicate using lightweight protocols such as HTTP/REST or gRPC. Common communication methods include:

Synchronous communication: Using HTTP/REST for real-time communication.
Asynchronous communication: Using message brokers like Kafka or RabbitMQ to decouple services.

6. What is service discovery, and how does it work in a microservices environment?

Answer:

Service discovery enables microservices to dynamically find and communicate with each other. When a new service instance is deployed, it registers with a service registry (like Consul, Eureka). Other services can query this registry to locate and interact with the required service.

7. What is the role of containers (e.g., Docker) in microservices?

Answer:

Containers (such as Docker) provide a lightweight, portable way to package microservices. Each service is isolated in its container, ensuring consistency across different environments (development, testing, production). Containers allow microservices to be easily deployed and scaled in a cloud environment.

8. What is a database-per-service pattern, and why is it beneficial in microservices?

Answer:

The database-per-service pattern means that each microservice owns its own database. This ensures that services are loosely coupled, as they don't share a single database. It enables independent scaling, better fault isolation, and allows each service to choose the most appropriate database technology for its needs.

9. What are some common challenges you face when implementing microservices?

Answer:

Complexity: Managing multiple services increases operational complexity.
Data consistency: Handling consistency across distributed services can be difficult.
Monitoring and debugging: Troubleshooting issues in a distributed system can be challenging without the right tools.
Inter-service communication: Managing communication and network latency between services.
Security: Ensuring secure communication between services.

10. What is the Circuit Breaker pattern, and why is it used in microservices?

Answer:

The Circuit Breaker pattern prevents a service from making requests to a failing service. If a service is down or underperforming, the circuit breaker "trips," and further calls are blocked for a period. This prevents cascading failures and gives the system time to recover.

11. How do you handle authentication and authorization across microservices?

Answer:

Authentication and authorization are typically handled using a centralized identity provider (e.g., OAuth, JWT). The API Gateway validates incoming requests and passes the user’s identity and permissions to microservices. Each service uses the information for fine-grained access control.

12. What is the role of a message broker (e.g., RabbitMQ, Kafka) in microservices?

Answer:

A message broker allows microservices to communicate asynchronously. It decouples services, enabling them to operate independently and improve fault tolerance. Common message brokers include Kafka (for high-throughput event streaming) and RabbitMQ (for reliable message delivery).

13. What is the difference between synchronous and asynchronous communication in microservices?

Answer:

Synchronous communication occurs when a client sends a request and waits for a response (e.g., RESTful HTTP API).
Asynchronous communication allows services to send a message and proceed without waiting for an immediate response (e.g., messaging systems like Kafka, RabbitMQ).

14. How do you ensure eventual consistency in a distributed system?

Answer:

Eventual consistency ensures that updates across services will propagate over time, even if they don't happen immediately. Techniques include:

Event-driven architecture: Using events to propagate changes across services.
Sagas: A pattern to manage distributed transactions with compensation for failure.

15. How would you design a fault-tolerant microservices system?

Answer:

A fault-tolerant system includes:

Redundancy: Deploying services in multiple instances.
Circuit Breaker pattern: To prevent failures from cascading.
Retries and timeouts: To handle transient failures.
Failover mechanisms: For automatic service recovery.
Graceful degradation: To continue functioning with limited capabilities when some services fail.

16. What tools or strategies do you use for monitoring microservices?

Answer:

Monitoring tools for microservices include:

Prometheus (metrics collection).
Grafana (visualization of metrics).
ELK Stack (Elasticsearch, Logstash, Kibana) for logging.
Jaeger or Zipkin for distributed tracing.

17. How do you ensure security in microservices, especially when communicating between them?

Answer:

Security measures include:

TLS/SSL encryption for secure communication.
OAuth 2.0 / JWT for authentication and authorization.
API Gateway for centralized security policies.
Service mesh (e.g., Istio) to enforce security policies across services.

18. What is the role of a service mesh (e.g., Istio) in microservices architecture?

Answer:

A service mesh provides a dedicated infrastructure layer for managing microservices communication. It handles load balancing, service discovery, observability, and security without requiring changes to the services themselves. Tools like Istio allow you to enforce policies, monitor traffic, and secure communications.

19. What is API versioning, and how do you handle it in microservices?

Answer:

API versioning is the process of managing changes to an API without breaking client applications. In microservices:

URI Versioning: E.g., /v1/resource.
Header Versioning: E.g., using HTTP headers to specify the API version.
Semantic Versioning: Versioning the API based on the impact of changes (major, minor, patch).

20. How do you approach splitting a monolithic application into microservices?

Answer:

Identify business capabilities: Break the monolithic app into domains (e.g., order, inventory, payments).
Define service boundaries: Ensure each service is loosely coupled and has its own database.
Start with a small module: Convert one or two modules into microservices to test the approach.
Gradual migration: Migrate the remaining components in phases to avoid disruption.

Node JS top 20 questions

Vivek Nishant — Fri, 20 Dec 2024 11:36:38 +0000

Here’s a list of 20 Node.js interview questions, covering both basic and advanced topics for a comprehensive preparation:

Basic Questions

What is Node.js, and why is it used?
- Node.js is a server-side runtime environment based on the V8 JavaScript engine, used for building fast and scalable network applications.
Explain the event loop in Node.js.
- The event loop is the mechanism that handles asynchronous callbacks in a single thread by delegating tasks to the system and processing them as events return.
What are streams in Node.js?
- Streams are objects used for reading or writing continuous chunks of data. Types include:
  - Readable (e.g., file read streams)
  - Writable (e.g., file write streams)
  - Duplex (e.g., sockets)
  - Transform (e.g., zlib for compression).
What is the difference between setImmediate() and process.nextTick()?
- setImmediate(): Executes after the current event loop completes.
- process.nextTick(): Executes before the next event loop iteration begins.
How does Node.js handle concurrency?
- Node.js uses an event-driven, non-blocking I/O model via the event loop. Heavy computations are offloaded to worker threads or background processes.
How do you handle uncaught exceptions in Node.js?
- Use the process.on('uncaughtException', callback) event to handle uncaught exceptions, but it's recommended to exit the process after logging the error.

Intermediate Questions

What is middleware in Node.js? Provide an example.
- Middleware functions in frameworks like Express.js process requests and responses.

   const express = require('express');
   const app = express();

   app.use((req, res, next) => {
     console.log('Middleware executed');
     next(); // Passes control to the next middleware/route handler
   });

   app.get('/', (req, res) => res.send('Hello World'));
   app.listen(3000);

How do you manage environment variables in Node.js?
- Use the dotenv package to load environment variables from a .env file:

   require('dotenv').config();
   console.log(process.env.MY_VARIABLE);

What are worker threads in Node.js?
- Worker threads are used to execute CPU-intensive JavaScript code in parallel, enabling better performance for heavy computations:

   const { Worker } = require('worker_threads');
   const worker = new Worker('./worker.js');

Explain the cluster module in Node.js.

The cluster module allows Node.js to spawn multiple processes (workers) sharing the same server port to leverage multi-core CPUs:

const cluster = require('cluster');
const http = require('http');
if (cluster.isMaster) {
  cluster.fork(); // Create worker processes
} else {
  http.createServer((req, res) => res.end('Hello')).listen(8000);
}

What is the difference between blocking and non-blocking I/O?
- Blocking I/O: Operations that block the event loop until completion (e.g., fs.readFileSync).
- Non-blocking I/O: Operations that allow the event loop to continue while waiting for execution (e.g., fs.readFile).
What is the libuv library in Node.js?
- libuv is a C library used by Node.js to handle the event loop, asynchronous I/O, and thread pool.

Advanced Questions

What are the differences between spawn(), fork(), and exec() in the child_process module?
- spawn(): Executes a command and streams the output.
- fork(): Spawns a new Node.js process for IPC (Inter-Process Communication).
- exec(): Executes a command and buffers the output.
What is the purpose of the cluster module in scaling Node.js applications?
- The cluster module enables horizontal scaling by creating worker processes to handle concurrent requests using multi-core CPUs.
What is the difference between req.params, req.query, and req.body in Express.js?
- req.params: Retrieves route parameters (e.g., /users/:id).
- req.query: Retrieves query string parameters (e.g., /users?id=123).
- req.body: Retrieves payload data from POST/PUT requests.
How do you secure a Node.js application?
- Use HTTPS.
- Validate and sanitize inputs to prevent SQL injection and XSS.
- Implement rate limiting to prevent brute force attacks.
- Use libraries like helmet for HTTP header security.
What are memory leaks in Node.js, and how can you debug them?
- Memory leaks occur when objects are no longer needed but not garbage-collected. Tools like node --inspect, Chrome DevTools, or heapdump can help identify leaks.

What is event emitter, and how is it used in Node.js?

The EventEmitter class allows objects to subscribe to and emit events:

const EventEmitter = require('events');
const emitter = new EventEmitter();

emitter.on('event', () => console.log('Event triggered'));
emitter.emit('event');

How does Node.js handle large file uploads efficiently?

By using streams, Node.js processes chunks of data rather than loading the entire file into memory:

const fs = require('fs');
const server = require('http').createServer((req, res) => {
  req.pipe(fs.createWriteStream('file.txt'));
  res.end('Upload complete');
}).listen(3000);

Explain the role of package-lock.json and why it is important.
- package-lock.json locks dependency versions to ensure consistent installs across environments, improving reproducibility and avoiding unexpected issues.

Bonus Topics

Explain how you would implement WebSockets in Node.js.
Discuss the advantages and challenges of serverless with Node.js.
Implement a custom middleware in Express.js.

Java Stream Notes

Vivek Nishant — Fri, 20 Dec 2024 11:31:06 +0000

Java Streams are part of the Java Collections Framework and were introduced in Java 8. They provide a powerful way to process data in a functional style, making it easier to work with collections and perform tasks like filtering, mapping, and reducing. Streams enable concise, declarative, and readable code.

Here’s a breakdown of key concepts and features of Java Streams:

1. What is a Stream?

A Stream is a sequence of elements supporting various operations to process data. It doesn’t store data itself but operates on the source (e.g., a collection, array, or I/O channel).

Key Characteristics:

Lazy Evaluation: Operations are executed only when a terminal operation is invoked.
Pipeline Processing: Operations can be chained (filter, map, etc.), forming a pipeline.
Immutable: The original source is not modified.

2. How to Create a Stream

Streams can be created in several ways:

import java.util.*;
import java.util.stream.*;

public class StreamExamples {
    public static void main(String[] args) {
        // From a collection
        List<String> list = Arrays.asList("A", "B", "C");
        Stream<String> stream1 = list.stream();

        // From an array
        String[] array = {"X", "Y", "Z"};
        Stream<String> stream2 = Arrays.stream(array);

        // From a range of numbers
        IntStream stream3 = IntStream.range(1, 5); // 1, 2, 3, 4

        // From static methods
        Stream<String> stream4 = Stream.of("Hello", "World");

        // Infinite streams
        Stream<Integer> stream5 = Stream.iterate(0, n -> n + 2); // 0, 2, 4, 6, ...
        Stream<Double> stream6 = Stream.generate(Math::random);
    }
}

3. Types of Stream Operations

Intermediate Operations

These return a new stream and are lazy (not executed until a terminal operation is invoked).
Common Intermediate Operations:
- filter(Predicate): Filters elements based on a condition.
- map(Function): Transforms each element.
- sorted() / sorted(Comparator): Sorts elements.
- distinct(): Removes duplicates.
- limit(n) / skip(n): Limits/skips elements.

Example:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> evenNumbers = numbers.stream()
    .filter(n -> n % 2 == 0) // Keep even numbers
    .map(n -> n * n)         // Square each number
    .collect(Collectors.toList()); // Collect to a list
System.out.println(evenNumbers); // Output: [4, 16]

Terminal Operations

These produce a result or a side effect.
Common Terminal Operations:
- collect(Collector): Collects elements into a collection.
- forEach(Consumer): Performs an action for each element.
- reduce(BinaryOperator): Reduces the stream to a single value.
- count(): Counts elements.
- anyMatch(), allMatch(), noneMatch(): Match predicates.
- findFirst() / findAny(): Finds an element.

Example:

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
String result = names.stream()
    .filter(name -> name.startsWith("B")) // Keep names starting with "B"
    .findFirst()
    .orElse("No match");
System.out.println(result); // Output: Bob

4. Stream Collectors

The Collectors utility class provides ways to collect data from streams.

Examples:

To List: collect(Collectors.toList())
To Map: collect(Collectors.toMap(keyMapper, valueMapper))
Joining Strings: collect(Collectors.joining(", "))
Summarizing Statistics: collect(Collectors.summarizingInt())

Example:

List<String> names = Arrays.asList("John", "Jane", "Jack");
String result = names.stream()
    .collect(Collectors.joining(", ")); // "John, Jane, Jack"
System.out.println(result);

5. Parallel Streams

Parallel Streams divide tasks into smaller chunks and process them in parallel using multiple threads.

Example:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.parallelStream()
    .mapToInt(n -> n * n)
    .sum();
System.out.println(sum); // Output: 55

6. Advanced Features

FlatMap: Flattens nested streams (e.g., converting a list of lists into a single stream).
Primitive Streams: Specialized streams for int, long, and double (e.g., IntStream, DoubleStream).
Custom Collectors: Create custom reduction operations.

Example of flatMap:

List<List<String>> nestedList = Arrays.asList(
    Arrays.asList("A", "B"),
    Arrays.asList("C", "D")
);
List<String> flatList = nestedList.stream()
    .flatMap(List::stream) // Flatten nested lists
    .collect(Collectors.toList());
System.out.println(flatList); // Output: [A, B, C, D]

7. Best Practices

Use parallel streams only when operations are computationally intensive and thread-safe.
Avoid modifying the original collection in stream pipelines.
Use method references (e.g., Class::method) for concise code.

Springboot Interview Questions

Vivek Nishant — Fri, 20 Dec 2024 11:28:46 +0000

Here are 20 top important Spring Boot interview questions every developer should prepare for:

1. What is Spring Boot? Why is it used?

Answer: Spring Boot is a framework designed to simplify the development of Java applications by eliminating boilerplate configurations. It provides features like auto-configuration, embedded servers, and starter dependencies for faster and easier application development.

2. What are the key features of Spring Boot?

Auto-configuration of Spring components.
Embedded servers like Tomcat, Jetty, and Undertow.
Starter dependencies for preconfigured setups.
Spring Boot Actuator for monitoring and management.
Externalized configuration using application.properties or application.yml.

3. What is the purpose of the `@SpringBootApplication` annotation?

Answer: Combines:
- @Configuration: Marks the class as a configuration class.
- @EnableAutoConfiguration: Enables Spring Boot's auto-configuration.
- @ComponentScan: Scans the package for components.

4. What is the difference between Spring and Spring Boot?

Answer:
- Spring Framework: Requires manual configuration of beans, XMLs, and dependencies.
- Spring Boot: Provides auto-configuration, embedded servers, and opinionated defaults to simplify setup.

5. How do you configure a database connection in Spring Boot?

Answer: Add the following in application.properties:

  spring.datasource.url=jdbc:mysql://localhost:3306/mydb
  spring.datasource.username=root
  spring.datasource.password=password
  spring.jpa.hibernate.ddl-auto=update

Include the database driver dependency in your pom.xml.

6. How do you create a RESTful web service in Spring Boot?

Answer: Use @RestController to create endpoints. Example:

  @RestController
  @RequestMapping("/api")
  public class UserController {
      @GetMapping("/users")
      public List<String> getUsers() {
          return List.of("Alice", "Bob", "Charlie");
      }
  }

7. What are Spring Boot starters?

Answer: Starters are pre-configured dependencies for specific functionalities. Examples:
- spring-boot-starter-web: For web applications.
- spring-boot-starter-data-jpa: For JPA and Hibernate.
- spring-boot-starter-security: For Spring Security.

8. What is the Spring Boot Actuator?

Answer: A module for monitoring and managing applications in production. It provides endpoints like /actuator/health and /actuator/metrics.

9. How do you handle exceptions in Spring Boot?

Answer: Use @ControllerAdvice and @ExceptionHandler for global exception handling:

  @ControllerAdvice
  public class GlobalExceptionHandler {
      @ExceptionHandler(RuntimeException.class)
      public ResponseEntity<String> handleException(RuntimeException ex) {
          return new ResponseEntity<>("Error: " + ex.getMessage(), HttpStatus.INTERNAL_SERVER_ERROR);
      }
  }

10. What is the difference between `@RestController` and `@Controller`?

Answer:
- @RestController: Combines @Controller and @ResponseBody. It returns data (JSON/XML).
- @Controller: Used for building web pages (views).

11. What is Spring Data JPA?

Answer: A Spring module for simplifying data access using JPA. It provides repository interfaces like JpaRepository for common database operations.

12. What is the difference between `CrudRepository` and `JpaRepository`?

Answer:
- CrudRepository: Basic CRUD operations.
- JpaRepository: Extends CrudRepository and adds support for JPA-specific features like pagination and batch processing.

13. What is dependency injection, and how does Spring Boot implement it?

Answer: Dependency Injection (DI) is a design pattern where objects are injected into a class rather than being created within it. Spring Boot uses annotations like @Autowired to implement DI.

14. What are Spring Profiles?

Answer: Profiles allow you to define environment-specific configurations (e.g., dev, prod). Activate a profile using:

  spring.profiles.active=dev

15. How does Spring Boot implement security?

Answer: By adding the spring-boot-starter-security dependency, basic authentication is enabled by default. For custom security configurations, you can extend SecurityFilterChain or use WebSecurityConfigurerAdapter.

16. What is the purpose of the `@Qualifier` annotation?

Answer: Used to resolve ambiguity when multiple beans of the same type exist. Example:

  @Service
  public class MyService {
      @Autowired
      @Qualifier("beanName")
      private MyBean myBean;
  }

17. What is the use of `@EnableAutoConfiguration`?

Answer: It enables Spring Boot’s auto-configuration mechanism, scanning the classpath and configuring beans automatically based on the dependencies.

18. How does Spring Boot support microservices?

Answer:
- Embedded servers for standalone deployment.
- RESTful APIs for communication.
- Integration with Spring Cloud for service discovery, configuration management, and circuit breaking.

19. How do you test a Spring Boot application?

Answer: Use Spring Boot Test features:
- @SpringBootTest: Loads the entire application context.
- @WebMvcTest: Tests only the web layer.
- MockMvc: Simulates HTTP requests for testing controllers.

20. How do you externalize configuration in Spring Boot?

Answer: Store configurations in application.properties, application.yml, or external files. You can override them with environment variables or command-line arguments.

JavaScript Interview Questions

Vivek Nishant — Fri, 20 Dec 2024 11:22:15 +0000

Basics

What are the differences between var, let, and const?
Explain the difference between == and === in JavaScript.
What is hoisting in JavaScript?
Explain closures and give an example.
What is the difference between function declaration and function expression?
What is the difference between null and undefined?
What are template literals, and how do you use them?
Explain the difference between synchronous and asynchronous code.
What are arrow functions, and how do they differ from regular functions?
What is the difference between primitive and reference types in JavaScript?

Advanced Topics

What is the event loop in JavaScript?
Explain the concept of Promises in JavaScript.
What are async/await, and how do they work?
Explain callback functions with an example.
What is the difference between shallow and deep copy in JavaScript?
Explain the concept of this in JavaScript.
What are JavaScript Prototypes, and how do they work?
Explain the difference between call(), apply(), and bind().
What is debouncing and throttling? Provide examples.
What is the difference between map(), forEach(), filter(), and reduce()?

DOM & BOM

How do you select elements using JavaScript (e.g., querySelector vs. getElementById)?
What is event delegation, and why is it useful?
How does event bubbling and capturing work in JavaScript?
Explain localStorage, sessionStorage, and cookies.
How do you prevent the default behavior of an event in JavaScript?

ES6+ Features & Best Practices

What are JavaScript modules, and how do you use import and export?
What is destructuring in JavaScript, and how is it used?
What are rest and spread operators in JavaScript?
What is optional chaining (?.) in JavaScript?
Explain the difference between deep equality and shallow equality in JavaScript.

Core Java Interview Questions

Vivek Nishant — Tue, 17 Dec 2024 15:57:56 +0000

Ultimate Guide to Java Interview Questions

If you're preparing for a Java interview, mastering these questions will give you a strong foundation. This post covers all critical Java topics, from Core Java concepts to Advanced topics, including coding challenges. Let's dive in!

Here’s a detailed explanation of the requested topics:

Core Java Basics

Key Features of Java:

Platform Independent: Java code runs on any platform using the JVM.
Object-Oriented: Encourages encapsulation, inheritance, and polymorphism.
Simple and Easy to Learn: Syntax similar to C++ but without complexity like pointers.
Secure: Provides runtime checking, bytecode verification, and a security manager.
Robust: Exception handling and garbage collection help avoid errors.
Multithreaded: Supports concurrent programming with built-in thread management.
High Performance: Uses Just-In-Time (JIT) compiler.
Distributed and Networked: Simplifies distributed system development using APIs.
Dynamic and Extensible: Adapts to evolving requirements through dynamic linking.

Difference Between JDK, JRE, and JVM:

JDK (Java Development Kit): Tools for developing and debugging Java programs, including JRE and compilers.
JRE (Java Runtime Environment): Executes Java applications; includes JVM and libraries.
JVM (Java Virtual Machine): Runs Java bytecode; ensures platform independence.

Difference Between == and .equals():

==: Compares references (memory locations) for objects.
.equals(): Compares content or state of objects. Can be overridden.

Class and Object in Java:

Class: Blueprint defining the properties (fields) and behaviors (methods).
Object: Instance of a class, representing a real-world entity.

public static void main(String[] args) Explained:

public: Accessible from anywhere.
static: No need to instantiate the class.
void: No return value.
main: Entry point of the program.
String[] args: Command-line arguments.

Difference Between String, StringBuilder, and StringBuffer:

String: Immutable; thread-safe.
StringBuilder: Mutable; not thread-safe but faster.
StringBuffer: Mutable; thread-safe with synchronized methods.

Access Modifiers:

Private: Visible within the class.
Default: Visible within the package.
Protected: Visible within the package and subclasses.
Public: Visible everywhere.

Difference Between final, finally, and finalize:

final: Used to declare constants, prevent inheritance, or override.
finally: Block to ensure cleanup after a try block.
finalize(): Method invoked by the garbage collector before destroying an object.

Object-Oriented Programming (OOP)

Four Pillars of OOP:

Encapsulation: Restricts access to internal details. Example: Private fields with public getters/setters.
Abstraction: Hides complexity using interfaces or abstract classes. Example: List interface.
Inheritance: Reuse code by extending parent classes. Example: class Dog extends Animal.
Polymorphism: Behavior changes based on the object. Example: Method overriding.

Difference Between Abstraction and Encapsulation:

Abstraction: Focuses on "what" an object does.
Encapsulation: Focuses on "how" the data is protected.

Method Overloading vs. Overriding:

Overloading: Same method name, different parameters.
Overriding: Subclass modifies a parent class method.

Interface vs. Abstract Class:

Interface: 100% abstraction; methods are implicitly abstract.
Abstract Class: Can have abstract and concrete methods.

Multiple Interfaces: A class can implement multiple interfaces using the implements keyword.

Constructor Overloading Example:

class Example {
    Example() { }
    Example(int a) { }
    Example(String s) { }
}

super and this:

this: Refers to the current object.
super: Refers to the parent class object.

Collections and Data Structures

ArrayList vs. LinkedList:

ArrayList: Faster for random access.
LinkedList: Faster for insertions/deletions.

HashMap, LinkedHashMap, TreeMap:

HashMap: Unordered, fastest.
LinkedHashMap: Maintains insertion order.
TreeMap: Sorted order.

Significance of hashCode() and equals() in HashMap:

Ensures proper key-value mapping by preventing duplicates.

Iterator vs. ListIterator:

Iterator: Traverses in one direction.
ListIterator: Traverses in both directions.

Fail-Fast vs. Fail-Safe:

Fail-Fast: Concurrent modification triggers ConcurrentModificationException.
Fail-Safe: Works on a copy, no exception.

Internal Working of HashMap: Uses buckets for storage, hashing for key-value mapping, and linked lists to resolve collisions.

Multithreading and Concurrency

Creating Threads in Java:

Extending Thread:

  class MyThread extends Thread { public void run() { } }

Implementing Runnable:

  class MyRunnable implements Runnable { public void run() { } }

synchronized Method vs. Block:

Method: Locks entire method.
Block: Locks a specific section.

wait(), notify(), notifyAll():

Used for inter-thread communication.

Volatile Keyword: Ensures visibility of changes across threads.

Exception Handling

Checked vs. Unchecked Exceptions:

Checked: Caught during compile-time (IOException).
Unchecked: Occurs during runtime (ArithmeticException).

Custom Exception Example:

class MyException extends Exception { MyException(String msg) { super(msg); } }

Java 8+ Features

Lambda Expression:

(numbers) -> numbers.stream().mapToInt(Integer::intValue).sum();

Need a deeper dive into specific areas? Let me know!
Common Coding Questions

Write a program to check if a string is a palindrome.
Write a program to find the second-largest element in an array.
Write a program to reverse a linked list.
Write a program to implement a thread-safe Singleton class.
Write a program to find the frequency of characters in a string.
Write a program to demonstrate deadlock and resolve it.
Write a program to check if two strings are anagrams.

Mastering Competitive Coding: String

Vivek Nishant — Sat, 11 May 2024 18:55:51 +0000

Easy level questions

Word Break:
- Input: s = "leetcode", wordDict = ["leet", "code"]
- Output: True
- Explanation: "leetcode" can be segmented into "leet" and "code".
Longest Palindromic Substring:
- Input: s = "babad"
- Output: "bab" or "aba"
- Explanation: Both "bab" and "aba" are valid longest palindromic substrings.
Regular Expression Matching:
- Input: s = "aa", p = "a*"
- Output: True
- Explanation: Pattern "a*" matches zero or more occurrences of 'a'.
Letter Combinations of a Phone Number:
- Input: digits = "23"
- Output: ["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"]
- Explanation: Corresponding letters for digits 2 and 3 are "abc" and "def" respectively.
Valid Palindrome II:
- Input: s = "abca"
- Output: True
- Explanation: By deleting 'b', the resulting string "aca" is a palindrome.
Group Anagrams:
- Input: strs = ["eat", "tea", "tan", "ate", "nat", "bat"]
- Output: [["bat"], ["nat","tan"], ["ate","eat","tea"]]
- Explanation: Anagrams are grouped together.
Minimum Window Substring:
- Input: s = "ADOBECODEBANC", t = "ABC"
- Output: "BANC"
- Explanation: The minimum window substring containing all characters from t is "BANC".
Decode String:
- Input: s = "3[a]2[bc]"
- Output: "aaabcbc"
- Explanation: Decode the string by repeating substrings inside brackets.
Permutations:
- Input: nums = [1,2,3]
- Output: [[1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1]]
- Explanation: All possible permutations of the input list.
Add Binary:
- Input: a = "11", b = "1"
- Output: "100"
- Explanation: Binary addition of "11" and "1" results in "100".