DEV Community: Abishek

String Problems

Abishek — Tue, 21 Apr 2026 08:44:19 +0000

Password generator

import random

Upper ="ABCDEFGHEJKLMNPOQRSTUVWXYZ"
lower = "abcdefghejklmnpoqrstuvwxyz"
number = "0123456789"
special = r"""!@#$%^&*()_+-=[]|\:;"'<>,.?/"""
result=""

i=0
while i<3:
    result+=Upper[random.randint(0,25)]
    result+=lower[random.randint(0,25)]
    result+=number[random.randint(0,9)]
    result+=special[random.randint(0,27)]


    i+=1

print(result)

Output
Cv7?Rq2'Fk8|

Password Validator program

password = "Abc@1234"

uppercase = 0
uppercaseFlag = False

lowercase=0
lowercaseFlag= False


digit=0
digitFlag =False

special=0
specialFlag=False

space=0
spaceFlag = True




if len(password)<8:
    print("Minimum length")
    exit()

i=0
while i<len(password):

    if 'A' <= password[i] <= 'Z':
        uppercaseFlag=True

    if 'a' <= password[i] <= 'z':
        lowercaseFlag=True

    if '0' <= password[i] <= '9':
        digitFlag = True

    if password[i] == ' ':
        spaceFlag=False

    if 'A' <= password[i] <= 'Z' or 'a' <= password[i] <= 'z' or '0' <= password[i] <= '9' or password[i] == ' ':
        pass
    else:
        specialFlag=True

    i+=1

if uppercaseFlag and lowercaseFlag and digitFlag and specialFlag and spaceFlag :
    print("Strong Validation")
else:
    print("check the password")

Output
Strong Validation

Count Of Letter,Special Character and Number

sen ="Life is Good@ dream123"
letter=0
number=0
special=0

i=0
while i<len(sen):
    if (sen[i]>='A' and sen[i]<='Z')or(sen[i]>='a' and sen[i]<='z'):  
      letter+=1
    elif sen[i]>='0' and sen[i]<='9':
       number+=1
    elif sen[i] == ' ':  # ' ' is a whitespace character
       pass              
    else:
       special+=1

    i+=1


print("count of letter :",letter)
print("count of numbers :",number)
print("count of special :",special)

Output
count of letter : 15 count of numbers : 3 count of special : 1

Upper to Lower

sen = "LIFE IS GOOD"

i=0
while i<len(sen):
   if sen[i]>='A' and sen[i]<='Z':  #this convert Upper to lower
      print(chr(ord(sen[i]) + 32), end="")
   elif sen[i]>='a' and sen[i]<='z':
      print(chr(ord(sen[i]) - 32), end="")  #this convert smaller to upper
   elif sen[i] == ' ':
      print(' ',end="")
   i+=1

print('')

Output
life is good

Every ArrayList Method You Need to Know (With Examples)

Abishek — Mon, 20 Apr 2026 04:29:23 +0000

Before anything, this is the import you need:

import java.util.ArrayList;

And this is how you create one:

ArrayList<String> list = new ArrayList<>();

Simple. Now let's get into the methods.

The Methods

add(element)

Adds an element to the end of the list.

list.add("Apple");

add(index, element)

Adds an element at a specific position. Shifts everything else to the right.

list.add(1, "Banana");

get(index)

Returns the element at that index.

String fruit = list.get(0); // Apple

set(index, element)

Replaces the element at that index with a new one.

list.set(0, "Mango"); // Apple becomes Mango

remove(index)

Removes the element at that index.

list.remove(1); // removes Banana

remove(object)

Removes the first occurrence of that specific value.

list.remove("Mango");

Heads up — if your list is ArrayList<Integer>, Java gets confused between remove(index) and remove(object). Wrap the value: list.remove(Integer.valueOf(5)).

size()

Returns how many elements are in the list.

int count = list.size();

isEmpty()

Returns true if the list has no elements.

boolean empty = list.isEmpty();

contains(object)

Returns true if the list has that value.

boolean has = list.contains("Apple");

indexOf(object)

Returns the index of the first occurrence. Returns -1 if not found.

int pos = list.indexOf("Apple");

lastIndexOf(object)

Returns the index of the last occurrence. Useful when duplicates exist.

int lastPos = list.lastIndexOf("Apple");

clear()

Removes everything. List becomes empty.

list.clear();

addAll(collection)

Adds all elements from another collection into this list.

ArrayList<String> more = new ArrayList<>();
more.add("Grapes");
more.add("Papaya");
list.addAll(more);

addAll(index, collection)

Same as above but inserts at a specific position.

list.addAll(1, more);

removeAll(collection)

Removes all elements that exist in the given collection.

list.removeAll(more);

retainAll(collection)

Keeps only the elements that exist in the given collection. Removes everything else.

list.retainAll(more);

containsAll(collection)

Returns true if this list contains every element in the given collection.

boolean hasAll = list.containsAll(more);

toArray()

Converts the ArrayList into a plain array.

Object[] arr = list.toArray();

subList(fromIndex, toIndex)

Returns a portion of the list. fromIndex is included, toIndex is not.

List<String> part = list.subList(0, 2); // index 0 and 1 only

Collections.sort(list)

Not an ArrayList method exactly, but used all the time. Sorts the list in ascending order.

import java.util.Collections;
Collections.sort(list);

Collections.reverse(list)

Reverses the order of elements.

Collections.reverse(list);

Quick Reference Table

