DEV Community: Hayes vincent

Comparable in Java

Hayes vincent — Mon, 20 Apr 2026 17:07:32 +0000

The Real Problem

Let’s say you create a Student class:

name

Now you store multiple students in a list and try:

Collections.sort(list);

Boom error.

Why?

Because Java doesn’t know how to compare two Student objects.

For numbers, it knows 5 > 3
For strings, it knows "A" < "B"
But for Student? No idea.

So What Does Comparable Do?

Comparable is like giving instructions to Java:

“If you want to compare my objects, follow this rule.”

It defines a default sorting logic for your class.

The Key Method: compareTo()

When you implement Comparable, you must override:

compareTo()

This method compares: current object vs another object

Basic idea:

return positive → current is bigger

return negative → current is smaller

return 0 → both are equal

Example: Sorting Students by ID

Let’s say we want to sort students by their ID.

Inside the Student class:

class Student implements Comparable {

int id;
String name;

public int compareTo(Student other) {
    return this.id - other.id;
}

}

That’s it.

Now Java understands how to sort your objects.

What Happens Behind the Scenes?

When you call:

Collections.sort(list);

Java will:

Pick two objects
Call compareTo()
Decide order
Repeat until everything is sorted

You don’t see it, but that’s what’s happening internally.

Before and After Sorting

Before:

[3-Alice, 2-Charlie, 4-Jennie]

After:

[2-Charlie, 3-Alice, 4-Jennie]

Simple and clean.

One Important Limitation

Comparable supports only one sorting logic.

So if you define sorting by ID: You cannot directly sort by name using the same Comparable.

For multiple sorting options, Java provides another concept called Comparator.

When Should You Use Comparable?

Use Comparable when:

Your class has a natural default order

You only need one main sorting logic

Example:

Students → sort by ID

Employees → sort by salary

Comparable is one of those concepts that feels confusing at first, but once you understand the idea, it becomes very simple.

You’re just teaching Java:

“This is how my objects should be compared.”

And once Java understands that, sorting becomes effortless.

“Comparable is used to define the natural ordering of objects by implementing the compareTo() method inside the class.”

Java Collections, ArrayList, Wrapper Class & Memory

Hayes vincent — Fri, 17 Apr 2026 17:28:52 +0000

When you start learning Java, these topics come up everywhere — collections, ArrayList, wrapper classes, and memory. Instead of memorizing definitions, it’s better to understand how they actually work together.

Java Collections – The Big Picture

In Java, the Collection framework is used to store and manage groups of data.

Think of it like a toolbox. Inside it, you have different tools depending on your need.

Here’s a simple structure:

Collection (Interface)
   |
   |--- List
   |      |--- ArrayList
   |      |--- LinkedList
   |      |--- Vector
   |
   |--- Set
          |--- HashSet
          |--- LinkedHashSet
          |--- TreeSet

List → ordered, allows duplicates
Set → no duplicates

What is ArrayList?

ArrayList is one of the most commonly used classes in Java.

It works like a dynamic array — meaning:

You don’t need to fix the size
It grows automatically when you add elements

Why developers like ArrayList:

Maintains insertion order
Allows duplicates
Fast access using index

Example:

import java.util.*;

class Demo {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();

        list.add(10);
        list.add(20);
        list.add(10);

        System.out.println(list);
    }
}

Output:

[10, 20, 10]

So yes — duplicates are allowed, and order is preserved.

Wrapper Class – Why Do We Need It?

Java has primitive types like:

int, char, double, boolean

But collections (like ArrayList) only store objects, not primitives.

That’s where wrapper classes come in.

Primitive	Wrapper Class
int	Integer
char	Character
double	Double
boolean	Boolean

Example:

int a = 10;
Integer obj = a;  // Autoboxing

Java automatically converts int → Integer. This is called autoboxing.

Printing Wrapper Objects

Integer obj = 100;
System.out.println(obj);

Output:

You might expect a memory address, but you get the value.

Why?

Because wrapper classes override the toString() method — so they print the actual value.

