DEV Community: PONVEL M

10 Simple Recursion Problems (Java, JavaScript, Python)

PONVEL M — Sat, 04 Apr 2026 04:41:41 +0000

Recursion becomes easy only with practice.
Here are 10 beginner-friendly problems to master recursion.

1. Print Numbers from 1 to N

Python

def printN(n):
    if n == 0:
        return
    printN(n-1)
    print(n)

printN(5)

Java

static void printN(int n){
    if(n == 0) return;
    printN(n-1);
    System.out.println(n);
}

JavaScript

function printN(n){
    if(n === 0) return;
    printN(n-1);
    console.log(n);
}

2. Print Numbers from N to 1

def reverse(n):
    if n == 0:
        return
    print(n)
    reverse(n-1)

static void reverse(int n){
    if(n == 0) return;
    System.out.println(n);
    reverse(n-1);
}

function reverse(n){
    if(n === 0) return;
    console.log(n);
    reverse(n-1);
}

4. Factorial

def fact(n):
    if n == 1:
        return 1
    return n * fact(n-1)

static int fact(int n){
    if(n == 1) return 1;
    return n * fact(n-1);
}

function fact(n){
    if(n === 1) return 1;
    return n * fact(n-1);
}

4. Sum of N Numbers

def sumN(n):
    if n == 0:
        return 0
    return n + sumN(n-1)

static int sumN(int n){
    if(n == 0) return 0;
    return n + sumN(n-1);
}

function sumN(n){
    if(n === 0) return 0;
    return n + sumN(n-1);
}

5. Fibonacci Series

def fib(n):
    if n <= 1:
        return n
    return fib(n-1) + fib(n-2)

static int fib(int n){
    if(n <= 1) return n;
    return fib(n-1) + fib(n-2);
}

function fib(n){
    if(n <= 1) return n;
    return fib(n-1) + fib(n-2);
}

6. Reverse a String

def reverseStr(s):
    if s == "":
        return s
    return reverseStr(s[1:]) + s[0]

static String reverseStr(String s){
    if(s.equals("")) return s;
    return reverseStr(s.substring(1)) + s.charAt(0);
}

function reverseStr(s){
    if(s === "") return s;
    return reverseStr(s.slice(1)) + s[0];
}

7. Count Digits