Method	What it does
`add(element)`	Adds to end
`add(index, element)`	Inserts at position
`get(index)`	Returns element at index
`set(index, element)`	Replaces element at index
`remove(index)`	Removes by position
`remove(object)`	Removes by value
`size()`	Returns total count
`isEmpty()`	Checks if list is empty
`contains(object)`	Checks if value exists
`indexOf(object)`	First position of value
`lastIndexOf(object)`	Last position of value
`clear()`	Removes everything
`addAll(collection)`	Merges another list
`addAll(index, collection)`	Merges at a position
`removeAll(collection)`	Removes matching elements
`retainAll(collection)`	Keeps only matching elements
`containsAll(collection)`	Checks if all exist
`toArray()`	Converts to plain array
`subList(from, to)`	Returns a slice of the list
`Collections.sort()`	Sorts ascending
`Collections.reverse()`	Reverses the list

Let's learn about collection and How to print Objects

Abishek — Sat, 18 Apr 2026 03:14:05 +0000

Arrays

My first question is can we add, remove value in array ? NO, we can add or remove a value from a array, we cannot manipulate because array is fixed size so we need to create another array to add or remove a value

    void pushValueArray(){
        int [] arr = {1,2,3,4};
        int [] arrCopy = new int[5];

        int i = 0 ;
        while(i<arr.length){
            arrCopy[i]=arr[i];
            i++;
        }
        arrCopy[arr.length]=5;
        System.out.println(Arrays.toString(arrCopy));
    }

Can we replace a value in array? YES,array is fixed but we can change the values in that array by accessing their index like this

    void replaceValueInArray(){
        int[] arr = {10, 20, 30};
        arr[2]= 40;
        System.out.println(Arrays.toString(arr));
    }

Can we print a Object? this is a tricky one ,

String is object
array is object
Object(new) is object

1. String is object

we can print String using System.out.println()

String str = "helllo";
System.out.println(str);

String is object so the referece address of the String should print but the Output will be helllo,why ?

Because String calls toString() method automatically,

public String toString(String x) {
    return this;
}

this happens in the behind the screens

2. array is object

we can print a Array? Yes we can!

int [] arr = {1,2,3,4};
System.out.println(arr); // ref address
System.out.println(Arrays.toString(arr)); // o/p : [1,2,3,4]

Is the output is array or string? The output is String but in array Format because the array is object we cant print directly so we use Arrays.toString()

3. Object(new) is object(TBD)

can we print Object? Yes but we need to override it

class ClassName {
    int x = 10;

    @Override //TBD
    public String toString() {
        return "x = " + x;
    }

public static void main(String[] args){
ClassName obj = new ClassName();
System.out.println(obj); // o/p : x = 10
    }
}

What is auto boxing and auto unboxing ?

*1. Auto Boxing *
Autoboxing = converting primitive → object automatically

int x = 10;
Integer obj = x; // autoboxing

2. Auto Unboxing
Unboxing = converting object → primitive automatically

Integer obj = 10;
int x = obj; // unboxing

FileReader ,BufferedReader ,FileWriter,BufferedWriter

Abishek — Wed, 08 Apr 2026 05:11:22 +0000

Class Hierarchy (With Meaning, Not Just Structure)

Reader (abstract)
   ↓
FileReader        → connects to file (source)
BufferedReader    → optimizes reading

Writer (abstract)
   ↓
FileWriter        → connects to file (destination)
BufferedWriter    → optimizes writing

Key Insight

FileReader / FileWriter → act as a bridge between Java and the file system
BufferedReader / BufferedWriter → act as a performance layer on top of that bridge

This separation is intentional and follows good design principles.

FileReader — What Actually Happens Internally

FileReader fr = new FileReader("file.txt");
int ch = fr.read();

Internal Flow

JVM requests data from the OS
OS reads data from disk into a kernel buffer
JVM copies that data into a user-space buffer
read() returns one character

The Problem

Even if the OS reads data in chunks internally, your code consumes it one character at a time.

So this loop:

while ((ch = fr.read()) != -1)

results in:

repeated method calls
continuous boundary checks
inefficient data consumption

Bottleneck:
Frequent method calls combined with poor utilization of already-fetched data.

BufferedReader — What Changes?

BufferedReader br = new BufferedReader(new FileReader("file.txt"));

Internal Behavior

Allocates an internal char[] buffer (typically ~8KB)
Calls FileReader.read(char[]) to fetch large chunks at once
Stores data in memory
Your code reads from this buffer instead of hitting the disk repeatedly

Deep Dive: `readLine()`

String line = br.readLine();

This is not a simple operation.

Internally:

Scans the buffer for \n (newline character)
Constructs a String from characters up to that point
If newline is not found:

refills the buffer
continues scanning
1. Returns the completed string

Key Shift

Instead of:

multiple disk interactions

You now have:

one disk read
many in-memory operations

Why BufferedReader Is Faster (Actual Reasons)

Not just “it uses a buffer.”

1. Reduced System Calls

Each disk access involves a kernel transition, which is expensive.
BufferedReader minimizes how often this happens.

2. Lower CPU Overhead

Fewer method calls compared to character-by-character reading.

3. Better Memory Access Patterns

Sequential access to arrays improves CPU cache utilization.

FileWriter — Internal Behavior

FileWriter fw = new FileWriter("file.txt");
fw.write("Hello");

What Happens

Data moves from Java → JVM buffer
JVM passes it to the OS
OS writes it to disk

Problem

Each write() can trigger disk interaction depending on buffering behavior.

Impact:
Frequent writes lead to frequent disk operations.