Stack vs Heap – Simple Understanding

This is where many beginners get confused. Keep it simple:

Stack

Stores primitive values
Stores references (addresses) of objects
Fast memory

Heap

Stores actual objects
Shared memory

Quick Table:

Type	Stack	Heap
int (primitive)	Stored directly	❌
Integer	Reference stored	Object stored
ArrayList	Reference stored	Object stored

Example to understand:

int a = 10;
Integer obj = new Integer(20);

a → stored in stack
obj → reference in stack, actual object in heap

Collection in Java

Hayes vincent — Thu, 16 Apr 2026 07:26:23 +0000

When you first start learning Java, you probably use variables and arrays to store data. It works fine… until it doesn’t. The moment your data becomes unpredictable or starts growing, arrays begin to feel rigid. That’s where Collections step in.

A Collection in Java is basically a smarter way to store a group of objects. Instead of worrying about size limits or writing extra logic to manage data, Collections handle most of that for you.

Collections aren’t just a feature in Java—they’re something you’ll use constantly once you start building real projects. Arrays teach you the basics, but Collections make your code practical.

So what’s the big deal?

Imagine you’re building a simple app—maybe a student list or a shopping cart. You don’t know how many items will be added. With arrays, you must decide the size beforehand. If it exceeds, you’re stuck.

Collections don’t have that problem.

They grow when needed. Shrink when needed. You just focus on your logic.

Why developers actually use Collections

It’s not just about avoiding arrays. Collections make coding easier in real-world scenarios:

You can add or remove data anytime without worrying about size
You get ready-made methods like sorting and searching
Less manual work → cleaner code
You can choose different structures depending on your need

For example:

Want ordered data? Use a List
Want unique values only? Use a Set
Want key-value pairs? Use a Map
When do you really need Collections?

You’ll end up using Collections in almost every real application:

When handling user input
When working with database results
When building features like cart, lists, history, logs
Anytime data is dynamic and changing

In short, if your data isn’t fixed, Collections are the better choice.

A quick example
import java.util.*;

public class Demo {
    public static void main(String[] args) {
        ArrayList<String> names = new ArrayList<>();

        names.add("Arun");
        names.add("Vijay");
        names.add("Kumar");

        System.out.println(names);
    }
}

Secure Socket Layer (SSL)And Jmeter

Hayes vincent — Sat, 11 Apr 2026 19:52:56 +0000

Secure Socket Layer (SSL) is a security protocol used to protect data when it is sent over the internet.

Simple Explanation

SSL makes sure that:

Data is encrypted (hidden from hackers)

Data is safe during transmission

The website you are connecting to is genuine (trusted)

Real-life Example

When you open a website like: https://google.com

The "https" means SSL is used

Your data (password, card details, etc.) is encrypted

How SSL Works (Easy Steps)

Browser sends request to server
Server sends its SSL certificate
Browser verifies it
Encrypted connection is established
Data is transferred securely

Key Features

Encryption – hides data

Authentication – verifies website identity

🛡 Data Integrity – prevents data tampering

SSL is now mostly replaced by TLS (Transport Layer Security), but people still say “SSL” commonl

"SSL is a protocol used to encrypt data between client and server, ensuring secure communication over the Internet

What is JMeter?

JMeter is a performance testing tool used to check how well a website or application works under load (many users).

Simple Explanation

It helps you answer:

How fast is my website?

Can it handle 1000 users at the same time?

Will it crash under heavy traffic?

Real-life Example

Imagine you built an e-commerce website.

Using JMeter, you can:

Simulate 500 users visiting your site

Check response time

Find slow APIs or crashes

Key Features

Load testing (many users at once)

Performance testing (speed check)

Supports HTTP, HTTPS, APIs

Gives reports (graphs, charts)

Basic Workflow

Create Test Plan
Add Thread Group (number of users)
Add HTTP Request (URL/API)
Run test
Analyze results

"Apache JMeter is an open-source tool used for load and performance testing of web applications and APIs."

FileReader, BufferedReader, FileWriter, BufferedWriter in Java

