Complete Java Programming Guide

Fundamentals to Advanced Data Structures and

Algorithms

Table of Contents
1. Fundamental Programming
2. String Manipulation
3. Array Operations
4. Linked List
5. Stack and Queue
6. Recursion
7. Sorting and Searching

Fundamental Programming
1. Reverse a Number Using While Loop
public class ReverseNumber {
public static int reverseNumber(int num) {
int reversed = 0;
while (num != 0) {
reversed = reversed * 10 + num % 10;
num /= 10;
}
return reversed;
}

public static void main(String[] args) {

int number = 12345;
[Link]("Original: " + number);
[Link]("Reversed: " + reverseNumber(number));
}
}

2. Check if a Number is Prime

public class PrimeChecker {
public static boolean isPrime(int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;

for (int i = 5; i * i <= n; i += 6) {

if (n % i == 0 || n % (i + 2) == 0) {
return false;
 }
}
return true;
}

public static void main(String[] args) {

int num = 29;
[Link](num + " is prime: " + isPrime(num));
}
}

3. Fibonacci Series - Iteration and Recursion

public class Fibonacci {
// Iterative approach
public static void fibonacciIterative(int n) {
int a = 0, b = 1;
[Link]("Fibonacci (Iterative): " + a + " " + b + " ");

for (int i = 2; i < n; i++) {

int next = a + b;
[Link](next + " ");
a = b;
b = next;
}
[Link]();
}

// Recursive approach
public static int fibonacciRecursive(int n) {
if (n <= 1) return n;
return fibonacciRecursive(n - 1) + fibonacciRecursive(n - 2);
}

public static void main(String[] args) {

int n = 10;
fibonacciIterative(n);

[Link]("Fibonacci (Recursive): ");

for (int i = 0; i < n; i++) {
[Link](fibonacciRecursive(i) + " ");
}
[Link]();
}
}

4. Armstrong Number Check

public class ArmstrongNumber {
public static boolean isArmstrong(int num) {
int original = num;
int digits = [Link](num).length();
int sum = 0;

while (num > 0) {

int digit = num % 10;
sum += [Link](digit, digits);
num /= 10;
}
 return sum == original;
}

public static void main(String[] args) {

int num = 153;
[Link](num + " is Armstrong: " + isArmstrong(num));
}
}

5. Factorial - Iterative and Recursive

public class Factorial {
// Iterative approach
public static long factorialIterative(int n) {
long result = 1;
for (int i = 2; i <= n; i++) {
result *= i;
}
return result;
}

// Recursive approach
public static long factorialRecursive(int n) {
if (n <= 1) return 1;
return n * factorialRecursive(n - 1);
}

public static void main(String[] args) {

int n = 5;
[Link]("Factorial (Iterative): " +
factorialIterative(n));
[Link]("Factorial (Recursive): " +
factorialRecursive(n));
}
}

6. Method Overloading and Overriding

// Method Overloading
class Calculator {
public int add(int a, int b) {
return a + b;
}

public double add(double a, double b) {

return a + b;
}

public int add(int a, int b, int c) {

return a + b + c;
}
}

// Method Overriding
class Animal {
public void makeSound() {
[Link]("Animal makes a sound");
}
}

class Dog extends Animal {

@Override
public void makeSound() {
[Link]("Dog barks");
}
}

public class OverloadingOverriding {

public static void main(String[] args) {
Calculator calc = new Calculator();
[Link]("Overloading: " + [Link](5, 3));
[Link]("Overloading: " + [Link](5.5, 3.2));
[Link]("Overloading: " + [Link](1, 2, 3));

Animal animal = new Dog();

[Link](); // Overriding
}
}

7. Palindrome Number Check

public class PalindromeNumber {
public static boolean isPalindrome(int num) {
int original = num;
int reversed = 0;

while (num > 0) {

reversed = reversed * 10 + num % 10;
num /= 10;
}

return original == reversed;

}

public static void main(String[] args) {

int num = 121;
[Link](num + " is palindrome: " + isPalindrome(num));
}
}