BufferedWriter — What Actually Improves?

BufferedWriter bw = new BufferedWriter(new FileWriter("file.txt"));

Internal Flow

Data is written into an internal buffer
It does not immediately go to disk
When buffer fills or flush()/close() is called:
- entire buffer is written in a single operation

Deep Detail: `flush()`

bw.flush();

This forces:

JVM buffer → OS buffer → Disk

Without calling flush():

data may remain in memory
file output may appear incomplete

Composition Design (Decorator Pattern)

BufferedReader br = new BufferedReader(new FileReader("file.txt"));

This is an example of the Decorator Pattern.

FileReader → provides raw data access
BufferedReader → enhances behavior

Why This Design Exists

Separation of concerns
Reusable components
Flexible layering

You can mix and match behaviors without rewriting logic.

Why Not Just Use FileReader Everywhere?

Because it does not scale.

Problem	Impact
Frequent reads	High CPU and system call overhead
No batching	Poor throughput
No abstraction	Manual parsing required

Memory vs Performance Tradeoff

Buffered classes:

Use additional memory (internal buffers)
Significantly reduce disk I/O

This is a classic systems tradeoff:

Spend a small amount of RAM to gain large performance improvements.

Try-With-Resources — What It Actually Solves

try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
}

What It Guarantees

close() is always called
For writers, this ensures flush() happens
OS-level file handles are released

File Handling

Abishek — Mon, 06 Apr 2026 05:59:04 +0000

In Java, file handling means working with files like creating them, reading data, writing data or deleting them. It helps a program save and use information permanently on the computer.
Java provides several methods for file handling like creating, reading, updating and deleting the files.

Java File Class

In Java, the File class is used to reprsent the path of a file or a directory in file system. This class is used for creation of files and directories, file searching, file deletion, etc. We need to import java.io.package before using the File class.

How to Create a file Object

To work with a file in Java, you first create a File object by passing the file name or path as a string. The File object represents the actual file/directory on the disk.

import java.io.File;    // Import the File class
File myObj = new File("filename.txt");    // Specify the filename

File Class Constructors(TBD)

Following is the list of constructors to create a File object.

-> File(File parent, String child)

This constructor creates a new File instance from a parent abstract pathname and a child pathname string.

-> File(String pathname)

This constructor creates a new File instance by converting the given pathname string into an abstract pathname.

-> File(String parent, String child)

This constructor creates a new File instance from a parent pathname string and a child pathname string.

-> File(URI uri)

This constructor creates a new File instance by converting the given file: URI into an abstract pathname.

File Class Methods

Once you have File object in hand, then there is a list of helper methods which can be used to manipulate the files.

-> getName()

Returns the name of the file or directory.

-> getAbsolutePath()

Returns the absolute pathname of file.

-> canRead()

Tests whether the application can read the file denoted by this abstract pathname. Returns true if and only if the file specified by this abstract pathname exists and can be read by the application; false otherwise.

->canWrite()

Tests whether the application can modify to the file denoted by this abstract pathname. Returns true if and only if the file system actually contains a file denoted by this abstract pathname and the application is allowed to write to the file; false otherwise.

->exists()

Tests whether the file or directory denoted by this abstract pathname exists. Returns true if and only if the file or directory denoted by this abstract pathname exists; false otherwise.

-> isDirectory()

Tests whether the file denoted by this abstract pathname is a directory. Returns true if and only if the file denoted by this abstract pathname exists and is a directory; false otherwise.

->isFile()

Tests whether the file denoted by this abstract pathname is a normal file. A file is normal if it is not a directory and, in addition, satisfies other system-dependent criteria. Any non-directory file created by a Java application is guaranteed to be a normal file. Returns true if and only if the file denoted by this abstract pathname exists and is a normal file; false otherwise.

-> length()

Returns the size of the file in bytes.

-> createNewFile()

Atomically creates a new, empty file. Returns true if the named file does not exist and was successfully created; false if the named file already exists.

-> delete()

Deletes the file or directory denoted by this abstract pathname. If this pathname denotes a directory, then the directory must be empty in order to be deleted. Returns true if and only if the file or directory is successfully deleted; false otherwise.

-> list()

Returns an array of strings naming the files and directories in the directory.

-> mkdir()

Creates the directory. Returns true if and only if the directory was created; false otherwise.

reference: oracle,tutorialspoint

Neon,Strong,Perfect Number coding

Abishek — Fri, 03 Apr 2026 17:27:06 +0000

Neon Number

What is Neon number ?
9 => 81
9 <= 8+1

neon number : There are only three neon numbers in the range of 0 to 100,000: 0, 1, and 9.

Python

no = int(input("enter a neon number to check : "))
sqr= no*no

def neon(sqr):
   SumOfNum=0
   while sqr>0:
      SumOfNum = sqr%10 + SumOfNum
      sqr=sqr//10

   return SumOfNum

if no==neon(sqr):
   print("its a neon")
else :
   print("not neon")

java

import java.util.Scanner;

public class NeonNumber {

    public static int neon(int sqr) {
        int sumOfNum = 0;

        while (sqr > 0) {
            sumOfNum = sqr % 10 + sumOfNum;
            sqr = sqr / 10;
        }

        return sumOfNum;
    }

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

        System.out.print("enter a neon number to check : ");
        int no = scanner.nextInt();

        int sqr = no * no;

        if (no == neon(sqr)) {
            System.out.println("its a neon");
        } else {
            System.out.println("not neon");
        }

        scanner.close();
    }
}

