# epam interview process

## **1\. Java Basics**

* **JVM, JRE, JDK** – understand the difference.
    
* **Data types & Variables** – primitive vs reference types.
    
* **Operators** – arithmetic, relational, logical, bitwise.
    
* **Control statements** – if, switch, loops (for, while, do-while).
    
* **Type Casting** – implicit (widening) vs explicit (narrowing).
    

---

## **2\. Object-Oriented Programming (OOP)**

* **Classes & Objects** – creation, instance vs static variables.
    
* **Constructors** – default, parameterized, constructor overloading.
    
* **Inheritance** – single, multilevel, hierarchical; super keyword.
    
* **Polymorphism**
    
    * **Compile-time (Method Overloading)**
        
    * **Runtime (Method Overriding)** – rules, @Override annotation.
        
* **Encapsulation** – getters, setters, access modifiers.
    
* **Abstraction** – abstract classes, interfaces.
    
* **Association, Aggregation, Composition** – object relationships.
    

---

## **3\. Core Java Concepts**

* **String & StringBuilder / StringBuffer** – immutability, common methods.
    
* **Wrapper Classes & Autoboxing / Unboxing** – Integer, Double, etc.
    
* **Enums & Annotations** – enum basics, usage, built-in annotations.
    
* **Static & final keywords** – static methods, variables, final classes.
    

---

## **4\. Exception Handling**

* **Checked vs Unchecked Exceptions** – examples and rules.
    
* **Try-catch-finally** – flow, multiple catch blocks.
    
* **Throws vs Throw** – differences.
    
* **Custom exceptions** – how to create your own.
    

---

## **5\. Collections Framework**

* **List, Set, Map** – differences and implementations.
    
    * ArrayList vs LinkedList
        
    * HashSet vs TreeSet
        
    * HashMap vs TreeMap vs LinkedHashMap
        
* **Queue & Deque** – PriorityQueue, ArrayDeque.
    
* **Iterator & ListIterator** – traversal & modification.
    
* **Collections class & Arrays class utility methods**.
    

---

## **6\. Generics**

* Generic classes, methods, and interfaces.
    
* Wildcards – `?`, `extends`, `super`.
    
* Type safety & benefits.
    

---

## **7\. Multithreading & Concurrency**

* **Thread creation** – `extends Thread` vs `implements Runnable`.
    
* **Thread methods** – start(), run(), sleep(), join(), yield().
    
* **Synchronization** – synchronized block & method.
    
* **Concurrent utilities** – ExecutorService, ConcurrentHashMap, etc.
    

---

## **8\. Java I/O & NIO**

* **File, FileReader, FileWriter, BufferedReader, BufferedWriter**.
    
* **Serialization / Deserialization** – Serializable interface.
    
* **NIO basics** – Paths, Files, Channels, Buffers.
    

---

## **9\. Java 8 Features** (Highly important in interviews)

* **Lambda expressions** – syntax, functional interfaces.
    
* **Streams API** – filter, map, collect, reduce.
    
* **Optional** – avoid null pointer exceptions.
    
* **Method references** – static, instance, constructor references.
    
* **Default & static methods in interfaces**.
    

---

## **10\. Miscellaneous / Advanced Core**

* **Java Memory Model** – stack vs heap, garbage collection basics.
    
* **Immutable objects** – how to create, examples.
    
* **equals() & hashCode()** – contract and importance in collections.
    
* **Comparable vs Comparator** – sorting objects.
    
* **Design patterns basics** – Singleton, Factory (optional but helpful).
    

## 📌 **Core Data Structures**

1. **Arrays**
    
    * Basics: Searching, Sorting (linear search, binary search, bubble/insertion/selection sort)
        
    * Sliding Window problems (max sum subarray, longest substring without repeat)
        
    * Prefix sum & Kadane’s Algorithm
        
2. **Strings**
    
    * Palindrome check, anagram check
        
    * String reversal, substring problems
        
    * Pattern matching basics (Naïve, KMP idea)
        