8. Class Hierarchy with Inheritance

class Vehicle {
protected String brand;
protected int year;

public Vehicle(String brand, int year) {

[Link] = brand;
[Link] = year;
}

public void start() {

[Link]("Vehicle is starting");
}
}

class Car extends Vehicle {

 private int doors;

public Car(String brand, int year, int doors) {

super(brand, year);
[Link] = doors;
}

@Override
public void start() {
[Link]("Car " + brand + " is starting with " + doors +
" doors");
}
}

class Motorcycle extends Vehicle {

private boolean hasSidecar;

public Motorcycle(String brand, int year, boolean hasSidecar) {

super(brand, year);
[Link] = hasSidecar;
}

@Override
public void start() {
[Link]("Motorcycle " + brand + " is starting");
}
}

9. Swap Two Numbers Without Third Variable

public class SwapNumbers {
public static void swapUsingArithmetic(int a, int b) {
[Link]("Before swap: a = " + a + ", b = " + b);
a = a + b;
b = a - b;
a = a - b;
[Link]("After swap: a = " + a + ", b = " + b);
}

public static void swapUsingXOR(int a, int b) {

[Link]("Before swap: a = " + a + ", b = " + b);
a = a ^ b;
b = a ^ b;
a = a ^ b;
[Link]("After swap: a = " + a + ", b = " + b);
}

public static void main(String[] args) {

swapUsingArithmetic(10, 20);
swapUsingXOR(15, 25);
}
}

10. Final, Static, and This Keywords

public class KeywordExample {
private static final String COMPANY_NAME = "TechCorp"; // final and
static
private static int employeeCount = 0; // static
 private final int employeeId; // final instance variable
private String name;

public KeywordExample(String name) {

[Link] = name; // this keyword
[Link] = ++employeeCount; // this keyword
}

public static void displayCompanyInfo() { // static method

[Link]("Company: " + COMPANY_NAME);
[Link]("Total Employees: " + employeeCount);
}

public void displayInfo() {

[Link]("Employee ID: " + [Link]);
[Link]("Name: " + [Link]);
}

public static void main(String[] args) {

KeywordExample emp1 = new KeywordExample("John");
KeywordExample emp2 = new KeywordExample("Jane");

[Link]();
[Link]();
[Link]();
}
}

String Manipulation
1. Reverse String Without Built-in Methods
public class ReverseString {
public static String reverseString(String str) {
char[] chars = [Link]();
int left = 0, right = [Link] - 1;

while (left < right) {

char temp = chars[left];
chars[left] = chars[right];
chars[right] = temp;
left++;
right--;
}

return new String(chars);

}

public static void main(String[] args) {

String str = "Hello World";
[Link]("Original: " + str);
[Link]("Reversed: " + reverseString(str));
}
}

2. Check if Two Strings are Anagrams

import [Link];

public class AnagramChecker {

public static boolean areAnagrams(String str1, String str2) {
if ([Link]() != [Link]()) {
return false;
}

char[] chars1 = [Link]().toCharArray();

char[] chars2 = [Link]().toCharArray();

[Link](chars1);
[Link](chars2);

return [Link](chars1, chars2);

}

public static void main(String[] args) {

String str1 = "listen";
String str2 = "silent";
[Link]("Are anagrams: " + areAnagrams(str1, str2));
}
}

3. First Non-Repeating Character

import [Link];
import [Link];

public class FirstNonRepeating {

public static char findFirstNonRepeating(String str) {
Map<Character, Integer> charCount = new HashMap<>();

// Count frequency of each character

for (char c : [Link]()) {
[Link](c, [Link](c, 0) + 1);
}

// Find first character with count 1

for (char c : [Link]()) {
if ([Link](c) == 1) {
return c;
}
}

return '\0'; // No non-repeating character found

}

public static void main(String[] args) {

String str = "programming";
char result = findFirstNonRepeating(str);
[Link]("First non-repeating character: " + result);
}
}