Strong number

145 <----------------
5! --->| 120         |
4! --->|  24         |
1! --->|   1 +       |
     ---------       |
         145 --------
     ---------

-> Strong Numbers are the numbers whose sum of factorial of digits is equal to the original number. Given a number, check if it is a Strong Number or not.

python

 def fact(num):
    fact = 1 
    while num>0:
      fact = fact * num
      num-=1
    return fact


given  = int(input("enter a Strong Number to Check : "))
copyOgGiven = given
result = 0 
while given>0:
   result =  result + fact(given%10)
   given = given //10

#print (result)
if copyOgGiven == result:
   print ("its strong number")
else:
   print("not strong number")

java

import java.util.Scanner;

public class StrongNumber {

    public static int fact(int num) {
        int fact = 1;

        while (num > 0) {
            fact = fact * num;
            num--;
        }

        return fact;
    }

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

        System.out.print("enter a Strong Number to Check : ");
        int given = scanner.nextInt();

        int copyOgGiven = given;
        int result = 0;

        while (given > 0) {
            result = result + fact(given % 10);
            given = given / 10;
        }

        if (copyOgGiven == result) {
            System.out.println("its strong number");
        } else {
            System.out.println("not strong number");
        }

        scanner.close();
    }
}

Perfect Number

->Perfect numbers are positive integers that equal the sum of their proper divisors, excluding the number itself. For example, 6 is a perfect number because its proper divisors (1, 2, and 3) add up to 6

6 - Divisors are 1,2,3
1+2+3 = 6

Python

givenNum = int(input("enter a perfect number to check : "))
start = 1
result =  0
while (start<=givenNum//2):
   if givenNum%start == 0 :
      result+=start

   start+=1

if (result == givenNum):
   print("it's perfect number")
else:
   print("not a perfect number")

java

import java.util.Scanner;

public class PerfectNumber {

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

        System.out.print("enter a perfect number to check : ");
        int givenNum = scanner.nextInt();

        int start = 1;
        int result = 0;

        while (start <= givenNum / 2) {
            if (givenNum % start == 0) {
                result += start;
            }
            start++;
        }

        if (result == givenNum) {
            System.out.println("it's perfect number");
        } else {
            System.out.println("not a perfect number");
        }

        scanner.close();
    }
}

Exception Handling

Abishek — Thu, 02 Apr 2026 02:30:22 +0000

What is an Exception?

The Oracle docs define it cleanly —

"An exception is an event, which occurs during the execution of a program, that disrupts the normal flow of the program's instructions."
— Oracle Java Tutorials

When an error happens inside a method, the method creates an exception object — which holds information about the error: its type and the state of the program when it occurred. That object is handed off to the runtime system. This is called throwing an exception.

The runtime then searches back through the call stack — the ordered list of methods that were called — looking for something that can handle it. If it finds nothing, the program terminates.

The Hierarchy — Error vs Exception

Not everything that goes wrong is the same. Java separates them clearly:

Throwable
├── Error             ← JVM level. You can't fix this. (OutOfMemoryError, StackOverflowError)
└── Exception         ← You CAN handle this
    ├── Checked       ← Compiler forces you to handle (IOException, SQLException)
    └── Unchecked     ← Runtime surprises (NullPointerException, ArrayIndexOutOfBoundsException)

The Error class exists separately from Exception for a reason — it allows programs to use catch (Exception e) to catch recoverable problems without accidentally catching errors from which recovery is typically not possible.

Simple rule:

Error — JVM is in trouble. Don't catch it. Fix the root cause.
Checked Exception — Compiler screams at you. You must handle it.
Unchecked Exception — Runtime surprise. Fix your logic.

The Keywords — one by one

try

Wrap the risky code here. Code that might throw an exception.

try {
    int result = 10 / 0; // risky!
}

catch

If something goes wrong in try, catch it here. Program doesn't crash.

According to Oracle, exception handlers can do more than just print error messages — they can do error recovery, prompt the user to make a decision, or propagate the error up to a higher-level handler.

try {
    int result = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("Can't divide by zero: " + e.getMessage());
}

Java 7+ bonus — one catch block can handle multiple exceptions:

catch (IOException | SQLException e) {
    logger.log(e);
    throw e;
}

Cleaner code, less repetition.

finally

Runs always — whether exception happened or not. This is where you do cleanup — close DB connections, close files, release resources.

try {
    int result = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("Error caught");
} finally {
    System.out.println("This always runs — cleanup here");
}

throw

Manually trigger an exception yourself.

if (age < 0) {
    throw new IllegalArgumentException("Age can't be negative");
}

throws

Used in method signature — a warning that this method might throw an exception. The caller must handle it.

As Oracle explains — if a method doesn't catch the checked exceptions that can occur within it, the method must specify that it can throw those exceptions using throws.

public void readFile(String path) throws IOException {
    // risky file reading code
}

throw vs throws in one line:

throw — you're throwing the ball right now
throws — you're warning someone a ball might come

What to actually DO with errors

Three honest options:

1. Handle it and continue

} catch (NumberFormatException e) {
    System.out.println("Enter a valid number");
    // ask user to re-enter, continue program
}

2. Log it and rethrow (TBD)

} catch (IOException e) {
    logger.error("File read failed", e);
    throw e; // let the caller deal with it
}

3. Wrap and throw a custom exception

} catch (SQLException e) {
    throw new DatabaseException("DB connection failed", e);
}

Key Points