3. **Linked List**
    
    * Singly & Doubly linked list basics
        
    * Reversal of linked list (iterative & recursive)
        
    * Detect & remove cycle (Floyd’s algorithm)
        
    * Merge two sorted linked lists
        
4. **Stack & Queue**
    
    * Implement using array/linked list
        
    * Balanced parentheses, Next Greater Element
        
    * Min/Max stack
        
    * Queue variations: Circular queue, Deque
        
    * Problems: LRU cache idea, sliding window maximum
        
5. **Hashing**
    
    * HashMap/HashSet basics
        
    * Count frequency of elements
        
    * Two-sum problem
        
    * Subarray with given sum
        
6. **Trees**
    
    * Binary Tree vs Binary Search Tree (BST)
        
    * Traversals: Preorder, Inorder, Postorder, Level order
        
    * Lowest Common Ancestor (LCA)
        
    * Height, diameter of tree
        
    * Balanced Binary Tree
        
    * BST operations (insert, search, delete)
        
7. **Graphs**
    
    * Representations (Adjacency list/matrix)
        
    * BFS, DFS
        
    * Shortest path (Dijkstra, BFS for unweighted)
        
    * Minimum Spanning Tree (Prim’s, Kruskal’s – just basics for freshers)
        
    * Cycle detection in graph
        
8. **Heap**
    
    * Min-heap, Max-heap basics
        
    * Heap sort
        
    * Priority queue applications
        
    * Top K elements problems
        

---

## 📌 **Algorithms**

1. **Sorting & Searching**
    
    * Merge Sort, Quick Sort
        
    * Binary Search applications (first/last occurrence, peak element, square root using binary search)
        
2. **Recursion & Backtracking**
    
    * Factorial, Fibonacci using recursion
        
    * N-Queens, Rat in a Maze, Subset/Permutation generation
        
3. **Dynamic Programming (DP) – Basics**
    
    * Fibonacci (recursive + DP)
        
    * Longest Common Subsequence (LCS)
        
    * 0/1 Knapsack
        
    * Coin change, Minimum steps to reach end
        
4. **Greedy Algorithms**
    
    * Activity selection problem
        
    * Huffman coding (basics)
        
    * Minimum spanning tree (Prim’s/Kruskal’s)
        

## 🔑 SQL Topics Important for EPAM Interviews (Fresher)

### 1\. **Basic SQL Fundamentals**

* What is **DBMS vs RDBMS**
    
* **Primary Key, Foreign Key, Unique, Not Null**
    
* Difference between **DDL, DML, DCL, TCL**
    
* **Normalization & Denormalization** (1NF, 2NF, 3NF basic understanding)
    
* **Indexes** (clustered vs non-clustered)
    

---

### 2\. **SQL Queries (Most Important 💯)**

* **SELECT, WHERE, ORDER BY, GROUP BY, HAVING**
    
* **DISTINCT** usage
    
* **Aggregate functions** (COUNT, SUM, AVG, MAX, MIN)
    
* **String functions** (LIKE, UPPER, LOWER, TRIM, SUBSTRING)
    
* **Date functions** (NOW, DATEADD, DATEDIFF, etc.)
    

👉 These are used heavily in problem-solving.

---

### 3\. **JOINS (High Priority 🚨)**

* **INNER JOIN**
    
* **LEFT JOIN / RIGHT JOIN**
    
* **FULL OUTER JOIN**
    
* **SELF JOIN**
    
* **CROSS JOIN**
    
* Practical problems (e.g., find employees with no manager, find students with no marks, etc.)
    

---

### 4\. **Subqueries & Nested Queries**

* **Scalar subquery** (returns single value)
    
* **IN, ANY, ALL, EXISTS**
    
* Subquery vs JOIN
    
* Correlated subqueries
    

---

### 5\. **Set Operations**

* **UNION vs UNION ALL**
    
* **INTERSECT**
    
* **EXCEPT / MINUS**
    

---

### 6\. **Constraints**

* PRIMARY KEY vs UNIQUE
    
* CHECK, DEFAULT
    
* FOREIGN KEY with ON DELETE CASCADE