4. String Palindrome Check

public class StringPalindrome {
public static boolean isPalindrome(String str) {
 str = [Link]().replaceAll("[^a-zA-Z0-9]", "");
int left = 0, right = [Link]() - 1;

while (left < right) {

if ([Link](left) != [Link](right)) {
return false;
}
left++;
right--;
}

return true;
}

public static void main(String[] args) {

String str = "A man, a plan, a canal: Panama";
[Link]("Is palindrome: " + isPalindrome(str));
}
}

5. Count Vowels and Consonants

public class VowelConsonantCounter {
public static void countVowelsConsonants(String str) {
int vowels = 0, consonants = 0;
str = [Link]();

for (char c : [Link]()) {

if ([Link](c)) {
if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c ==
'u') {
vowels++;
} else {
consonants++;
}
}
}

[Link]("Vowels: " + vowels);

[Link]("Consonants: " + consonants);
}

public static void main(String[] args) {

String str = "Hello World";
countVowelsConsonants(str);
}
}

6. Remove Duplicate Characters

import [Link];
import [Link];

public class RemoveDuplicates {

public static String removeDuplicates(String str) {
Set<Character> seen = new LinkedHashSet<>();

for (char c : [Link]()) {

[Link](c);
 }

StringBuilder result = new StringBuilder();

for (char c : seen) {
[Link](c);
}

return [Link]();
}

public static void main(String[] args) {

String str = "programming";
[Link]("Original: " + str);
[Link]("Without duplicates: " + removeDuplicates(str));
}
}

7. String Rotation Check

public class StringRotation {
public static boolean isRotation(String str1, String str2) {
if ([Link]() != [Link]()) {
return false;
}

String combined = str1 + str1;

return [Link](str2);
}

public static void main(String[] args) {

String str1 = "abcde";
String str2 = "cdeab";
[Link]("Is rotation: " + isRotation(str1, str2));
}
}

8. String Compression
public class StringCompression {
public static String compress(String str) {
if ([Link]() == 0) return str;

StringBuilder compressed = new StringBuilder();

int count = 1;
char current = [Link](0);

for (int i = 1; i < [Link](); i++) {

if ([Link](i) == current) {
count++;
} else {
[Link](current).append(count);
current = [Link](i);
count = 1;
}
}

[Link](current).append(count);
 return [Link]() < [Link]() ? [Link]() :
str;
}

public static void main(String[] args) {

String str = "aabcccccaaa";
[Link]("Original: " + str);
[Link]("Compressed: " + compress(str));
}
}

9. Longest Substring Without Repeating Characters

import [Link];
import [Link];

public class LongestSubstring {

public static int lengthOfLongestSubstring(String s) {
Set<Character> set = new HashSet<>();
int maxLength = 0;
int left = 0;

for (int right = 0; right < [Link](); right++) {

while ([Link]([Link](right))) {
[Link]([Link](left));
left++;
}
[Link]([Link](right));
maxLength = [Link](maxLength, right - left + 1);
}

return maxLength;
}

public static void main(String[] args) {

String str = "abcabcbb";
[Link]("Longest substring length: " +
lengthOfLongestSubstring(str));
}
}

10. Word Frequency Counter

import [Link];
import [Link];

public class WordFrequency {

public static void countWordFrequency(String str) {
String[] words = [Link]().split("\\s+");
Map<String, Integer> wordCount = new HashMap<>();

for (String word : words) {

word = [Link]("[^a-zA-Z]", "");
if (![Link]()) {
[Link](word, [Link](word, 0) + 1);
}
}

for ([Link]<String, Integer> entry : [Link]()) {

 [Link]([Link]() + ": " + [Link]());
}
}

public static void main(String[] args) {

String str = "This is a test. This test is only a test.";
countWordFrequency(str);
}
}

