DEV Community: Arul .A

Understanding String Immutability Through Practical Python Examples

Arul .A — Tue, 21 Apr 2026 16:00:49 +0000

1.Remove extra space :

name="practice makes    perfect"
i=0
result=""
while i<len(name):
  if name[i]!=" ":
    result=result+name[i]
  else:
    if i>0 and name[i-1]!=" ":
      result=result+name[i]
  i+=1
print(result)

Output:

2.Remove unwanted space in front of the sentence:

name = "practice makes perfect        "
i = 0
result = ""

while i < len(name):
    if name[i] != " ":
        break   
    i += 1

while i < len(name):
    result += name[i]
    i += 1

print(result)

Output:

3.Remove unwanted space in back of the sentence:

name = "Kill them with your success        "
result = ""

i = len(name)-1

while i >= 0:

    if name[i] == " ":
        i -= 1
        continue

    else:
        j = 0

        while j <= i:
            result += name[j]
            j += 1

        break

print(result)

Output :

4.Reversing a word:

name = "Arul"
result = ""

i = len(name)-1

while i >= 0:
    result = result + name[i]
    i -= 1

print(result)

Output:

Password generator

Arul .A — Tue, 21 Apr 2026 08:58:59 +0000

1.Password Generator :

Algorithm:

1.Define character sets: uppercase, lowercase, digits, and special characters.

2.Combine all character sets into one common pool.

3.Initialize an empty password string.

4.Add one random character from each character set to ensure strength.

5.Use a loop to add remaining random characters from the common pool until length is reached.

6.Display the final generated password.1.

Example:

import random

upper="ABCDEFGHIJKLMNOPQRSTUVWXYZ"
lower="abcdefghijklmnopqrstuvwxyz"
numbers="0123456789"
special="!@#$&"

all_chars=upper+lower+numbers+special

password=""

password=password+random.choice(upper)
password=password+random.choice(lower)
password=password+random.choice(numbers)
password=password+random.choice(special)

i=4

while i<8:
    password=password+random.choice(all_chars)
    i+=1

print("Generated Password :",password)

Output :

Password Validation ?

Arul .A — Tue, 21 Apr 2026 08:46:46 +0000

1.Lowercase to Uppercase converter:

text=input("Enter some words :")
i=0
upper=""
while i<len(text):
    ch=text[i]
    if ch>="a" and ch<="z":
        upper=upper+chr(ord(ch) - 32)
    else:
        upper=upper+ch
    i+=1
print(upper)

2.First letter Only uppercase:

text=input("Enter some words :")
i=0
upper=""
while i<len(text):
    ch=text[i]
    if (ch>="a" and ch<="z") and (text[i-1]==" " or i==0):
        upper=upper+chr(ord(ch) - 32)
    else:
        upper=upper+ch
    i+=1
print(upper)

3.Letters Count :

text=input("Enter some words :")
i=0
count=0
while i<len(text):
    ch=text[i]
    if (ch>="a" and ch<="z") or (ch>="A" and ch<="Z"):
        count+=1
    i+=1
print(count)

4.Word Count :

text=input("Enter some words :")
i=0
count=1
while i<len(text):
    if text[i]!=" " and text[i-1]==" ":
        count+=1
    i+=1
print(count)

5.Password Validation :

text = input("Create your password: ")

upper = False
lower = False
number = False
special = False
valid = True

i = 0
while i < len(text):
    ch = text[i]

    if "A" <= ch <= "Z":
        upper = True
    elif "a" <= ch <= "z":
        lower = True
    elif "0" <= ch <= "9":
        number = True
    elif ch in "!@#$&":
        special = True
    else:
        valid = False

    i += 1

if len(text) < 8:
    print("Password must be at least 8 characters")

else:
    if not valid:
        print("Only allowed special characters: ! @ # $ &")

    if not upper:
        print("Add at least one uppercase letter")

    if not lower:
        print("Add at least one lowercase letter")

    if not number:
        print("Add at least one number")

    if not special:
        print("Add at least one special character: ! @ # $ &")

    if upper and lower and number and special and valid:
        print("Password successfully created")

Sorting Custom Objects in Java: A Beginner's Guide to Comparable

Arul .A — Tue, 21 Apr 2026 04:56:57 +0000

Comparable Interface in Java Collections :

What is it?

Comparable is a Java interface in java.lang with a single method:

Ex:

public interface Comparable<T> {
    int compareTo(T other);
}

It defines the natural ordering of objects of a class. When a class implements Comparable, it's saying "I know how to compare myself to another object of my type."

compareTo return values:

Return Value - Meaning
negative - this < other
0 - this== other
positive - this > other

Example:

Product pen  = new Product("Pen",  10.0);
Product bag  = new Product("Bag",  50.0);
Product book = new Product("Book", 10.0); // same price as pen

System.out.println(pen.compareTo(bag));  // negative → pen < bag
System.out.println(bag.compareTo(pen));  // positive → bag > pen
System.out.println(pen.compareTo(book)); // 0        → equal price

Result - Meaning
negative - pen is cheaper than bag
0 - pen and book cost the same
positive - bag is more expensive than pen

Why use it?

Without Comparable, Java's sorting and ordering mechanisms have no idea how to rank your custom objects.

Implementing it lets you use:

Collections.sort(list)
Arrays.sort(array)
TreeSet / TreeMap (automatically sorted)
PriorityQueue (min-heap by default)

When to use it?

Use Comparable when your class has one obvious, default ordering that makes sense intrinsically — like a Student sorted by roll number, or a Product by price.

class Student implements Comparable<Student> {
    String name;
    int rollNo;

    Student(String name, int rollNo) {
        this.name = name;
        this.rollNo = rollNo;
    }

    @Override
    public int compareTo(Student other) {
        return this.rollNo - other.rollNo; // Natural order: ascending by rollNo
    }

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

public class Main {
    public static void main(String[] args) {
        List<Student> students = new ArrayList<>();
        students.add(new Student("Alice", 3));
        students.add(new Student("Bob", 1));
        students.add(new Student("Carol", 2));

        Collections.sort(students); // Uses compareTo internally

        System.out.println(students); // [Bob(1), Carol(2), Alice(3)]

        // Works with TreeSet too
        TreeSet<Student> set = new TreeSet<>(students);
        System.out.println(set); // [Bob(1), Carol(2), Alice(3)]
    }
}

Decode Any Indian Pincode Using Python?

Arul .A — Mon, 20 Apr 2026 08:42:31 +0000

We take a 6-digit pincode as input from the user and validate it before processing. By splitting the first digit, first two digits, and first three digits, we identify the Region, Sub-region, and District. This way, anyone can find the exact location details of any pincode.

regions = {
    1: "Delhi",
    2: "Uttar Pradesh & Uttarakhand",
    3: "Rajasthan & Gujarat",
    4: "Maharashtra",
    5: "Andhra Pradesh & Telangana",
    6: "Tamil Nadu & Kerala",
    7: "West Bengal & North East",
    8: "Bihar & Jharkhand",
    9: "Army Postal Service"
}

sub_regions = {
    11: "Delhi Region",
    40: "Mumbai Region",
    60: "Chennai Region",
    70: "Kolkata Region"
}

districts = {
    110: "Delhi",       111: "Delhi (North)",      112: "Delhi (South)",
    400: "Mumbai",      401: "Mumbai (Suburban)",   402: "Mumbai (West)",
    600: "Chennai",     601: "Tiruvallur",          602: "Kanchipuram",
    700: "Kolkata",     701: "Kolkata (North)",     702: "Kolkata (South)"
}

def get_pincode_details(pincode):
    if not pincode.isdigit() or len(pincode) != 6:
        print("Invalid pincode. Enter exactly 6 digits.")
        return

    num         = int(pincode)
    first_digit = num // 100000
    first_two   = num // 10000
    first_three = num // 1000