Always catch specific exceptions first, then general ones
A specific handler targets one exact error; a general handler using a superclass like IOException catches all its subclasses too
finally is for cleanup — DB connections, file streams, resources
Never catch Error — those are JVM-level failures, not yours to fix
Checked exceptions — compiler forces you to handle them
Unchecked exceptions — runtime issues, fix your code logic

try {
    // risky code
} catch (FileNotFoundException e) { // specific first
    System.out.println("File not found: " + e.getMessage());
} catch (IOException e) {           // general after
    System.out.println("IO error: " + e.getMessage());
} finally {
    // close connection, file, etc.
}

Exceptions vs Errors — final summary

	Exception	Error
Recoverable?	✅ Yes	❌ No
Should you catch?	✅ Yes	❌ Avoid
Example	IOException, NullPointerException	OutOfMemoryError, StackOverflowError
Cause	Bad logic / external issues	JVM failure

References: Oracle Java Exception Tutorial • Java Language Spec — Exceptions

Why Recursion? (When Loops Feel Just Fine)

Abishek — Wed, 01 Apr 2026 07:08:06 +0000

Honestly, when I first heard about recursion I thought — why even bother, loops work fine.

And I was right. For simple stuff, loops ARE easier.

But then I hit problems where loops started getting messy and recursion just... made sense.

So what even is recursion?

A function that calls itself. That's it.

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

See that? factorial calling factorial. The function solves a smaller version of the same problem until it hits the base case and stops.

Loop vs Recursion — honest take

	Loop	Recursion
Simple problems	✅ easier	feels overkill
Nested/tree structures	gets messy	✅ clean
Memory	efficient	uses call stack
Readability	straightforward	takes time to click

When recursion actually wins

When the problem itself is repetitive in nature — like a folder inside a folder inside a folder. You don't know how deep it goes. A loop struggles. Recursion handles it naturally.

Same with backtracking — maze solving, sudoku. You try a path, it fails, you go back and try another. That "go back" part is just recursion doing its thing.

Basic Programs Every Beginner Must Know (LCM, Sum, Factorial)

Abishek — Fri, 27 Mar 2026 19:06:22 +0000

These are the most important beginner problems asked in interviews and tests.
Let’s understand them with logic + flow + code in 3 languages.

1. Sum of N Numbers

Find the sum from a starting number to an ending number.

Python

output

JAVA

import java.util.Scanner;

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

        int start = sc.nextInt();
        int end = sc.nextInt();

        int result = 0;

        while (start <= end) {
            result += start;
            start++;
        }

        System.out.println(result);
    }
}

JavaScript

let start = 1;
let end = 10;

let result = 0;

while (start <= end) {
    result += start;
    start++;
}

console.log(result);

2. LCM (Least Common Multiple)

Find the smallest number divisible by both numbers.

Python

output

JAVA

import java.util.Scanner;

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

        int a = sc.nextInt();
        int b = sc.nextInt();

        int max = (a > b) ? a : b;

        while (true) {
            if (max % a == 0 && max % b == 0) {
                System.out.println(max);
                break;
            }
            max++;
        }
    }
}

JavaScript

let a = 30;
let b = 35;

let max = a > b ? a : b;

while (true) {
    if (max % a === 0 && max % b === 0) {
        console.log(max);
        break;
    }
    max++;
}

3. Factorial

Find factorial of a number
5! = 5 × 4 × 3 × 2 × 1 = 120

Python

output

JAVA

import java.util.Scanner;

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

        int n = sc.nextInt();
        int result = 1;

        while (n > 0) {
            result *= n;
            n--;
        }

        System.out.println(result);
    }
}

JavaScript

let n = 5;
let result = 1;

while (n > 0) {
    result *= n;
    n--;
}

console.log(result);

15 Java String Method Questions I Practiced — Here's What I Actually Learned

Abishek — Fri, 27 Mar 2026 18:06:05 +0000

15 Java String Method Questions I Practiced — Here's What I Actually Learned

I've been learning Java for a while now, and strings are everywhere. But knowing that String exists and actually knowing how to use it in real situations are two very different things.

Here's everything I picked up, question by question.

Q1 — Why Does Login Fail Even When the Password is Correct?

Scenario: User types Admin123 (with a trailing space). Login fails even though the password matches.

This one is so common in real applications and nobody talks about it enough. The fix is .trim() — it removes all leading and trailing whitespace from a string before you compare it.

if (password.equals(CheckPassword.trim())) {
    System.out.println("Login Success");
}

What I learned: Never compare user input directly. Always .trim() first. Users accidentally add spaces all the time — especially on mobile keyboards.

Q2 — UI Sends "Vijay" but Database Has "vijay" — How to Compare Safely?

Scenario: The UI sends the name with a capital V but your database stores it lowercase.

.equals() is case-sensitive — "Vijay" and "vijay" would fail. The fix is .equalsIgnoreCase() which ignores the case completely.

if (DataBaseName.equalsIgnoreCase(UIName.trim()))
    System.out.println("login success");

What I learned: Always use .equalsIgnoreCase() for usernames and names. Use .equals() only when case matters — like passwords.

Q3 — What's the Difference Between `==` and `.equals()`?

This question genuinely confused me before I practiced it.

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

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

== compares memory addresses (reference). s1 is in the String Pool, s2 is a new object in the heap — different address, so false.
.equals() compares the actual value — both contain "JAVA", so true.

What I learned: Never use == to compare strings in Java. Always use .equals(). The == trap has broken countless real applications.

Q4 — Validate an Email Address