Array Operations
1. Find Largest and Smallest Elements
public class ArrayMinMax {
public static void findMinMax(int[] arr) {
if ([Link] == 0) return;

int min = arr[0];

int max = arr[0];

for (int i = 1; i < [Link]; i++) {

if (arr[i] < min) {
min = arr[i];
}
if (arr[i] > max) {
max = arr[i];
}
}

[Link]("Minimum: " + min);

[Link]("Maximum: " + max);
}

public static void main(String[] args) {

int[] arr = {64, 34, 25, 12, 22, 11, 90};
findMinMax(arr);
}
}

2. Sort Array Without Library Methods

public class ArraySorting {
// Bubble Sort
public static void bubbleSort(int[] arr) {
int n = [Link];
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
 public static void printArray(int[] arr) {
for (int value : arr) {
[Link](value + " ");
}
[Link]();
}

public static void main(String[] args) {

int[] arr = {64, 34, 25, 12, 22, 11, 90};
[Link]("Original array:");
printArray(arr);

bubbleSort(arr);
[Link]("Sorted array:");
printArray(arr);
}
}

3. Find Duplicates in Array

import [Link];
import [Link];
import [Link];
import [Link];

public class FindDuplicates {

public static List<Integer> findDuplicates(int[] arr) {
Set<Integer> seen = new HashSet<>();
Set<Integer> duplicates = new HashSet<>();

for (int num : arr) {

if ([Link](num)) {
[Link](num);
} else {
[Link](num);
}
}

return new ArrayList<>(duplicates);

}

public static void main(String[] args) {

int[] arr = {1, 2, 3, 4, 2, 7, 8, 8, 3};
List<Integer> duplicates = findDuplicates(arr);
[Link]("Duplicates: " + duplicates);
}
}

4. Check if Array Contains Specific Element

public class ArraySearch {
public static boolean contains(int[] arr, int target) {
for (int num : arr) {
if (num == target) {
return true;
}
}
return false;
}
 public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5};
int target = 3;
[Link]("Array contains " + target + ": " +
contains(arr, target));
}
}

5. Find Missing Number (1 to n)

public class MissingNumber {
public static int findMissingNumber(int[] arr, int n) {
int expectedSum = n * (n + 1) / 2;
int actualSum = 0;

for (int num : arr) {

actualSum += num;
}

return expectedSum - actualSum;

}

public static void main(String[] args) {

int[] arr = {1, 2, 4, 5, 6}; // Missing 3
int n = 6;
[Link]("Missing number: " + findMissingNumber(arr, n));
}
}

6. Move All Zeros to End

public class MoveZeros {
public static void moveZerosToEnd(int[] arr) {
int nonZeroIndex = 0;

// Move all non-zero elements to the front

for (int i = 0; i < [Link]; i++) {
if (arr[i] != 0) {
arr[nonZeroIndex++] = arr[i];
}
}

// Fill remaining positions with zeros

while (nonZeroIndex < [Link]) {
arr[nonZeroIndex++] = 0;
}
}

public static void printArray(int[] arr) {

for (int value : arr) {
[Link](value + " ");
}
[Link]();
}

public static void main(String[] args) {

int[] arr = {0, 1, 0, 3, 12};
[Link]("Original array:");
 printArray(arr);

moveZerosToEnd(arr);
[Link]("After moving zeros:");
printArray(arr);
}
}

7. Left Rotate Array by One Position

public class LeftRotate {
public static void leftRotateByOne(int[] arr) {
if ([Link] <= 1) return;

int first = arr[0];

for (int i = 0; i < [Link] - 1; i++) {
arr[i] = arr[i + 1];
}
arr[[Link] - 1] = first;
}

public static void printArray(int[] arr) {

for (int value : arr) {
[Link](value + " ");
}
[Link]();
}

public static void main(String[] args) {

int[] arr = {1, 2, 3, 4, 5};
[Link]("Original array:");
printArray(arr);

leftRotateByOne(arr);
[Link]("After left rotation:");
printArray(arr);
}
}