    print("Region:     ", regions.get(first_digit,   "Unknown"))
    print("Sub-region: ", sub_regions.get(first_two, "Unknown"))
    print("District:   ", districts.get(first_three, "Unknown"))


pincode = input("Enter Pincode: ").strip()
get_pincode_details(pincode)

Java ArrayList Cheat Sheet: All Methods with Examples

Arul .A — Mon, 20 Apr 2026 03:31:50 +0000

What is Arraylist?
Java ArrayList class uses a dynamic array for storing the elements. It is like an array, but there is no size limit. We can add or remove elements anytime. So, it is much more flexible than the traditional array. It is found in the java.util package. The ArrayList in Java can have the duplicate elements also. It implements the List interface so we can use all the methods of the List interface here. The ArrayList maintains the insertion order internally.

import java.util.ArrayList;
import java.util.Collections;

public class ArrayListMethods {
    public static void main(String[] args) {

        // 1. CREATE ArrayList

        ArrayList<String> list = new ArrayList<>();
        System.out.println("Created ArrayList: " + list);


        // 2. add() - Add elements

        list.add("Chennai");
        list.add("Mumbai");
        list.add("Delhi");
        list.add("Kolkata");
        System.out.println("\nAfter add()     : " + list);
        // Output: [Chennai, Mumbai, Delhi, Kolkata]


        // 3. add(index, element) - Add at position

        list.add(2, "Bangalore");
        System.out.println("After add(2)    : " + list);
        // Output: [Chennai, Mumbai, Bangalore, Delhi, Kolkata]

        // 4. get() - Get element by index

        String city = list.get(0);
        System.out.println("\nget(0)          : " + city);
        // Output: Chennai

        // 5. set() - Update element

        list.set(1, "Hyderabad");
        System.out.println("After set(1)    : " + list);
        // Output: [Chennai, Hyderabad, Bangalore, Delhi, Kolkata]


        // 6. remove(index) - Remove by index

        list.remove(3);
        System.out.println("After remove(3) : " + list);
        // Output: [Chennai, Hyderabad, Bangalore, Kolkata]

        // 7. remove(object) - Remove by value

        list.remove("Kolkata");
        System.out.println("After remove()  : " + list);
        // Output: [Chennai, Hyderabad, Bangalore]


        // 8. size() - Get size

        System.out.println("\nsize()          : " + list.size());
        // Output: 3


        // 9. contains() - Check element exists

        System.out.println("contains Chennai: " + list.contains("Chennai"));
        // Output: true
        System.out.println("contains Delhi  : " + list.contains("Delhi"));
        // Output: false


        // 10. indexOf() - Get index of element

        System.out.println("\nindexOf Chennai : " + list.indexOf("Chennai"));
        // Output: 0

        // 11. isEmpty() - Check if empty

        System.out.println("isEmpty()       : " + list.isEmpty());
        // Output: false

        // 12. sort() - Sort elements

        Collections.sort(list);
        System.out.println("\nAfter sort()    : " + list);
        // Output: [Bangalore, Chennai, Hyderabad]


        // 13. reverse() - Reverse elements

        Collections.reverse(list);
        System.out.println("After reverse() : " + list);
        // Output: [Hyderabad, Chennai, Bangalore]


        // 14. subList() - Get portion of list

        list.add("Delhi");
        list.add("Mumbai");
        System.out.println("\nFull list       : " + list);
        System.out.println("subList(1,3)    : " + list.subList(1, 3));
        // Output: [Chennai, Bangalore]

        // 15. toArray() - Convert to Array

        Object[] arr = list.toArray();
        System.out.println("\ntoArray()       : ");
        for (Object obj : arr) {
            System.out.println("  " + obj);
        }


        // 16. addAll() - Add multiple elements

        ArrayList<String> newCities = new ArrayList<>();
        newCities.add("Pune");
        newCities.add("Jaipur");
        list.addAll(newCities);
        System.out.println("\nAfter addAll()  : " + list);
        // Output: [Hyderabad, Chennai, Bangalore, Delhi, Mumbai, Pune, Jaipur]

        // 17. clear() - Remove all elements

        list.clear();
        System.out.println("After clear()   : " + list);
        // Output: []
        System.out.println("isEmpty()       : " + list.isEmpty());
        // Output: true
    }
}

Input Validation in Java: Validating PIN Code, Gmail, and Mobile Numbers

Arul .A — Sat, 18 Apr 2026 09:22:09 +0000

1.pincode validation :

Must be 6 digits
Only numbers (no letters, no symbols)
first digit can’t be 0

def pincode(pc):
    if pc//100000!=0 and pc//100000<=9:
        print("valid")
    else:
        print("invalid")
pincode(int(input("Enter your 6 digit pin code :")))

2.Gmail validation :

Allow only characters: a–z, A–Z, 0–9, '@', '.', '_'.
If any other character appears → invalid.
Email must end with "@gmail.com".
There must be at least one character before "@gmail.com".
Special characters (@ . _) are allowed anywhere (no position check).
If all above conditions pass → valid Gmail, else invalid.

def verify_Gmail(Gmail):
    i=0
    while i<len(Gmail):
        current=Gmail[i]
        i+=1
        if current>="a" and current<="z":
            continue;
        elif current>="A" and current<="Z":
            continue;
        elif current>="0" and current<="9":
            continue;
        elif current=="@" or current=="." or current=="_":
            continue;
        else:
            return False
    if Gmail[-10:]=="@gmail.com":
        return True
    else:
        return False
if verify_Gmail(input("Enter Your Gmail :")):
    print("valid")
else:
    print("invalid")

3.Mobile number validation :

Allow only digits (0–9), '+' and space; reject anything else.
If length = 10 → must be all digits and start with 6–9.
If length = 13 → must start with "+91" and next digit must be 6–9.
If length = 14 → must start with "+91 " and next digit must be 6–9.
Otherwise → invalid mobile number.

def verify(mobnum):
    index=0
    while index<len(mobnum):
        if mobnum[index]>="0" and mobnum[index]<="9":
            index+=1
            continue;
        else:
            return False
    return True



def mobile(n):
    i=0
    while i<len(n):
        if(n[i]>="0" and n[i]<="9") or (n[i]=="+") or (n[i]==" "):
            i+=1
        else:
            return "characters and special charactors not allowed"