Hayes vincent — Thu, 09 Apr 2026 05:19:44 +0000

When I first started learning Java file handling, I thought all these classes were just different ways to read and write files. But once I understood how they actually work internally, everything became clearer.

Let’s break it down in a simple way.

Big Picture (How They Are Related)

Java splits file handling into two layers:

Reader (abstract)
   ↓
FileReader        → connects to file
BufferedReader    → makes reading faster

Writer (abstract)
   ↓
FileWriter        → connects to file
BufferedWriter    → makes writing faster

Think of it like this:

FileReader / FileWriter → direct connection to the file
BufferedReader / BufferedWriter → performance layer on top

FileReader — What Really Happens

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

At first glance, it looks simple. But behind the scenes:

Java requests data from the OS
OS reads data from disk into memory
JVM copies it into user space
You receive one character at a time

Now consider this loop:

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

This leads to:

Many method calls
Reading one character repeatedly
Inefficient performance for large files

The issue is not disk speed — it is how the data is consumed.

BufferedReader — The Improvement

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

This introduces a buffer layer.

What changes:

Reads a large chunk (around 8KB) at once
Stores it in memory
Your program reads from memory instead of disk repeatedly

Example:

String line = br.readLine();

Internally:

Searches for newline (\n)
Builds a string
If newline is not found, it refills the buffer and continues

Instead of multiple disk operations:

One disk read
Many fast in-memory reads

Why BufferedReader Is Faster

The performance improvement comes from:

Fewer system calls
Lower CPU overhead
Better memory access patterns

FileWriter — Writing Basics

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

What happens:

Data moves from Java to the OS
OS writes it to disk

Issue:

Each write operation may trigger disk activity
Frequent writes reduce performance

BufferedWriter — Efficient Writing

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

Now:

Data is stored in memory first
Written to disk only when:
- Buffer is full
- flush() is called
- close() is called

Important:

bw.flush();

This ensures data is written to disk.

Without calling flush:

Data may remain in memory
Output may appear incomplete

Design Insight (Decorator Pattern)

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

This is an example of the Decorator Pattern:

FileReader → provides base functionality
BufferedReader → enhances it

Benefits of this design:

Separation of concerns
Reusable components
Flexible layering

Why Not Just Use FileReader/FileWriter?

Because they do not scale well.

Problem	Impact
Character-by-character reading	Slow
Frequent system calls	High overhead
No batching	Poor performance

Memory vs Performance

Buffered classes:

Use slightly more memory
Provide significant performance improvement

A small memory cost results in much faster execution.

Try-With-Resources (Best Practice)

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

Advantages:

Automatically closes resources
Prevents memory leaks
Ensures proper flushing for writers

File Handling Classes in Java

Hayes vincent — Tue, 07 Apr 2026 15:42:45 +0000

File Handling

When working with Java, handling files is a very common task — whether you're storing data, reading input, or creating logs.

Java provides several classes in the java.io package to make file handling easy. Let’s understand the most important ones in a simple way.

1. File Class – Working with Files & Folders

The File class is used to create, delete, and get details about files or directories.

Important:
It does NOT read or write data inside the file — it only manages file properties.

Common Methods
createNewFile() → Create a new file
exists() → Check if file exists
getName() → Get file name
getAbsolutePath() → Get full file path
canRead() → Check read permission
canWrite() → Check write permission
canExecute() → Check execute permission
length() → Get file size
delete() → Delete file
mkdir() → Create folder
mkdirs() → Create multiple folders
list() → List files in directory

2. FileReader – Reading Text Files

FileReader is used to read characters from a file.

It’s a simple class, mainly used for basic file reading.

Common Methods
read() → Read one character
read(char[]) → Read multiple characters
read(char[], off, len) → Read with position
ready() → Check if ready to read
skip(n) → Skip characters
getEncoding() → Get encoding type
close() → Close file

Best for small text files.

3. FileWriter – Writing to Files

FileWriter is the easiest way to write text into a file.

If the file already exists, it will usually overwrite the content.