Scenario: Keep asking the user for an email until it contains @ and .

if (CheckEmail.contains("@") && CheckEmail.contains(".")) {
    System.out.println("Your Email : " + CheckEmail);
    condition = false;
}

.contains() checks if a string has a specific sequence of characters inside it. I put it inside a while loop to keep asking until the input is valid.

What I learned: .contains() is great for quick format checks. For production-level validation you'd use regex, but .contains() is perfect for learning the logic first.

Q5 — Convert a String to an Integer

Scenario: User types "1234" as text. You need it as a number to do math.

int number = Integer.parseInt(scan.nextLine());

Integer.parseInt() converts a numeric string into an actual int. If the user types letters instead of numbers, it throws a NumberFormatException — which is why real apps wrap this in try-catch.

What I learned: Keyboard input is always a String. Whenever you need a number from the user, Integer.parseInt() is your go-to.

Q6 — Remove Extra Spaces from Start and End

String extraSpace = " welcome to java ";
System.out.println(extraSpace.trim()); // "welcome to java"

.trim() again — but this time I saw it as a standalone method, not just inside a comparison. It's great for cleaning up any user-facing text before displaying or storing it.

Q7 — Count How Many Times a Word Appears

Scenario: "Java is easy, Java is powerful" — how many times does "Java" appear?

This one I still had a doubt on during practice. The clean way to count occurrences:

String count = "java is easy , java is powerful";
int occurrences = count.split("java", -1).length - 1;
System.out.println(occurrences); // 2

Split the string by the word you're looking for. The number of pieces minus 1 = the number of occurrences. The -1 flag makes sure empty trailing strings are counted too.

What I learned: There's no .countOccurrences() method in Java — you build it using .split() or a loop.

Q8 — Reverse a String Without StringBuilder

Scenario: Reverse "abishek" without using StringBuilder.reverse().

String word = "abishek";
String reverse = "";

for (int i = 0; i < word.length(); i++) {
    reverse = word.charAt(i) + reverse;
}
System.out.println(reverse); // kehsiba

.charAt(i) picks out one character at a time by its index. Each character is added to the front of the result string, which builds the reverse naturally.

What I learned: .charAt() is how you access individual characters in a string. This loop pattern is a classic interview question — worth memorizing.

Q9 — Check if a String is a Palindrome

A palindrome reads the same forwards and backwards — like "madam" or "racecar".

String reverse = "";
for (int i = 0; i < word.length(); i++) {
    reverse = word.charAt(i) + reverse;
}
System.out.println(reverse.equals(word) ? "it is palindrome" : "not palindrome");

Reverse the string using the same loop as Q8, then compare it to the original with .equals(). I also used the ternary operator here which keeps the code clean.

What I learned: Palindrome check = reverse + compare. That's it.

Q10 — Remove Duplicate Characters

Scenario: Input "aabbccddee" → Output "abcde"

String duplicate = "aabbccddee";
String result = "";

for (int i = 0; i < duplicate.length(); i++) {
    if (result.indexOf(duplicate.charAt(i)) == -1) {
        result += duplicate.charAt(i);
    }
}
System.out.println(result); // abcde

.indexOf() returns the position of a character in a string — or -1 if it's not there. I use that -1 check to decide if the character has already been added to the result.

What I learned: .indexOf() returning -1 means "not found" — this is a very useful pattern for checking membership in a string.

Q11 — Extract Part of a String (Log Parser)

Scenario: Log entry is "ERROR: File not found". You only want "File not found".

String logFormat = "ERROR: File not found";
System.out.println(logFormat.substring(7)); // File not found

.substring(7) starts from index 7 and returns everything after it. You can also do .substring(start, end) to get a specific range.

What I learned: .substring() is essential for parsing structured text like logs, file paths, or formatted data where you know the position of what you need.

Q12 — Parse a CSV String

Scenario: "Abishek,Chennai,23" — extract name, city, age separately.

String CSV = "Abishek,Chennai,23";
String[] result = CSV.split(",");

System.out.println("Name: " + result[0]);
System.out.println("City: " + result[1]);
System.out.println("Age:  " + result[2]);

.split(",") breaks the string wherever it finds a comma and returns an array of pieces. I then access each piece by its array index.

What I learned: .split() is how you parse any delimiter-separated data — CSV files, API responses, config strings, all of it.

Q13 — Replace Words in a String

Scenario: Replace "Java" with "Spring Boot" and "Love" with "Hate" in one sentence.

String given = "I Love Java Programming";
String result = given.replace("Java", "C++").replace("Love", "Hate");
System.out.println(result); // I Hate C++ Programming

.replace() swaps every occurrence of a word with something new. You can chain multiple .replace() calls together since each one returns a new String.

What I learned: String methods in Java return new strings — they don't modify the original. This is because strings in Java are immutable. You have to store the result.

Q14 — Validate a Mobile Number

Scenario: Validate that a number is 10 digits and starts with 6, 7, 8, or 9.

if (number.matches("[6-9][0-9]{9}")) {
    System.out.println("Valid number");
}

.matches() checks if the entire string matches a regular expression (regex) pattern. [6-9] means any digit from 6 to 9. [0-9]{9} means exactly 9 more digits after that. Together = a valid Indian mobile number format.

What I learned: .matches() with regex is the professional way to validate formats — phone numbers, emails, passwords, PINs. This was my first time really using regex and it clicked here.

Q15 — Split a String by a Custom Delimiter

Scenario: "apple#banana#mango" — split by # and store in an array.