    if len(n)==10:
        if n[0]>="6" and n[0]<="9" and verify(n):
            return "valid";
        else:
            return "incorrect"

    if len(n)==13:
        if n[0:3]=="+91":
            if n[3]>="6" and n[3]<="9" and verify(n[3:]):
                return "valid"
            else:
                return "incorrect"
        return "First three number should like +91"

    if len(n)==14:
        if n[0:4]=="+91 ":
            if n[4]>="6" and n[4]<="9" and verify(n[4:]):
                return "valid"
            else:
                return "incorrect"
        return "First four number should like +91 "
    return "Please Enter Your valid Mobile Number"      
print(mobile(input("Enter Your Mobile  Number : ")));

Primitives vs Objects: The Magic of Java Wrapper Classes

Arul .A — Sat, 18 Apr 2026 04:24:28 +0000

Wrapper class :

A Wrapper class is a class that wraps a primitive data type inside an object. In Java, primitive types like int, double, char etc. are not objects — but sometimes Java needs objects (like in Collections).

Primitive vs Wrapper class:
int - Integer
double - Double
char - Character
boolean - Boolean
float - Float
long - Long
byte - Byte
short - Short

Autoboxing :

-The java automatically converts primitive to object.
Ex:

int x = 5(primitive) → auto → Integer obj = 5

Unboxing :

The java automatically converts object to primitive. Ex:


Integer obj = 5 (wrapper object) → auto → int x = 5 (primitive)

Where Primitive and wrapper objects are stored :

Stack memory - Primitives like int, double are stored here. Fast, small, temporary.
Heap memory - Wrapper objects like Integer, Double are stored here as full objects.

Java Collections: Everything You Need to Know About the List Interface

Arul .A — Sat, 18 Apr 2026 02:21:47 +0000

1.List Interface :

The List interface is part of java.util and extends the Collection interface. It represents an ordered sequence of elements — you can access any element by its position (index).

It is Ordered
It Allows duplicates
Index-based access

import java.util.List;
import java.util.ArrayList;

List<String> fruits = new ArrayList<>();
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Mango");
System.out.println(fruits.get(0)); // Output: Apple

The 2 main implementations :

Arraylist:

Elements sit side-by-side in memory. Jump to any index instantly — like numbered boxes in a row.
It stores elements in a contiguous block of memory, so get(5) jumps straight to position 5 — like page numbers in a book. This is called O(1) or "constant time."

-When you use ArrayList :

You read or access elements often
You mostly add to the end of the list
Memory efficiency matters
You need to iterate in order

Linkedlist:

Each node holds the value + a pointer to next. Scattered in memory must walk the chain to find an element.
Each element is a node that holds a pointer to the next. Inserting means just rewiring two pointers — no shifting needed. ArrayList, on the other hand, has to push every element after the insertion point one slot over.

-When you use Linkedlist :

You insert/delete in the middle often
You need a Queue or Deque structure
List size changes frequently
You process from both ends

Common List methods :

1.Add() — insert elements :

fruits.add("Grapes");           // Adds to end
fruits.add(1, "Cherry");      // Adds at index 1

2.get() & size() — access & count :

String first = fruits.get(0);  // "Apple"
int total = fruits.size();      // Total items

3.remove() — delete elements :

fruits.remove("Banana");       // Remove by value
fruits.remove(0);              // Remove by index

The Java Collections are Backbone of Data Handling

Arul .A — Thu, 16 Apr 2026 15:54:46 +0000

Hi,today i learned about the java collections in java.I will share some points in java collections.

What is Java Collections ?

The java collections is a framework that provides a set of interfaces and classes to store,manage, and manipulate groups of objects efficiently.

Core Components of Java Collections :

The framework is mainly divided into three major interfaces:

1) List – Ordered and Allows Duplicates