Common Methods
write(int) → Write single character
write(char[]) → Write character array
write(String) → Write string
write(String, off, len) → Write part of string
append() → Add content at end
flush() → Force write immediately
close() → Close file

Best for simple writing tasks.

4. BufferedReader – Fast Reading

BufferedReader makes reading faster and more efficient by using a buffer.

Instead of reading character-by-character, it reads large chunks at once.

Common Methods
read() → Read one character
readLine() → Read full line
read(char[], off, len) → Read into array
ready() → Check readiness
skip(n) → Skip characters
mark() → Mark current position
reset() → Go back to marked position
close() → Close stream

Best for reading large files efficiently.

5. BufferedWriter – Fast Writing

BufferedWriter improves writing performance by reducing file access operations.

Common Methods
write(int) → Write one character
write(char[]) → Write character array
write(String) → Write string
write(String, off, len) → Write part of string
newLine() → Add a new line
flush() → Force write
close() → Close stream

Best for writing large data efficiently.

6. PrintWriter – Formatted Output

PrintWriter is used when you want clean and formatted output.

It works similar to System.out.print() but writes into files.

Common Methods
print() → Write without newline
println() → Write with newline
printf() → Formatted output
format() → Same as printf
write() → Write raw data
append() → Add data
flush() → Force write
close() → Close writer

Exception Handling Keywords in Java

Hayes vincent — Thu, 02 Apr 2026 05:21:23 +0000

📌 What is an Exception?

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

🔍 Common Examples:
Dividing a number by zero
Accessing a null object
Trying to open a file that doesn’t exist

try Block

The try block is used to wrap code that might throw an exception.

 Syntax:
try {
    // risky code
}
 Example:
try {
    int a = 10 / 0; // Exception occurs
}

Where is it used?
Database operations
File handling
Network calls

catch Block

The catch block handles the exception thrown inside the try block.

Syntax:
catch(Exception e) {
    // handling code
}
 Example:
try {
    int a = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("Cannot divide by zero");
}

Where is it used?
Displaying user-friendly error messages
Preventing program crashes

finally Block

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

 Syntax:
finally {
    // cleanup code
}
 Example:
try {
    int a = 10 / 2;
} catch (Exception e) {
    System.out.println("Error");
} finally {
    System.out.println("Always executed");
}

Real-Time Usage:
Closing database connections
Closing files
Releasing system resources

throw Keyword

The throw keyword is used to manually throw an exception.

Syntax:
throw new Exception("message");
 Example:
public class Main {
    public static void main(String[] args) {
        int num = -5;

        if (num < 0) {
            throw new ArithmeticException("Negative number not allowed");
        }

        System.out.println("Valid number");
    }
}

Where is it used?
Custom validations
Business rules (e.g., age restrictions)

throws Keyword

The throws keyword is used in method signatures to declare exceptions.

Syntax:
void method() throws Exception {
    // code
}
 Example:
import java.io.*;

class Test {
    void readFile() throws IOException {
        FileReader file = new FileReader("test.txt");
    }
}

Where is it used?
File handling
Checked exceptions
Passing responsibility to the caller

** Conclusion**

Exception handling in Java helps you build robust and error-free applications. By using try, catch, finally, throw, and throws, you can manage errors effectively and ensure smooth program execution.

Compile-Time Exception (Checked Exception)and Runtime Exception (Unchecked Exception)

Hayes vincent — Tue, 31 Mar 2026 06:22:33 +0000

*1. Compile-Time Exception (Checked Exception)
*
These are errors that are checked before the program runs (during compilation).

✔ Key Points:
Detected by the compiler
Must be handled using try-catch or throws
If not handled → program will NOT compile

Examples:
File not found
IOException
SQLException
 Example Code:

import java.io.*;

public class Test {
    public static void main(String[] args) throws IOException {
        FileReader file = new FileReader("abc.txt"); // may not exist
    }
}

If you don’t handle it → compile-time error

** 2. Runtime Exception (Unchecked Exception)**

These occur while the program is running.