String GivenString = "apple#banana#mango";
String[] arr = GivenString.split("#");
System.out.println(Arrays.toString(arr)); // [apple, banana, mango]

Same concept as Q12 but with a custom delimiter. Arrays.toString() prints the array in a readable format instead of the raw memory address.

What I learned: .split() works with any delimiter — comma, hash, pipe, space. And always use Arrays.toString() when printing arrays or you'll get gibberish output.

The Full Method Cheat Sheet

Here's every method I used across all 15 questions:

Method	What It Does
`.trim()`	Removes whitespace from start and end
`.equals()`	Compares values — case sensitive
`.equalsIgnoreCase()`	Compares values — ignores case
`.contains()`	Checks if a substring exists inside
`.charAt(i)`	Gets the character at a specific index
`.length()`	Returns total number of characters
`.indexOf()`	Finds position of a character (-1 if not found)
`.substring(n)`	Returns string from index n onwards
`.substring(a, b)`	Returns string from index a to b
`.split(delimiter)`	Breaks string into array by a separator
`.replace(old, new)`	Swaps all occurrences of a word
`.matches(regex)`	Checks if string matches a pattern
`Integer.parseInt()`	Converts numeric string to int

What I Actually Took Away From This

The biggest thing these 15 questions taught me is that String methods are not just syntax — they're tools for solving real problems.

Before this, I knew .trim() existed. Now I know when I need it — every time I take user input. I knew .split() was a thing. Now I know it's how you parse CSV data. I knew == and .equals() were different. Now I know exactly why — and why getting it wrong breaks login systems.

If you're learning Java, I'd genuinely recommend doing scenario-based practice over reading method documentation. The methods stick when you see the problem they solve.

Mastering Java String Methods: Top 20 Methods with Examples

Abishek — Wed, 25 Mar 2026 07:04:14 +0000

Introduction

Strings are a fundamental part of Java programming. To work efficiently with text, developers must understand the built-in methods provided by the String class.

In this blog, we will explore 20 important Java String methods with clear examples.

What is a String in Java?

In Java, a String is the type of object that can store a sequence of characters enclosed by double quotes and every character is stored in 16 bits, i.e., using UTF 16-bit encoding. A string acts the same as an array of characters. Java provides a robust and flexible API for handling strings, allowing for various operations such as concatenation, comparison and manipulation.--->(TBD)

how to create String?

String name = "Abishek";

String name = new String("Abishek")

String Methods

1.length()

"Java String".length(); // 11

What it returns:
It returns an integer showing the total number of characters in the string.

Why we need it:
We use it when we want to know how long a string is—for example, validating input length or looping through characters.

How it works:
Java counts each character in the string, including spaces, and returns the total count

2. charAt()

"Java String".charAt(5);

What it returns:
It returns a single character at the specified index.

Why we need it:
Useful when working with individual characters, such as checking letters or building custom logic.

How it works:
Java treats the string as a sequence of characters and retrieves the one at the given position (index starts from 0).

3. indexOf()

"Java String".indexOf("a"); // 1

What it returns:
Returns the index of the first occurrence of the given character. If not found, it returns -1.

Why we need it:
Helpful when searching for specific characters or words inside a string.

How it works:
Java scans the string from left to right and stops at the first match.

4. lastIndexOf()

"Java String".lastIndexOf("a"); // 3

What it returns:
Returns the index of the last occurrence of the character.

Why we need it:
Useful when a character appears multiple times and you need the final position.

How it works:
Java searches the string from right to left to find the last match.

5. isEmpty()

"".isEmpty(); // true

What it returns:
Returns true if the string is empty, otherwise false.

Why we need it:
Commonly used for input validation to check if the user entered anything.

How it works:
It checks whether the string length is zero

6. equals()

"Java String".equals("Java String"); // true

What it returns:
Returns true if both strings are exactly equal.

Why we need it:
Used to compare string values correctly (instead of using ==).

How it works:
Java compares each character of both strings one by one.

7. equalsIgnoreCase()

"java string".equalsIgnoreCase("JAVA STRING"); // true

What it returns:
Returns true if both strings are equal, ignoring case differences.

Why we need it:
Useful when user input may vary in uppercase/lowercase.

How it works:
Java converts both strings to the same case before comparing.

8. compareTo()

"Java".compareTo("String");

What it returns:

0 → equal
negative → comes before
positive → comes after

Why we need it:
Used for sorting strings in alphabetical order.

How it works:
Java compares characters based on Unicode values.

9. compareToIgnoreCase()

"java".compareToIgnoreCase("JAVA"); // 0

What it returns:
Same as compareTo() but ignores case.

Why we need it:
Useful for sorting or comparing without worrying about uppercase/lowercase.

How it works:
Internally converts both strings to the same case before comparing.

10. contains()

"Java String".contains("String"); // true

What it returns:
Returns true if the substring exists.

Why we need it:
Helpful for checking if a word or phrase is present.

How it works:
Java checks if the given sequence appears anywhere inside the string.

11. substring()

"Java String".substring(5, 11); // String

What it returns:
Returns a part of the original string.

Why we need it:
Useful for extracting specific portions of data.

How it works:
It takes characters from start index up to (but not including) end index.

12. replace()

"Java String".replace("Java", "C++"); // C++ String

What it returns:
Returns a new string with replaced values.

Why we need it:
Used when modifying text, such as replacing words or characters.

How it works:
Java replaces all matching parts and creates a new string.

13. replaceAll()

"Java123 String".replaceAll("\\d", ""); // Java String