def countDigits(n):
    if n == 0:
        return 0
    return 1 + countDigits(n//10)

static int countDigits(int n){
    if(n == 0) return 0;
    return 1 + countDigits(n/10);
}

function countDigits(n){
    if(n === 0) return 0;
    return 1 + countDigits(Math.floor(n/10));
}

8. Sum of Digits

def sumDigits(n):
    if n == 0:
        return 0
    return n%10 + sumDigits(n//10)

static int sumDigits(int n){
    if(n == 0) return 0;
    return (n%10) + sumDigits(n/10);
}

function sumDigits(n){
    if(n === 0) return 0;
    return (n%10) + sumDigits(Math.floor(n/10));
}

9. Check Palindrome (String)

def isPalindrome(s):
    if len(s) <= 1:
        return True
    return s[0] == s[-1] and isPalindrome(s[1:-1])

static boolean isPalindrome(String s){
    if(s.length() <= 1) return true;
    return s.charAt(0) == s.charAt(s.length()-1)
        && isPalindrome(s.substring(1, s.length()-1));
}

function isPalindrome(s){
    if(s.length <= 1) return true;
    return s[0] === s[s.length-1] &&
           isPalindrome(s.slice(1, -1));
}

10. Power of a Number (xⁿ)

def power(x, n):
    if n == 0:
        return 1
    return x * power(x, n-1)

static int power(int x, int n){
    if(n == 0) return 1;
    return x * power(x, n-1);
}

function power(x, n){
    if(n === 0) return 1;
    return x * power(x, n-1);
}

Difference Between Compile-Time Exception and Runtime Exception (Java)

PONVEL M — Sat, 04 Apr 2026 04:41:25 +0000

Exception handling is an important concept in Java that helps us handle errors smoothly without crashing the program.

In this blog, we will clearly understand:

What is Compile-Time Exception
What is Runtime Exception
Key Differences with examples

What is an Exception?

An exception is an error that occurs during the execution of a program.

It interrupts the normal flow of the program.

1. Compile-Time Exception (Checked Exception)

Definition

Compile-time exceptions are errors that are checked by the compiler before the program runs.

If not handled, the program will not compile.

Examples

IOException
SQLException
FileNotFoundException

Example Code (Java)

import java.io.*;

class Main {
    public static void main(String[] args) throws IOException {
        FileReader file = new FileReader("test.txt"); // may throw exception
        BufferedReader br = new BufferedReader(file);
        System.out.println(br.readLine());
    }
}

If we don’t use throws or try-catch, compilation will fail.

Key Points

✔ Checked at compile time
✔ Must be handled using try-catch or throws
✔ Safer, because errors are caught early

2. Runtime Exception (Unchecked Exception)

Definition

Runtime exceptions occur during program execution.

Compiler does NOT check these errors.

Examples

ArithmeticException
NullPointerException
ArrayIndexOutOfBoundsException

Example Code (Java)

class Main {
    public static void main(String[] args) {
        int a = 10 / 0; // runtime error
        System.out.println(a);
    }
}

This code compiles successfully, but crashes at runtime.

Key Points

✔ Occurs at runtime
✔ Not checked by compiler
✔ Optional to handle

Difference Table

Feature	Compile-Time Exception	Runtime Exception
Checked by	Compiler	JVM at runtime
Handling	Mandatory	Optional
Occurs	Before execution	During execution
Examples	IOException, SQLException	NullPointerException, ArithmeticException
Program Status	Won’t compile	Compiles but crashes

Real-Life Example

Compile-Time Exception
Like missing documents before an exam → You cannot enter

Runtime Exception
Like bike breakdown during travel → Problem happens suddenly

Advantages of Exception Handling

✔ Prevents program crash
✔ Maintains normal flow
✔ Helps debugging
✔ Improves code quality

Important Note

All compile-time exceptions are checked exceptions
All runtime exceptions are unchecked exceptions

Conclusion

Understanding the difference between compile-time and runtime exceptions is very important for writing robust Java programs.

Compile-time exceptions = handled early
Runtime exceptions = handled during execution

Recursion Programs: Sum of Digits, Reverse Number & Digit Printing (Python, Java, JavaScript)

PONVEL M — Sat, 04 Apr 2026 04:41:10 +0000

Recursion is one of the most important concepts in programming. It means a function calls itself to solve smaller parts of a problem.

In this blog, we will understand recursion with three simple and important problems:

Sum of digits of a number
Reverse a number
Print digits of a number

We will implement all these in Python, Java, and JavaScript.

1. Sum of Digits Using Recursion

Problem

Find the sum of digits of a number.

Example:
Input: 1234
Output: 10

Logic

Take last digit → n % 10
Remove last digit → n / 10
Repeat until number becomes 0

Python Code

def sum_digits(n):
    if n == 0:
        return 0
    return n % 10 + sum_digits(n // 10)

print(sum_digits(1234))

Java Code

class Main {
    static int sumDigits(int n){
        if(n == 0) return 0;
        return n % 10 + sumDigits(n / 10);
    }

    public static void main(String[] args){
        System.out.println(sumDigits(1234));
    }
}

JavaScript Code

function sumDigits(n){
    if(n === 0) return 0;
    return n % 10 + sumDigits(Math.floor(n / 10));
}

console.log(sumDigits(1234));

2. Reverse a Number Using Recursion

Problem

Reverse a number using recursion.

Example:
Input: 1234
Output: 4321

Logic

Take last digit
Build reversed number step by step

Python Code

def reverse(n, rev=0):
    if n == 0:
        return rev
    return reverse(n // 10, rev * 10 + n % 10)

print(reverse(1234))

Java Code

class Main {
    static int reverse(int n, int rev){
        if(n == 0) return rev;
        return reverse(n / 10, rev * 10 + n % 10);
    }

    public static void main(String[] args){
        System.out.println(reverse(1234, 0));
    }
}

JavaScript Code

function reverse(n, rev = 0){
    if(n === 0) return rev;
    return reverse(Math.floor(n / 10), rev * 10 + n % 10);
}

console.log(reverse(1234));

3. Print Digits of a Number

Problem

Print each digit of a number.

Example:
Input: 1234

Output:
1
2
3
4

Logic

First go to the last digit using recursion
Print while returning back

Python Code

def print_digits(n):
    if n == 0:
        return
    print_digits(n // 10)
    print(n % 10)

print_digits(1234)

Java Code

class Main {
    static void printDigits(int n){
        if(n == 0) return;
        printDigits(n / 10);
        System.out.println(n % 10);
    }

    public static void main(String[] args){
        printDigits(1234);
    }
}

JavaScript Code

function printDigits(n){
    if(n === 0) return;
    printDigits(Math.floor(n / 10));
    console.log(n % 10);
}

printDigits(1234);

Conclusion

Recursion is a powerful concept that helps us solve problems in a clean and simple way.

✔ Breaks problems into smaller parts
✔ Makes code more readable
✔ Useful for mathematical and logical problems

Final Thought

If you understand these three problems, you can easily solve many recursion-based questions in interviews.

Practice more to master recursion!

Thank you for reading!

Sum of Digits, Reverse Number & Digit Printing

PONVEL M — Sat, 04 Apr 2026 04:40:55 +0000

Using Recursion and Normal Methods (Python, Java, JavaScript)

In programming, we can solve problems in multiple ways. The two common approaches are:

Normal Method (Loops) – using for / while
Recursion – function calling itself

In this blog, we will solve 3 important problems using both approaches:

Sum of digits
Reverse a number
Print digits of a number

1. Sum of Digits

Example

Input: 1234
Output: 10

Normal Method (Loop)

Python

def sum_digits(n):
    total = 0
    while n > 0:
        total += n % 10
        n = n // 10
    return total

print(sum_digits(1234))

Java

class Main {
    public static void main(String[] args){
        int n = 1234, sum = 0;
        while(n > 0){
            sum += n % 10;
            n = n / 10;
        }
        System.out.println(sum);
    }
}

JavaScript

function sumDigits(n){
    let sum = 0;
    while(n > 0){
        sum += n % 10;
        n = Math.floor(n / 10);
    }
    return sum;
}

console.log(sumDigits(1234));

Recursion Method

Python

def sum_digits(n):
    if n == 0:
        return 0
    return n % 10 + sum_digits(n // 10)

print(sum_digits(1234))

Java

class Main {
    static int sumDigits(int n){
        if(n == 0) return 0;
        return n % 10 + sumDigits(n / 10);
    }

    public static void main(String[] args){
        System.out.println(sumDigits(1234));
    }
}

JavaScript

function sumDigits(n){
    if(n === 0) return 0;
    return n % 10 + sumDigits(Math.floor(n / 10));
}

console.log(sumDigits(1234));

🔁 2. Reverse a Number

👉 Example

Input: 1234
Output: 4321

🔁 Normal Method (Loop)

Python

def reverse(n):
    rev = 0
    while n > 0:
        rev = rev * 10 + n % 10
        n = n // 10
    return rev

print(reverse(1234))

Java

class Main {
    public static void main(String[] args){
        int n = 1234, rev = 0;
        while(n > 0){
            rev = rev * 10 + n % 10;
            n = n / 10;
        }
        System.out.println(rev);
    }
}

JavaScript

function reverse(n){
    let rev = 0;
    while(n > 0){
        rev = rev * 10 + n % 10;
        n = Math.floor(n / 10);
    }
    return rev;
}

console.log(reverse(1234));

🔄 Recursion Method

Python

def reverse(n, rev=0):
    if n == 0:
        return rev
    return reverse(n // 10, rev * 10 + n % 10)

print(reverse(1234))

Java

class Main {
    static int reverse(int n, int rev){
        if(n == 0) return rev;
        return reverse(n / 10, rev * 10 + n % 10);
    }

    public static void main(String[] args){
        System.out.println(reverse(1234, 0));
    }
}

JavaScript

function reverse(n, rev = 0){
    if(n === 0) return rev;
    return reverse(Math.floor(n / 10), rev * 10 + n % 10);
}

console.log(reverse(1234));

🔢 3. Print Digits of a Number

👉 Example

Input: 1234

Output:
1
2
3
4

🔁 Normal Method (Loop)

Python

def print_digits(n):
    digits = []
    while n > 0:
        digits.append(n % 10)
        n = n // 10
    for d in reversed(digits):
        print(d)

print_digits(1234)

Java

class Main {
    public static void main(String[] args){
        int n = 1234;
        int[] arr = new int[10];
        int i = 0;

        while(n > 0){
            arr[i++] = n % 10;
            n = n / 10;
        }

        for(int j = i - 1; j >= 0; j--){
            System.out.println(arr[j]);
        }
    }
}

JavaScript

function printDigits(n){
    let arr = [];
    while(n > 0){
        arr.push(n % 10);
        n = Math.floor(n / 10);
    }
    arr.reverse().forEach(d => console.log(d));
}

printDigits(1234);

🔄 Recursion Method

Python

def print_digits(n):
    if n == 0:
        return
    print_digits(n // 10)
    print(n % 10)

print_digits(1234)

Java

class Main {
    static void printDigits(int n){
        if(n == 0) return;
        printDigits(n / 10);
        System.out.println(n % 10);
    }

    public static void main(String[] args){
        printDigits(1234);
    }
}

JavaScript

function printDigits(n){
    if(n === 0) return;
    printDigits(Math.floor(n / 10));
    console.log(n % 10);
}

printDigits(1234);

🎯 Conclusion

Both approaches are important:

🔁 Loop Method

Easy to understand
Faster execution
Uses less memory

🔄 Recursio

Advantages of Exception Handling in Java

PONVEL M — Tue, 31 Mar 2026 04:01:06 +0000

When writing programs, errors are unavoidable. A user might enter wrong input, a file may not exist, or a network may fail.

Instead of crashing the program, we use Exception Handling to manage these errors smoothly.

What is Exception Handling?

Exception Handling is a mechanism that allows a program to handle runtime errors and continue execution without crashing.

In Java, it is mainly done using:

try
catch
finally

Why Do We Need Exception Handling?

Without exception handling:

Program will stop immediately
User experience becomes bad

With exception handling:

Errors are handled properly
Program continues running

Advantages of Exception Handling

Prevents Program Crash

The biggest advantage!

If an error occurs, the program will not terminate suddenly.

Example:

try {
    int a = 10 / 0;
} catch (Exception e) {
    System.out.println("Error handled!");
}

Instead of crashing, it prints:

Error handled!

Maintains Normal Flow of Program

Even after an error, the remaining code will execute.

try {
    int a = 10 / 0;
} catch (Exception e) {
    System.out.println("Handled");
}

System.out.println("Program continues...");

Output:

Handled
Program continues...

Improves User Experience

Users don’t see technical errors like:

NullPointerException
ArrayIndexOutOfBoundsException

Instead, you can show friendly messages:

catch (Exception e) {
    System.out.println("Something went wrong. Please try again!");
}

Helps in Debugging

Exception objects provide useful information:

Error type
Line number
Stack trace

catch (Exception e) {
    e.printStackTrace();
}

Helps developers find and fix bugs faster.

Separates Error Handling Code

You can separate normal logic and error handling logic.

Clean and readable code!

try {
    // main logic
} catch (Exception e) {
    // error handling
}

Allows Custom Error Messages

You can create your own exceptions and messages.

throw new Exception("Invalid Input!");

Makes your application more meaningful.

Ensures Resource Management (`finally` block)

The finally block always executes, whether exception occurs or not.

finally {
    System.out.println("Closing resources...");
}

Used for:

Closing files
Closing database connections

Handles Different Types of Errors

You can use multiple catch blocks:

try {
    int arr[] = new int[5];
    arr[10] = 50;
} catch (ArithmeticException e) {
    System.out.println("Math Error");
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("Array Error");
}

Output:

Array Error

Real-Life Example

Imagine a banking app

Without exception handling:

App crashes → user loses trust

With exception handling:

Shows "Transaction Failed, Try Again"
App continues working

Final Thoughts

Exception handling is not just about catching errors.

It is about:

Writing robust programs
Improving user experience
Making code clean and maintainable

Conclusion

✔ Prevents crashes
✔ Maintains program flow
✔ Improves user experience
✔ Helps debugging
✔ Makes code cleaner

Understanding Recursion with Simple Examples (Java, Python & JavaScript)

PONVEL M — Mon, 30 Mar 2026 07:16:23 +0000

Recursion is one of the most important concepts in programming. Once you understand it clearly, many complex problems become much easier to solve.

In this blog, we will learn recursion in a simple and practical way with examples in Python, Java, and JavaScript.

What is Recursion?

Recursion is a technique where a function calls itself to solve a problem.

Instead of using loops, recursion breaks a problem into smaller subproblems and solves them step by step.

Two Important Parts of Recursion

Every recursive function must have:

1. Base Case (Stopping Condition)

This is the condition where the function stops calling itself.

Without this → program will run forever (infinite recursion )

2. Recursive Call

The function calls itself with a smaller or simpler input.

Example 1: Print Numbers from 1 to 5

Flowchart:

Python

def display(num):
    if num > 5:
        return

    print(num)
    display(num + 1)

display(1)

Java

class Main {
    static void display(int num) {
        if (num > 5) return;

        System.out.println(num);
        display(num + 1);
    }

    public static void main(String[] args) {
        display(1);
    }
}

JavaScript

function display(num) {
    if (num > 5) return;

    console.log(num);
    display(num + 1);
}

display(1);

Output:

1 2 3 4 5

Example 2: Print Odd Numbers (1 to 9)

Flowchart:

Python

def display(num):
    if num > 9:
        return

    print(num)
    display(num + 2)

display(1)

Output:

1 3 5 7 9

Example 3: Print Multiples of 5

Python

def display(num):
    if num > 25:
        return

    print(num)
    display(num + 5)

display(5)

Output:

5 10 15 20 25

Example 4: Factorial using Recursion

Factorial means:

5! = 5 × 4 × 3 × 2 × 1

Python

def fact(num, result=1):
    if num > 5:
        return result

    result *= num
    return fact(num + 1, result)

print("Factorial:", fact(1))

Java

class Main {
    static int fact(int num, int result) {
        if (num > 5) return result;

        result *= num;
        return fact(num + 1, result);
    }

    public static void main(String[] args) {
        System.out.println("Factorial: " + fact(1, 1));
    }
}

Example 5: Sum of First N Numbers

Flowchart:

Python

def sum_n(num, total=0):
    if num > 5:
        return total

    total += num
    return sum_n(num + 1, total)

print("Sum:", sum_n(1))

Output:

Sum: 15

How Recursion Works (Simple Idea)

Example:

display(1)

It works like:

display(1)
display(2)
display(3)
display(4)
display(5)
stop

Each function call is stored in memory until the base condition is met.

Advantages of Recursion

✔ Makes code shorter and cleaner
✔ Useful for problems like trees, graphs, factorial
✔ Easier to understand logically

Disadvantages of Recursion

Uses more memory (stack)
Can be slower than loops
Risk of infinite recursion

Final Thoughts

Recursion may feel confusing at first, but once you understand:

Base case + Recursive call = Everything

you can solve many complex problems easily.

Practice Ideas

Try solving:

Reverse a number using recursion
Fibonacci series
Sum of digits
Palindrome check

Tip: Start small, trace step-by-step, and recursion will become easy!

Happy Coding!

Exception Handling in Java (Simple Explanation)

PONVEL M — Sun, 29 Mar 2026 17:17:43 +0000

Introduction

While writing programs, errors can happen at any time. These errors can crash the program and stop it suddenly. In Java, we use Exception Handling to handle these errors and keep the program running smoothly.

What is an Exception?

An exception is an unwanted event that occurs during program execution and disrupts the normal flow of the program.

Example:

Dividing a number by zero
Accessing invalid array index
Trying to open a file that doesn’t exist

Why Exception Handling is Important?

Prevents program crash
Maintains normal program flow
Improves user experience
Helps in debugging errors

Types of Exceptions

1. Checked Exception

Checked at compile time
Example: File handling errors

2. Unchecked Exception

Occurs at runtime
Example: ArithmeticException, NullPointerException

Basic Keywords in Exception Handling

1. try

Used to write code that may cause an exception.

2. catch

Used to handle the exception.

3. finally

Always executes (whether exception occurs or not).

4. throw

Used to manually throw an exception.

5. throws

Used to declare exceptions in method signature.

Simple Example

public class Example {
    public static void main(String[] args) {
        try {
            int a = 10;
            int b = 0;
            int result = a / b; // error
            System.out.println(result);
        } catch (ArithmeticException e) {
            System.out.println("Cannot divide by zero!");
        } finally {
            System.out.println("Program finished.");
        }
    }
}

How it Works

try block contains risky code
If error occurs → catch block runs
finally block runs always

Common Exceptions in Java

ArithmeticException
NullPointerException
ArrayIndexOutOfBoundsException
NumberFormatException

Advantages of Exception Handling

Keeps program stable
Handles runtime errors
Separates error-handling code from normal code
Makes code readable and maintainable

Conclusion

Exception Handling in Java is a powerful feature that helps developers manage errors effectively. Instead of stopping the program, it allows us to handle problems gracefully and continue execution.

My Learning Experience

While learning exception handling, I understood how important it is to manage errors properly. Using try and catch, I can control program crashes and make applications more reliable. It made my coding more professional and clean.

Mastering Java String Methods – Real-Time Scenario Practice

PONVEL M — Fri, 27 Mar 2026 17:27:40 +0000

Introduction

Strings are one of the most commonly used data types in Java. In real-world applications like login systems, data processing, and validation, we frequently work with strings.

Today, I practiced Java String methods using real-time scenarios, which helped me understand how they are used in actual applications.

1. Handling Extra Spaces (trim)

When a user enters a password with extra spaces, login may fail.

String password = "Admin123 ";
password = password.trim();

trim() removes unwanted spaces from start and end.

2. Case-Insensitive Comparison

User input and database values may differ in case.

if(ui.equalsIgnoreCase(db)) {
    System.out.println("Match");
}

equalsIgnoreCase() ignores case differences.

3. Difference Between == and equals()

String s1 = "Java";
String s2 = new String("Java");

System.out.println(s1 == s2);      // false
System.out.println(s1.equals(s2)); // true

== checks reference
equals() checks value

4. Email Validation using contains()

if(email.contains("@") && email.contains(".")) {
    System.out.println("Valid Email");
}

5. Converting String to Integer

int num = Integer.parseInt("1234");

6. Removing Spaces

String str = "  Welcome to Java  ";
str = str.trim();

7. Counting Word Occurrences

String str = "Java is easy. Java is powerful.";
int count = 0, index = 0;

while((index = str.indexOf("Java", index)) != -1) {
    count++;
    index += 4;
}

8. Reversing a String

String rev = "";
for(int i = str.length()-1; i>=0; i--) {
    rev += str.charAt(i);
}

9. Palindrome Check

if(str.equals(rev)) {
    System.out.println("Palindrome");
}

10. Removing Duplicate Characters

if(result.indexOf(ch) == -1) {
    result += ch;
}

11. Extracting Data using substring()

String result = log.substring(log.indexOf(":") + 2);

12. Splitting CSV Data

String[] arr = data.split(",");

13. Replacing Words

str.replace("Java", "Spring Boot");

14. Mobile Number Validation

mobile.matches("\\d{10}");

15. Splitting Using Custom Delimiter

str.split("#");

Key Methods Learned

trim()
equalsIgnoreCase()
contains()
indexOf()
substring()
split()
replace()
matches()

My Learning Experience

Today’s practice was very useful because I understood how Java String methods are used in real-time scenarios rather than just theory.

I learned how to:

Handle user input errors (like extra spaces and case issues)
Validate data such as email and mobile numbers
Process and manipulate strings efficiently
Extract and transform data using methods like substring() and split()

The most interesting part for me was removing duplicate characters and counting word occurrences, because it improved my logical thinking.

Overall, this exercise helped me gain confidence in using String methods for real-world applications and interviews. I now feel more comfortable solving string-based problems and explaining them clearly.

Conclusion

Java String methods are powerful tools for handling real-time data. Practicing these scenarios improves both coding skills and problem-solving ability, which are essential for interviews and real-world development.

Thank you for reading!

Understanding String and String Methods in Java

PONVEL M — Fri, 27 Mar 2026 17:21:42 +0000

Introduction

In Java, String is one of the most commonly used classes. It represents a sequence of characters and is widely used for handling text such as names, messages, and data processing.

Strings in Java are immutable, which means once a String object is created, it cannot be changed.

What is a String in Java?

A String is an object that represents a sequence of characters.

Example:

String name = "Ponvel";

Here, "Ponvel" is stored as a String object.

Important Concept: Immutability

Strings are immutable in Java.

Example:

String str = "Hello";
str.concat(" World");

System.out.println(str);

Output:

Hello

Even though we tried to add " World", the original string is not changed.

Correct Way:

str = str.concat(" World");

String Creation Methods

1. Using Literal

String s1 = "Java";

2. Using `new` Keyword

String s2 = new String("Java");

Difference: Literal vs New Keyword

Literal	new Keyword
Stored in String pool	Stored in heap
Memory efficient	More memory used
Faster	Slightly slower

Common String Methods (VERY IMPORTANT)

1. length()

Returns the length of the string.

String str = "Java";
System.out.println(str.length());

Output: 4

2. toUpperCase() & toLowerCase()

String str = "java";

System.out.println(str.toUpperCase()); // JAVA
System.out.println(str.toLowerCase()); // java

3. charAt()

Returns character at specific index.

String str = "Java";
System.out.println(str.charAt(1));

Output: a

4. indexOf()

Finds position of a character.

String str = "Java";
System.out.println(str.indexOf('a'));

Output: 1

5. substring()

Extracts part of string.

String str = "Java Programming";

System.out.println(str.substring(5));
System.out.println(str.substring(0, 4));

Output:

Programming
Java

🔹 6. equals() vs == (VERY IMPORTANT )

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

System.out.println(a == b);       // true
System.out.println(a == c);       // false
System.out.println(a.equals(c));  // true

Difference: equals() vs ==

equals()	==
Compares values	Compares memory
Recommended	Not safe

7. contains()

Checks if string contains value.

String str = "Java Programming";
System.out.println(str.contains("Java"));

Output: true

8. replace()

Replaces characters.

String str = "Java";
System.out.println(str.replace('a', 'o'));

Output: Jovo

9. trim()

Removes spaces.

String str = "  Java  ";
System.out.println(str.trim());

10. split()

Splits string into array.

String str = "Java,Python,C++";

String[] arr = str.split(",");

for(String s : arr) {
    System.out.println(s);
}

StringBuilder vs StringBuffer vs String

Difference Table:

Feature	String	StringBuilder	StringBuffer
Mutable	No	Yes	Yes
Thread Safe	No	No	Yes
Performance	Slow	Fast	Medium

When to Use What?

Use String → When data is constant
Use StringBuilder → Fast operations (single thread)
Use StringBuffer → Multi-threaded applications

Interview Important Questions

Why String is Immutable?

Security
Performance (String pool)
Thread safety

What is String Pool?

Special memory area to store unique string literals

What is difference between StringBuilder and StringBuffer?

Answer:

Both are mutable
StringBuffer is thread-safe
StringBuilder is faster

Conclusion

Strings are a fundamental part of Java programming. Understanding how they work, especially concepts like immutability, string pool, and string methods, is essential for both coding and interviews.

Mastering String methods will help you solve many real-world problems such as:

Data processing
Validation
Parsing

LCM, Sum of numbers, and Factorial

PONVEL M — Fri, 27 Mar 2026 17:14:29 +0000

1. LCM (Least Common Multiple)

Flow chart:

In Python:

In Java:

In JavaScript:

2. Find the sum of n numbers :

Flow chart:

In Python

Output:

In Java:

In JavaScript

3.Find the factorial of given number:

Flow chart:

In Python

In Java:

In JavaScript

Understanding Prime Numbers Using Loop in Programming

PONVEL M — Wed, 25 Mar 2026 16:48:15 +0000

Introduction

Prime numbers are one of the most important concepts in mathematics and programming. They are widely used in algorithms, cryptography, and problem-solving. In this blog, we will learn what a prime number is and how to write a program using loops to check whether a number is prime.

What is a Prime Number?

A prime number is a number that is divisible only by:

1
Itself

Examples:

2, 3, 5, 7, 11 → Prime numbers

Non-Prime Numbers:

4 (divisible by 2)
6 (divisible by 2 and 3)

Logic Behind Prime Number Program

To check if a number is prime:

Take a number as input
Check divisibility from 2 to n-1
If any number divides it → Not Prime
If no number divides it → Prime

Java Program Using Loop

import java.util.Scanner;

public class PrimeNumber {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.print("Enter a number: ");
        int num = sc.nextInt();
        int count = 0;

        for(int i = 1; i <= num; i++) {
            if(num % i == 0) {
                count++;
            }
        }

        if(count == 2) {
            System.out.println("Prime Number");
        } else {
            System.out.println("Not a Prime Number");
        }
    }
}

Optimized Approach (Better Logic)

Instead of checking till n, we can check till √n (square root of n) to improve performance.

public class PrimeOptimized {
    public static void main(String[] args) {
        int num = 29;
        boolean isPrime = true;

        if(num <= 1) {
            isPrime = false;
        } else {
            for(int i = 2; i <= Math.sqrt(num); i++) {
                if(num % i == 0) {
                    isPrime = false;
                    break;
                }
            }
        }

        if(isPrime) {
            System.out.println("Prime Number");
        } else {
            System.out.println("Not Prime");
        }
    }
}

Why Optimization Matters?

Reduces number of iterations
Improves performance for large numbers
Used in real-world applications

Time Complexity

Basic approach → O(n)
Optimized approach → O(√n)

Conclusion

Prime numbers are fundamental in programming and problem-solving. By using loops, we can easily determine whether a number is prime. Optimizing the solution using square root logic makes the program faster and more efficient.

Tip

Always try to optimize your logic when working with loops to improve performance in real-world applications.

Why Java is Multi-Threaded and JavaScript is Single-Threaded

PONVEL M — Fri, 06 Mar 2026 02:12:42 +0000

One of the most common questions beginners and interviewers ask is:

Why is Java multi-threaded while JavaScript is not?

Even though both languages look similar in syntax, their design goals and execution environments are completely different.
Let’s understand this in simple terms.

🔹 What Does Multi-Threaded Mean?

A multi-threaded program can:

Execute multiple tasks at the same time
Use multiple CPU cores
Improve performance for heavy workloads

🔹 Why Java is Multi-Threaded

Java was designed for:

Enterprise applications
Backend servers
Banking and financial systems
Large-scale systems

These applications need to:
✔ Handle many users simultaneously
✔ Process multiple tasks in parallel
✔ Use CPU efficiently

That’s why Java supports true multi-threading.

Example in Java:

`class MyThread extends Thread {
public void run() {
System.out.println("Thread running");
}
}

public class Main {
public static void main(String[] args) {
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
t1.start();
t2.start();
}
}`

👉 Here, both threads can run at the same time using different CPU cores.

🔹 Why JavaScript is NOT Multi-Threaded

JavaScript was created for:

Web browsers
Handling user interactions
Updating the UI (DOM)

In browsers:

One thread handles UI rendering
One thread handles JavaScript execution

If JavaScript were multi-threaded:
❌ Two threads might update the DOM at the same time
❌ UI could break or crash
❌ Race conditions would occur

👉 To protect the UI, JavaScript was designed as single-threaded.

🔹 But JavaScript is NOT Slow 😮

Even though JavaScript has only one main thread, it is non-blocking.

It uses:

Web APIs
Callback Queue
Event Loop

Example:

`console.log("Start");

setTimeout(() => {
console.log("Async Task");
}, 1000);

console.log("End");

Output:
Start
End
Async Task`

👉 The async task runs without blocking the main thread.

🔹 How JavaScript Handles Concurrency

JavaScript uses asynchronous programming instead of threads:

Event Loop manages execution
Long tasks run in the background
Main thread stays responsive

🔹 Can JavaScript Ever Use Multiple Threads?

Yes, but indirectly:

Web Workers (Browser)
Worker Threads (Node.js)

⚠️ These workers:

Cannot access DOM directly
Communicate via messages

JavaScript core still remains single-threaded.

🔹 Simple Real-World Analogy

Java → Multiple workers doing tasks in parallel
JavaScript → One main worker with helpers working in background

🔹 Conclusion

Java is multi-threaded because it is built for high-performance and parallel execution,
while JavaScript is single-threaded to ensure UI safety and simplicity, using the event loop for asynchronous behavior.