Key Points:
NOT checked at compile time
Occur due to logic errors
Program compiles successfully but crashes during execution

Examples:
ArithmeticException (divide by zero)
NullPointerException
ArrayIndexOutOfBoundsException
✔ Example Code:
public class Test {
    public static void main(String[] args) {
        int a = 10 / 0; // runtime error
    }
}

Compiles fine, but crashes when running

Main Differences

Feature Compile-Time Exception Runtime Exception
Checked by Compiler JVM (during execution)
Handling required Yes (mandatory) No (optional)
When occurs Before running During running
Cause External issues (file, DB) Logic mistakes
Example IOException NullPointerException

Java Exception Handling:

Hayes vincent — Mon, 30 Mar 2026 17:57:07 +0000

What is an Exception?

An exception is an unwanted or unexpected event that occurs during the execution of a program, which disrupts the normal flow of instructions.

In simple terms:
It is a runtime error that can crash your program if not handled properly.

Real-Life Examples
Dividing a number by zero
Accessing an invalid array index
Opening a file that doesn’t exist
🔹 Exception Hierarchy in Java

All exceptions in Java follow a structured hierarchy under Throwable Class

Object
└── Throwable
├── Exception
│ ├── Checked Exceptions
│ └── Unchecked Exceptions (RuntimeException)
└── Error
🔸 Important Concept
Most exceptions are derived from Exception
Error represents serious system-level problems (not usually handled)
** Types of Exceptions**

1. Checked Exceptions
Checked at compile time
Must be handled using try-catch or throws

Example:

IOException
SQLException

** 2. Unchecked Exceptions (Runtime Exceptions)**
Occur at runtime
Not mandatory to handle

Example:
**
ArithmeticException
NullPointerException
ArrayIndexOutOfBoundsException**

** Try-Catch Block**

The try-catch block is used to handle exceptions and prevent program crashes.

Syntax

try {
    // Code that may cause exception
} catch (ExceptionType e) {
    // Code to handle exception
}
🔹 Example: Handling Arithmetic Exception
public class Test {
    public static void main(String[] args) {
        try {
            int result = 10 / 0; // risky code
        } catch (ArithmeticException e) {
            System.out.println("Cannot divide by zero!");
        }
    }
}

Multiple Catch Blocks

You can handle different types of exceptions separately.

try {
    int arr[] = new int[3];
    arr[5] = 10;
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("Index out of bounds!");
} catch (Exception e) {
    System.out.println("Some error occurred");
}

Finally Block

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

Used for:

Closing files
Releasing resources

try {
    int data = 100 / 10;
} catch (Exception e) {
    System.out.println("Error");
} finally {
    System.out.println("Execution completed");
}

Common Exception Types in Java

** 1. ArithmeticException**

Occurs when an illegal arithmetic operation is performed.

int x = 10 / 0;

2. NullPointerException

Occurs when trying to use a null reference.


String str = null;
System.out.println(str.length());

3. ArrayIndexOutOfBoundsException

Occurs when accessing an invalid array index.


int arr[] = {1, 2, 3};
System.out.println(arr[5]);

**
Why Exception Handling is Important?**

Prevents program crashes
Maintains smooth execution
Improves code reliability
Helps in debugging

Final Thoughts

Exception handling is a core concept in Java that every developer must understand. By using try, catch, and finally, you can manage errors effectively and build robust applications.

Exception and Exception handling:

Hayes vincent — Sat, 28 Mar 2026 06:38:51 +0000

What is an Exception?

An exception is an error that occurs during program execution (runtime) and disrupts the normal flow of the program.

int a = 10;
int b = 0;
int c = a / b;

What is Exception Handling?

Exception handling is a mechanism to handle these runtime errors so that the program does not crash and continues execution.

public class Main {
    public static void main(String[] args) {
        try {
            int a = 10 / 0; // exception
        } catch (ArithmeticException e) {
            System.out.println("Error handled");
        }
    }
}

Output: Error handled

package Learning;

public class ExceptionDemo {