What it returns:
Returns a new string after replacing patterns.

Why we need it:
Useful for removing numbers, spaces, or special patterns.

How it works:
Uses regular expressions (regex) to match and replace content.

14. toUpperCase()

"Java String".toUpperCase(); // JAVA STRING

What it returns:
Returns the string in uppercase.

Why we need it:
Useful for formatting or standardizing text.

How it works:
Converts each character to its uppercase equivalent.

15. toLowerCase()

"Java String".toLowerCase(); // java string

What it returns:
Returns the string in lowercase.

Why we need it:
Used when case-insensitive comparison is needed.

How it works:
Converts each character to lowercase.

16. trim()

"  Java String  ".trim(); // Java String

What it returns:
Returns a string without leading and trailing spaces.

Why we need it:
Useful when cleaning user input.

How it works:
Removes spaces only from the beginning and end.

17. split()

"Java,String".split(","); //[Java,String]

What it returns:
Returns an array of strings.

Why we need it:
Useful for breaking data into parts (like CSV values).

How it works:
Splits the string based on a delimiter.

18. concat()

"Java".concat(" String"); // Java String

What it returns:
Returns a new combined string.

Why we need it:
Used to join strings together.

How it works:
Adds the second string to the first and returns a new string.

19. join()

String.join(" ", "Java", "String"); // Java String

What it returns:
Returns a single string with joined values.

Why we need it:
Useful when combining multiple values with a separator.

How it works:
Adds a delimiter between each element and joins them.

20. matches()

"Java123".matches("[A-Za-z0-9]+"); // true

What it returns:
Returns true if the string matches the pattern.

Why we need it:
Used for validation (email, password, etc.).

How it works:
Checks the string against a regex pattern.--->(TBD)

Java basics like Class,Datatype,Static....

Abishek — Mon, 16 Feb 2026 16:45:33 +0000

Class

1, what is class?
-> Class is blueprint or template
-> A class is the blueprint from which individual objects are created.
-> This section defines a class that models the state and behavior of a real-world object
-> It intentionally focuses on the basics, showing how even a simple class can cleanly model state and behavior.
-> the word class is a reserved word in java
-> A class has one or more methods.
-> A class should have only one main method
-> A class is indeed a non-primitive data type in programming.

DataType

there are two types of data types in java.
- 1. primitive datatype
- 2. non-primitive datatype

Primitive datatypes

There are two type
- numeric type
  - byte
  - short
  - int
  - long
  - float
- non numeric type
  - boolean
  - char

Non-Primitive datatypes

Non-primitive data types are called reference types because they refer to objects.
- String
- array
- class
- object
- interface
- enum

the image show that how the data types will be declared,ranges,size...

Static

When a member is declared static, it belongs to the class rather than instances of the class.This means that only one instance of the static member exists, regardless of how many objects of the class are created.
static is a non-access modifier in Java.
Access modifiers: public, private, protected,default.
Non-access modifiers: static, final, abstract, synchronized, transient, volatile.

The static keyword can be used with the following:

Variable (also known as a class variable)
Method (also known as a class method)
Block
Nested class

static Variable

class Example {
    static int counter = 0;
}

Static Method

class Example {
    static void display() {
        System.out.println("Static method called");
    }
}

Static nested class(TBD)

class OuterClass {
    static class NestedStaticClass {
        void display() {
            System.out.println("Static nested class method called");
        }
    }
}

Static block(TBD)

public class StaticBlockExample {
    static {
        System.out.println("Static block executed");
    }

DEV Community: Abishek

String Problems

Password generator

Password Validator program

Count Of Letter,Special Character and Number

Upper to Lower

Every ArrayList Method You Need to Know (With Examples)

The Methods

add(element)

add(index, element)

get(index)

set(index, element)

remove(index)

remove(object)

size()

isEmpty()

contains(object)

indexOf(object)

lastIndexOf(object)

clear()

addAll(collection)

addAll(index, collection)

removeAll(collection)

retainAll(collection)

containsAll(collection)

toArray()

subList(fromIndex, toIndex)

Collections.sort(list)

Collections.reverse(list)

Quick Reference Table

Let's learn about collection and How to print Objects

Arrays

What is auto boxing and auto unboxing ?

FileReader ,BufferedReader ,FileWriter,BufferedWriter

Class Hierarchy (With Meaning, Not Just Structure)

Key Insight

FileReader — What Actually Happens Internally

Internal Flow

The Problem

BufferedReader — What Changes?

Internal Behavior

Deep Dive: readLine()

Key Shift

Why BufferedReader Is Faster (Actual Reasons)

1. Reduced System Calls

2. Lower CPU Overhead

3. Better Memory Access Patterns

FileWriter — Internal Behavior

What Happens

Problem

BufferedWriter — What Actually Improves?

Internal Flow

Deep Detail: flush()

Composition Design (Decorator Pattern)

Why This Design Exists

Why Not Just Use FileReader Everywhere?

Memory vs Performance Tradeoff

Try-With-Resources — What It Actually Solves

What It Guarantees

File Handling

Java File Class

How to Create a file Object

File Class Constructors(TBD)

File Class Methods

Neon,Strong,Perfect Number coding

Neon Number

Python

java

Strong number

python

java

Perfect Number

Python

java

Exception Handling

What is an Exception?

The Hierarchy — Error vs Exception

The Keywords — one by one

try

catch

Deep Dive: `readLine()`

Deep Detail: `flush()`

Q3 — What's the Difference Between `==` and `.equals()`?