8. Maximum Subarray Sum (Kadane's Algorithm)

public class MaxSubarraySum {
public static int maxSubarraySum(int[] arr) {
int maxSoFar = arr[0];
int maxEndingHere = arr[0];

for (int i = 1; i < [Link]; i++) {

maxEndingHere = [Link](arr[i], maxEndingHere + arr[i]);
maxSoFar = [Link](maxSoFar, maxEndingHere);
}

return maxSoFar;
}

public static void main(String[] args) {

int[] arr = {-2, -3, 4, -1, -2, 1, 5, -3};
[Link]("Maximum subarray sum: " + maxSubarraySum(arr));
}
}
9. Merge Two Sorted Arrays
public class MergeSortedArrays {
public static int[] merge(int[] arr1, int[] arr2) {
int[] result = new int[[Link] + [Link]];
int i = 0, j = 0, k = 0;

while (i < [Link] && j < [Link]) {

if (arr1[i] <= arr2[j]) {
result[k++] = arr1[i++];
} else {
result[k++] = arr2[j++];
}
}

while (i < [Link]) {

result[k++] = arr1[i++];
}

while (j < [Link]) {

result[k++] = arr2[j++];
}

return result;
}

public static void printArray(int[] arr) {

for (int value : arr) {
[Link](value + " ");
}
[Link]();
}

public static void main(String[] args) {

int[] arr1 = {1, 3, 5, 7};
int[] arr2 = {2, 4, 6, 8};

int[] merged = merge(arr1, arr2);

[Link]("Merged array:");
printArray(merged);
}
}

10. Check if Array is Palindrome

public class ArrayPalindrome {
public static boolean isPalindrome(int[] arr) {
int left = 0;
int right = [Link] - 1;

while (left < right) {

if (arr[left] != arr[right]) {
return false;
}
left++;
right--;
}

return true;
}
 public static void main(String[] args) {
int[] arr = {1, 2, 3, 2, 1};
[Link]("Is palindrome: " + isPalindrome(arr));
}
}

Linked List
1. Reverse Linked List (Iterative and Recursive)
class ListNode {
int val;
ListNode next;

ListNode(int val) {
[Link] = val;
}
}

public class ReverseLinkedList {

// Iterative approach
public static ListNode reverseIterative(ListNode head) {
ListNode prev = null;
ListNode current = head;

while (current != null) {

ListNode next = [Link];
[Link] = prev;
prev = current;
current = next;
}

return prev;
}

// Recursive approach
public static ListNode reverseRecursive(ListNode head) {
if (head == null || [Link] == null) {
return head;
}

ListNode reversedHead = reverseRecursive([Link]);

[Link] = head;
[Link] = null;

return reversedHead;
}

public static void printList(ListNode head) {

while (head != null) {
[Link]([Link] + " -> ");
head = [Link];
}
[Link]("null");
}

public static void main(String[] args) {

 ListNode head = new ListNode(1);
[Link] = new ListNode(2);
[Link] = new ListNode(3);
[Link] = new ListNode(4);

[Link]("Original list:");
printList(head);

ListNode reversed = reverseIterative(head);

[Link]("Reversed list:");
printList(reversed);
}
}

2. Detect Loop in Linked List

public class DetectLoop {
public static boolean hasLoop(ListNode head) {
if (head == null || [Link] == null) {
return false;
}

ListNode slow = head;

ListNode fast = head;

while (fast != null && [Link] != null) {

slow = [Link];
fast = [Link];

if (slow == fast) {
return true;
}
}

return false;
}

public static void main(String[] args) {

ListNode head = new ListNode(1);
[Link] = new ListNode(2);
[Link] = new ListNode(3);
[Link] = [Link]; // Create loop

[Link]("Has loop: " + hasLoop(head));

}
}

3. Find Middle of Linked List

public class FindMiddle {
public static ListNode findMiddle(ListNode head) {
if (head == null) return null;

ListNode slow = head;

ListNode fast = head;

while (fast != null && [Link] != null) {

slow = [Link];
fast = [Link];
 }

return slow;
}

public static void main(String[] args