    public static void main(String[]args) {

        ExceptionDemo  ed=new ExceptionDemo ();
        int i=5;
        int j=0;

        ed.multiplay(i, j);
        ed.divide(i, j);
        ed.add(i, j);

    }
    public void multiplay(int i,int j) {
        System.out.println("Mulitplay:" + i*j); 
         }
    public void divide(int i,int j) {
        try {
        System.out.println("Division:" + i/j);  
         }catch(ArithmeticException ed) {
             System.out.println("will check");
         }}

    public void add(int i,int j) {
        System.out.println("Add:"+ i+j);    
         }

}

Strings and methods:

Hayes vincent — Fri, 27 Mar 2026 06:55:56 +0000

STRINGS:

A String is a sequence of characters.
It is an object of Java String Class.
Once created, it cannot be changed.
Any modification creates a new object.

Strings are one of the most commonly used data types in Java. Whether you're building login systems, validating user input, or processing data, understanding how to work with strings is very important.

In this blog, we’ll explore essential string-handling techniques in Java with simple explanations and examples.

Handling Trailing Spaces in Password

When users enter passwords, they may accidentally add spaces at the beginning or end. This can cause login failures even if the password is correct.

To solve this, we use the trim() method.

input.trim().equals(correctPassword);

This removes unwanted spaces before comparing the password.

2. Case-Insensitive Comparison

Sometimes we don’t want uppercase and lowercase letters to affect comparison.

nameFromUI.equalsIgnoreCase(nameFromDB);

This ensures "John" and "john" are treated as the same.

Difference Between == and equals()

This is a very common interview question:

== compares memory location (reference)
equals() compares actual values

Always use equals() when comparing strings.

4. Email Validation (Basic)

We can do a simple check to validate an email:

email.contains("@") && email.contains(".");

Note: This is basic validation. Real-world applications use regex.

Converting String to Integer

Sometimes we need to convert user input into numbers:

int number = Integer.parseInt(str);

This allows us to perform calculations.

Removing Extra Spaces

str.trim();

This removes spaces from both ends of the string.

Counting Occurrences of a Word

We can count how many times a word appears using indexOf():

int count = 0;
int index = 0;

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

Reversing a String

String reversed = "";

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

Palindrome Check

A palindrome reads the same forwards and backwards.

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

Removing Duplicate Characters

String result = "";

for (int i = 0; i < str.length(); i++) {
    char ch = str.charAt(i);
    if (result.indexOf(ch) == -1) {
        result += ch;
    }
}

Extracting Substring from Log

int index = log.indexOf(":");
String message = log.substring(index + 1);

Splitting CSV Data

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

This is useful when working with comma-separated values.

13. Replacing Substrings

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

14. Mobile Number Validation

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

This ensures the number has exactly 10 digits.

Splitting String Using Delimiter

String[] parts = str.split("#");

Understanding string handling in Java is essential for real-world applications like login systems, data validation, and text processing.

By mastering these techniques, you can write cleaner, more efficient, and more reliable Java programs.

package Learning;

public class Leraningjava {
    String nam;
    String nam1;
    String num;
    String inpu ;
    String value;
    String valu;
    String log;

    Leraningjava(String valu ){
        this.nam=nam;
        this.nam1=nam1;
        this.num=num;
        this.inpu=inpu;
        this.value=value;
        this.valu=valu;
        this.log=log;
    }
    Leraningjava(){

    }

    public void display(String nam) {   
        nam=nam.trim();
        System.out.println(nam);
    }

    public void display1(String nam,String nam1) {

        System.out.println(nam.equalsIgnoreCase(nam1));
    }
    public void display2(String num) {

        int n = Integer.parseInt(num);

        System.out.println(n + 10);
    }

    public void display7(String name) {

        String[] words=name.split(" ");
        int count=0;
        for(String word:words) {
            if(word.equals("java")) {
                count++;

            }
        }
        System.out.println(count);
    }

    public void  display4(String inpu) {

        String rev = "";

        for(int i = inpu.length()-1; i >= 0; i--){
            rev += inpu.charAt(i);
        }
        System.out.println(rev);
    }