A List maintains insertion order and allows duplicate elements.

Common Implementations:

ArrayList
LinkedList

Example:
List list = new ArrayList<>();
list.add("Apple");
list.add("Apple"); // duplicates allowed

Use List when:

Order matters
You need index-based access

2) Set – No Duplicates Allowed

A Set does not allow duplicate elements.

Common Implementations:

HashSet (fast, unordered)
TreeSet (sorted)

Example:
Set set = new HashSet<>();
set.add("Apple");
set.add("Apple"); // ignored

Use Set when:

You want unique values
Duplicates must be avoided

3) Map – Key-Value Pair Storage

A Map stores data in key-value format.

Common Implementations:

HashMap
TreeMap Example: Map map = new HashMap<>(); map.put(1, "Arul"); map.put(2, "John");

Use Map when:

You need to associate one value with another
Fast lookup using keys is required

Real-World Use Cases

Java Collections are everywhere:

Storing user data in applications
Managing product lists in e-commerce
Handling logs and transactions
Processing large datasets

What is Testing?Types Of Testing?Example for Testcase?

Arul .A — Thu, 16 Apr 2026 03:52:21 +0000

Testing:

It refers to the process of evaluating a system or its components to determine whether they meet specified requirements.
It involves executing a program with the intent to identify bugs, errors, or any discrepancies that could hinder functionality.
The primary goal of testing is to ensure that the software is reliable, functional, and ready for deployment.

Types of Testing :

Manual Testing:

Manual testing is the process of manually executing test cases without of automation tools.

Automated Testing:

Automated testing uses specialized tools and scripts to perform tests automatically. This approach is particularly useful for regression testing, where the same tests are run repeatedly.

Unit Testing:

Unit testing focuses on individual components or functions of the software. The primary goal is to ensure that each unit performs as expected.

Integration Testing:

Integration testing evaluates the interaction between different components or systems. It helps to identify issues that occur when integrating various modules.

System Testing:

System testing involves testing the entire software application as a whole. It validates the software against the specified requirements and ensures it behaves as expected in a complete environment.

Acceptance Testing:

Acceptance testing is performed to determine whether the software is acceptable for delivery. This testing often involves stakeholders and users to ensure all requirements are met.

What is Testcase :
A test case is a documented set of conditions, inputs, steps, and expected results used to verify specific software functionality.

It ensures applications work as intended, aiding in validation, repeatability, and bug detection.
Key elements include a unique ID, description, prerequisites, steps, and expected outcomes.

Core Components of a Test Case:

Test Case ID: A unique identifier.
Description: What feature is being tested.
Preconditions: Necessary conditions, such as user login state.
Test Steps: Detailed actions to perform.TestData: Input data used (e.g., username, password).
Expected Result: The anticipated behavior of the application.
Actual Result: The actual behavior observed.
Status: Pass/Fail.

Example For Testcase :

Python vs Java: Don’t Choose Blindly — Here’s the Reality

Arul .A — Wed, 15 Apr 2026 15:19:15 +0000

Python :

The Variables do not need type declarations.

x = 10          # no type declaration needed
x = "hello"     # can reassign to a different type

The syntax uses indentation for code blocks.

def print():
    a=10
print("Hello, World!")

Python supports standalone functions outside classes.

def greet(name):
    return f"Hi {name}"

Java :

The java is strictly declare the data type before you create a variable.

int x = 10;         // type must be declared
// x = "hello";     // compile error!

The Java uses curly braces .

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

Java requires everything to be inside a class — no standalone functions

public class Greeter {
    public static String greet(String name) {
        return "Hi " + name;
    }
}