    public void display9(String value) {
        String reve="";
        for(int i=value.length()-1; i>=0; i--) {
            reve+=value.charAt(i);
        }
        if(value.equals(reve)) {
            System.out.println("pliomdomre");
        }else {
            System.out.println("not pliomfrome");
        }

    }
    public void display8(String log) {


        String result = log.split(":")[1].trim();
        System.out.println(result);
    }

    public void display9() {
        String data = "Vijay,25,Chennai";

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

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

    public void display6() {
        String str = "I love Java programming";

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

        System.out.println(str);
    }

    public void displayy() {
        String str = "apple#banana#mango";

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

        for(String s : arr){
            System.out.println(s);
        }
    }
    public void  duplicate(String valu) {
        String copy="";
        for (int i=0;i< valu.length();i++) {
            char ch = valu.charAt(i);
            if(valu.indexOf(ch)==-1) {

                copy=copy+ch;
            }
        }
        System.out.println(copy);

    }



    public static void main(String[]args) {

        Leraningjava s=new Leraningjava("");
        s.duplicate("aabbccdd");
//      s.display8("Error : file not found");
//      s.display9();
//      s.display6();
//      s.displayy();
        //      s.display0("aabbccdd");

        //      s.display("    hayes    "); 
        //      s.display1("vijay", "Vijay");
        //      s.display2("hi");
        //      s.display3("java is easy to learn java is powerful");
        //      s.display4("java");
        //      s.display9("madam");
        //      
        //      
        //      String obj="java";
        //      String obj1=new String("java");
        //      System.out.println(obj==obj1);
        //      System.out.println(obj.equals(obj1));
        //      
        //      

        //      String str=" Admin123 ";
        //      String si= " Admin123 ";
        //      
        //      
        //      System.out.println(str.contains(si));
        //
        //      

    }

}



















//  String str=" Admin123 ";
//  String s= " Admin123 ";
//  
//  System.out.println(str.charAt(0)); 
//  System.out.println(str.compareTo(s)); 
//  System.out.println(str.compareToIgnoreCase(s));
//  System.out.println(s.codePointAt(0));
//  System.out.println(str.isBlank());
//  System.out.println(str.isEmpty());
//  System.out.println(str.concat(s));
//  System.out.println(str.contains(s));
//  
//  str=str.trim();
//  System.out.println(str);

//  System.out.println(s.equalsIgnoreCase(str));


//      String s1="java";
//      String s2=new String("java");
//      System.out.println(s1==s2);
//      System.out.println(s1.equals(s2));


//  converted string to intger:

//  String num="1230";      
//  int s=Integer.parseInt(num);    
//  System.out.println(s +10);
//  
//  

//      remove start and end:
//      
//      String str=" Welcome to java ";
//      System.out.println(str.trim());
//

what is prime number?

Hayes vincent — Wed, 25 Mar 2026 16:15:15 +0000

A prime number is a number that has only 2 factors:
A number greater than 1 that is divisible only by 1 and itself.

java:

package Learning;

import java.util.Scanner;

public class primenum {
    public static void main(String[]args) {
        Scanner s=new Scanner(System.in);
        System.out.println("Enter the number:");
        int n=s.nextInt();
        boolean prime=true;
        if(n<=1) prime=false;
        for(int i=2;i<=Math.sqrt(n);i++) {
            if(n%2==0) {
                prime=false;
                break;
            }
        }
        System.out.println(prime ?"prime" : "not pime");
    }

}

JavaScript:

let n = Number(prompt("Enter a number:"));
let isPrime = true;

if (n <= 1) {
    isPrime = false;
} else {
    for (let i = 2; i < n; i++) {
        if (n % i === 0) {
            isPrime = false;
            break;
        }
    }
}

console.log(isPrime ? "Prime" : "Not Prime");

Python:

num=int(input("enter a number: "))
div=2
flag=True
while div<=num/2:
    if num%div==0:
        flag=False
        break
    div+=1
if flag==True:
    print("This number is Prime")
else:
    print("This number is not Prime")