DEV Community: KIRAN RAJ

Comparable Interface in Java

KIRAN RAJ — Mon, 20 Apr 2026 17:01:53 +0000

Comparable Interface in Java

In Java, the Comparable interface is used to compare objects and define their natural ordering.

Examples:

Comparing students based on marks

Comparing products based on price

Sorting strings alphabetically

Why Do We Need Comparable?

Primitive values like int or double can be compared easily.
But for custom objects like Student or Employee, Java does not know how to compare them by default.

So, we define the comparison logic using the Comparable interface.

Definition

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

The key method is compareTo().

*How compareTo() Works
*
Returns a negative value → current object is smaller

Returns 0 → both objects are equal

Returns a positive value → current object is greater

This is the basis for sorting.

Example: Sorting Students by Marks

import java.util.*;

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

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

    public int compareTo(Student s) {
        return this.marks - s.marks; // ascending order
    }
}

public class Main {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();

        list.add(new Student("A", 80));
        list.add(new Student("B", 60));
        list.add(new Student("C", 90));

        Collections.sort(list);

        for (Student s : list) {
            System.out.println(s.name + " " + s.marks);
        }
    }
}

Output:

B 60
A 80
C 90

Key Points

Comparable defines natural (default) ordering

It is implemented inside the class

Collections.sort() automatically uses it

You must override compareTo()

Comparable vs Comparator

Comparable	Comparator
Implemented inside the class	Implemented in a separate class
Only one sorting logic	Multiple sorting logics possible
Uses compareTo()	Uses compare()

Simple Analogy

Comparable: the object decides how it should be compared
Comparator: an external logic decides how objects are compared

Final Line

The Comparable interface allows you to define a default sorting behavior for your objects.

ArrayList Methods in Java

KIRAN RAJ — Sun, 19 Apr 2026 18:15:27 +0000

ArrayList Methods in Java

When I first started learning Java, arrays were a bit confusing because of fixed size. Then I came across ArrayList, and it felt much easier to use.

Basically, ArrayList is like an improved version of array. You don’t need to decide the size before. It grows when you add data.

What is ArrayList?

ArrayList is a class in Java used to store multiple values. It allows duplicate values and keeps order.

In simple terms,
it is just a dynamic array.

Creating an ArrayList

import java.util.ArrayList;

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

Methods I used the most

add()

This is the first method everyone uses. It just adds elements.

list.add("Apple");
list.add("Banana");

Also we can add using index:

list.add(1, "Mango");

get()

Used to take value from list.

System.out.println(list.get(0));

Index starts from 0, same like array.

set()

If you want to change something:

list.set(1, "Orange");

It replaces the old value.

remove()

Used to delete.

list.remove(0);
list.remove("Apple");

Both ways will work.

size()

To know how many elements are there:

System.out.println(list.size());

contains()

Sometimes we need to check if item is present.

System.out.println(list.contains("Banana"));

isEmpty()

Simple check:

System.out.println(list.isEmpty());

clear()

Deletes everything.

list.clear();

Looping

Normal for loop:

for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));
}

For-each (easy one):

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

Small program I tried

import java.util.ArrayList;

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

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

        list.add("Tea");
        list.add("Coffee");
        list.add("Boost");

        list.remove("Coffee");

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

Final

ArrayList is very useful. Once you start using it, you won’t feel like going back to arrays for most cases.

At first I just memorized methods, but later when I practiced, it became easy.

That’s it. Nothing big. Just practice

ArrayList vs LinkedList in Java

KIRAN RAJ — Sat, 18 Apr 2026 04:53:43 +0000

ArrayList vs LinkedList in Java

I used to think ArrayList and LinkedList are basically the same thing.
Because when you’re coding, both feel similar — you just call add(), get(), and move on.

But after using them a bit more, the difference starts to show. Not immediately, but when the list gets bigger or when you keep modifying it.

ArrayList

ArrayList is kind of like a normal array, but it grows automatically.

So everything is stored in order, one next to another. Because of that, accessing elements is quick.
If you know the index, you’ll get the value instantly.

The only thing is, inserting or deleting in between isn’t that smooth.
Other elements need to shift, so it takes some extra work internally.

ArrayList<Integer> list = new ArrayList<>();
list.add(10);
list.add(20);
System.out.println(list.get(1));

LinkedList

LinkedList works differently. It doesn’t store elements in a continuous way.

Each element is connected to the next one (and previous too). So it’s more like a chain.

Because of this, inserting or removing elements is easier — it just updates the links.
But accessing is slower, since it has to go step by step.

LinkedList<Integer> list = new LinkedList<>();
list.add(10);
list.add(20);
System.out.println(list.get(1));

What I understood

Instead of remembering all details, I just think like this:

If I need fast access → I use ArrayList
If I keep adding/removing → LinkedList makes more sense

That’s how I usually decide.

In practice

Most of the time, I end up using ArrayList. It’s simple and works fine for general cases.

LinkedList is useful, but I don’t reach for it unless there’s a clear reason.

Final note
Both are part of the same interface, but they behave differently inside.

So choosing one depends on what your program is doing more — reading or modifying.

Java Collections Framework

KIRAN RAJ — Thu, 16 Apr 2026 19:37:10 +0000

Java Collections Framework

Java Collections Framework is used to store and manage a group of objects in an easy way.

Instead of creating everything from scratch, Java already gives ready-made classes like ArrayList, HashSet, and HashMap. We can directly use them.

1. What is a Collection?

A collection means a group of data.
For example, storing multiple names or numbers together.

2. Why do we use Collections?

Before collections:

If we want to store many values, we had to create many variables → confusing

Then arrays came → better, but still not perfect

Problems with arrays:

Size is fixed

Memory can be wasted

Not flexible

So Java introduced Collections to solve these issues.

3. Advantages (Simple way)

No need to write your own data structures

Works faster (already optimized)

Can reuse in many programs

Easy to learn (same pattern – List, Set, Map)

Code looks clean and simple

Size can increase or decrease anytime

Extra help methods like sorting and searching available

Java File Handling

KIRAN RAJ — Tue, 07 Apr 2026 15:51:04 +0000

Java File Handling

What I understood about File Handling

When I started learning Java, one thing I noticed is that data inside a program does not stay forever. Once the program stops, everything is gone. Because of that, we use files to store data.

So, file handling is basically working with files like creating them, writing something into them, reading the content later, and sometimes deleting them.

File Class (Basic Idea)

In Java, we usually use the File class from the java.io package. It is mainly used to refer to a file path.

One small confusion I had at first was thinking it creates a file directly. But actually, it just creates an object that points to a location.

import java.io.File;

public class Test {
    public static void main(String[] args) {
        File myFile = new File("data.txt");
        System.out.println("Just created a reference, not the actual file");
    }
}

Creating the File

To actually create the file in the system, we use createNewFile().

import java.io.File;
import java.io.IOException;

public class FileCreate {
    public static void main(String[] args) {
        try {
            File myFile = new File("data.txt");

            if (myFile.createNewFile()) {
                System.out.println("New file created");
            } else {
                System.out.println("File already exists");
            }

        } catch (IOException e) {
            System.out.println("Something went wrong while creating file");
        }
    }
}

Writing into the File

To write something into the file, we can use FileWriter. One important thing is to close it after writing.

import java.io.FileWriter;

public class FileWrite {
    public static void main(String[] args) {
        try {
            FileWriter writer = new FileWriter("data.txt");

            writer.write("This is just a practice example.");
            writer.close();

            System.out.println("Writing done");

        } catch (Exception e) {
            System.out.println("Error while writing");
        }
    }
}

Reading the File

For reading, I used Scanner because it is easy to understand. It reads line by line.

import java.io.File;
import java.util.Scanner;

public class FileRead {
    public static void main(String[] args) {
        try {
            File myFile = new File("data.txt");
            Scanner sc = new Scanner(myFile);

            while (sc.hasNextLine()) {
                System.out.println(sc.nextLine());
            }

            sc.close();

        } catch (Exception e) {
            System.out.println("Could not read the file");
        }
    }
}

Deleting the File

If the file is not needed, we can delete it using delete().

import java.io.File;

public class FileDelete {
    public static void main(String[] args) {
        File myFile = new File("data.txt");

        if (myFile.delete()) {
            System.out.println("File deleted successfully");
        } else {
            System.out.println("Delete failed");
        }
    }
}

Streams (Just Basic Understanding)

While reading about this, I found that Java uses streams internally.

Byte streams - used for images or other binary data

Character streams - used for text

Some classes I came across are FileReader and FileWriter.

Errors I Faced

While trying these programs, I got errors like file not found and sometimes permission issues. Using try-catch helped me handle those errors.

Conclusion (My Understanding)

File handling is simple once we practice it. At first it felt confusing, but after trying examples, it became clear how Java works with files.

I feel practicing small programs is the best way to understand this topic.

Java File Handling

KIRAN RAJ — Mon, 06 Apr 2026 05:46:22 +0000

What is File Handling?

File Handling in Java is the process of creating, reading, writing, updating, and deleting files using Java programs.

👉 It helps programs to store data permanently instead of only in memory.

📁 What is a File?

A file is a collection of data stored in a storage device (like hard disk).

👉 Examples:

notes.txt
data.pdf
image.jpg

📂 What is a Directory (Folder)?

A directory (folder) is a container used to store files and other folders.

👉 Example:

Documents/
   ├── notes.txt
   ├── resume.pdf
   └── Images/

⚙️ What is the File Class?

The File class in Java is used to:

Create files
Check file properties
List files and folders
Delete files

👉 It belongs to:

java.io package

🔑 Important Methods (Definition)

createNewFile() → Creates a new file
listFiles() → Lists all files in a directory
isFile() → Checks if it is a file
isDirectory() → Checks if it is a folder
getName() → Returns file/folder name
delete() → Deletes a file

🔤 String Methods Used in File Handling

👉 File handling often uses String methods:

toLowerCase() → ignore case
endsWith() → check file type
substring() → extract extension
lastIndexOf() → find extension position

💾 Why File Handling is Important?

Store data permanently
Read/write application data
Work with system files
Used in real-world apps (logs, configs, reports)

Short Conclusion

File handling is a core concept in Java that allows developers to interact with system files and build practical applications.

Java Exception Handling – 20 Scenarios Q&A

KIRAN RAJ — Sat, 04 Apr 2026 04:29:27 +0000

Java Exception Handling – 20 Real-Time Scenarios Explained

Introduction

Exception handling in Java helps developers manage runtime errors and keep applications stable. Let’s understand all key concepts through real-time scenarios.

1.What is an Exception?

While running your app, a calculation crashes.

✔ Answer: Runtime error

2.How to Handle Exceptions?

You want to prevent app crash.

✔ Answer: Use try, catch, and throw

3.Root Class of Exceptions

You want to know the parent of all exceptions.

✔ Answer: Throwable

4.Code That Always Runs

You want cleanup code to always execute.

✔ Answer: finally

5.Divide by Zero

User enters 0 in division.

✔Answer: ArithmeticException

6.Checked Exception

File reading operation.

✔ Answer: IOException

7.Not Handling Exception

You ignore exception.

✔Answer: Program terminates

8.Correct Block Order

Writing try-catch-finally.

✔ Answer: try → catch → finally

9.Manually Throw Exception

Validate input and throw error.

✔ Answer: throw

10. Declare Exception

Inform method may throw exception.

✔ Answer: throws

11.Arithmetic Exception Handling

Division by zero inside try.

✔ Answer: "Error" printed

12.Null Value Access

Access method on null.

✔ Answer: "Handled" printed

13.Wrong Catch Order

Parent class before child class.

✔ Answer: Wrong order

14.Array Index Error

Access invalid index.

✔ Answer: "Out of bounds"

15.System.exit() Case

Program exits forcefully.

✔ Answer: finally will NOT execute

16.Try Without Catch

Writing only try block.

✔ Answer: Only valid with finally

17.Unchecked Exception

Runtime error (null access).

✔ Answer: NullPointerException

18.Exception Propagation

Method doesn’t handle exception.

✔ Answer: Passed to caller

19.Who Handles Exception?

Which block manages error.

✔ Answer: catch

20.Purpose of Finally

Cleanup operations needed.

✔ Answer: Execute cleanup code

21.Student Result Validation

Marks must be between 0–100

if(marks < 0 || marks > 100){
    throw new IllegalArgumentException("Invalid marks");
}

22: Checked vs Unchecked

👉 Use:

Checked → external issues

Unchecked → coding mistakes

23.Finally Not Executed

System.exit(0) → finally skip

Final Summary

Exception = runtime error

try-catch = handle

finally = cleanup

throw = create

throws = declare

propagation = pass to caller

Exception Handling In Java(Complete Guide with Examples)

KIRAN RAJ — Fri, 03 Apr 2026 04:35:31 +0000

Exception Handling in Java

- Introduction

Exception handling is a powerful mechanism in Java that helps developers manage runtime errors and maintain the normal flow of applications. Instead of crashing the program, Java allows you to handle unexpected situations gracefully using structured blocks like try, catch, and finally.

1.What is an Exception?

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

👉 Example:

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

2.Types of Exceptions

✅ Checked Exceptions

Checked at compile time
Must be handled using try-catch or throws
Example: IOException, SQLException

❌ Unchecked Exceptions

Occur at runtime
Not mandatory to handle
Example: NullPointerException, ArithmeticException

3.Important Keywords

Wraps code that may cause an exception.

catch

Handles the exception.

finally

Always executes (except when JVM stops).

throw

Used to explicitly throw an exception.

throws

Declares exceptions in a method signature.

4.Order of Execution

Correct order:

try → catch → finally

5.Common Exceptions

Divide by zero → ArithmeticException
Null value access → NullPointerException
Invalid array index → ArrayIndexOutOfBoundsException

6.Exception Propagation

Exception propagation means passing an exception from one method to another until it is handled.

void method1() {
    int x = 10 / 0;
}

void method2() {
    method1();
}

void method3() {
    try {
        method2();
    } catch (Exception e) {
        System.out.println("Handled");
    }
}

Code Examples

7.Handling Exception

try {
    int x = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("Error");
}

8.Null Handling

try {
    String s = null;
    System.out.println(s.length());
} catch (Exception e) {
    System.out.println("Handled");
}

9.Throw Example

if(marks < 0 || marks > 100){
    throw new IllegalArgumentException("Invalid marks");
}

10.SpecialCase:System.exit()

try {
    System.exit(0);
} finally {
    System.out.println("Finally");
}

Output: Finally will NOT execute

Reason: JVM stops immediately.

11. Purpose of Finally Block

Used for cleanup operations:

Closing files

Releasing resources

Closing database connections

12.Important Rules

try cannot exist alone

Must be followed by catch or finally

catch blocks must be ordered from specific → general

Parent class (Exception) should come last

13.Quick Summary

Exception = Runtime error

try-catch = Handle errors

finally = Cleanup

throw = Create exception

throws = Declare exception

Propagation = Passing exception to caller

14.Conclusion

Exception handling is essential for building robust Java applications. By using proper handling techniques, developers can prevent crashes, improve user experience, and write clean, maintainable code.

Java Exception Handling:Understanding throw vs throws

KIRAN RAJ — Wed, 01 Apr 2026 18:02:03 +0000

Exception Handling in Java: throw vs throws

When writing Java programs, errors can happen anytime — like dividing by zero, invalid input, or file issues.
To handle these situations properly, Java provides exception handling.

Two important keywords in Java exception handling are:

throw
throws

1.What is an Exception?

An exception is an unwanted event that stops the normal flow of a program.

Example:

int a = 10;
int b = 0;
int result = a / b; // ArithmeticException

2.What is throw in Java?

throw is used to manually create and throw an exception.

It is used inside a method.

✅ Syntax:

throw new ExceptionType("Error message");

✅ Example:

public class Test {
    public static void main(String[] args) {
        int age = 15;

        if(age < 18){
            throw new ArithmeticException("Not eligible to vote");
        }

        System.out.println("Eligible");
    }
}

Explanation:

If condition is true → exception is thrown manually

Program stops unless handled

What is throws in Java?

throws is used to declare exceptions that a method might throw.

It is used in method signature.

✅ Syntax:

returnType methodName() throws ExceptionType

✅ Example:

import java.io.*;

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

    public static void main(String[] args) {
        try {
            readFile();
        } catch(IOException e){
            System.out.println("File not found");
        }
    }
}

Explanation:

throws tells the compiler: "This method may cause an exception"

The caller must handle it using try-catch

4. Difference Between throw and throws

Feature throw throws

Usage Used to throw exception Used to declare exception
Location Inside method Method signature
Number Only one exception at a time Multiple exceptions allowed
Keyword Type Statement Declaration

💡 Real-Life Analogy

throw 👉 You actually throw a ball

throws 👉 You warn someone that you may throw a ball

5.When to Use?

✔ Use throw

When you want to create custom error conditions

For validation (age, input, etc.)

✔ Use throws

When method might cause checked exceptions

When you want caller to handle exception

Advantages Of Exception Handling

KIRAN RAJ — Mon, 30 Mar 2026 07:35:22 +0000

Advantages of Exception Handling in Java

Exception handling is a powerful mechanism in Java that allows developers to manage runtime errors efficiently. Instead of crashing the program, it helps maintain the normal flow of execution and improves the overall reliability of applications.

1. Maintains Normal Flow of Program

Without exception handling, a program stops abruptly when an error occurs. Using try-catch, you can handle errors and continue execution smoothly.

try {
    int result = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("Cannot divide by zero");
}
System.out.println("Program continues...");

2. Prevents Program Crashes

Exception handling prevents unexpected termination of programs. It catches runtime errors and handles them gracefully.

👉 Example:

Without handling → Program crashes
With handling → Error message shown, program continues

3. Separates Error Handling Code

It separates normal code from error-handling code, making programs more readable and maintainable.

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

4. Improves Code Readability

When exceptions are handled properly, the code becomes easier to understand and debug.

Clean structure
Organized logic
Better debugging

5. Allows Custom Error Messages

Developers can display meaningful error messages instead of confusing system errors.

catch (NumberFormatException e) {
    System.out.println("Please enter a valid number");
}

🔹 6. Supports Multiple Exception Types

Java allows handling different exceptions separately using multiple catch blocks.

try {
    int arr[] = new int[5];
    arr[10] = 50;
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("Array index error");
} catch (Exception e) {
    System.out.println("General error");
}

7. Ensures Resource Cleanup

The finally block ensures that important resources (like files, database connections) are always closed.

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

8. Enables Robust and Secure Applications

Exception handling helps build strong applications that can handle unexpected situations without failing.

9. Helps in Debugging

Using e.printStackTrace() or logs, developers can easily identify where the error occurred.

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

Exception Handling In Java

KIRAN RAJ — Sat, 28 Mar 2026 06:08:18 +0000

Introduction

While writing Java programs, errors are inevitable. These errors, known as exceptions, can occur during program execution and may cause your application to crash. Exception handling in Java helps you manage these errors gracefully, ensuring your program continues to run smoothly without unexpected termination.

What is Exception Handling?

Exception handling is a mechanism in Java used to handle runtime errors so that the normal flow of the application can be maintained.

Instead of stopping the program abruptly, Java provides a structured way to detect and handle errors.

Why is Exception Handling Important?

Prevents program crashes
Improves user experience
Maintains normal program flow
Helps in debugging and error tracking

Basic Syntax of Exception Handling

Java uses five main keywords for exception handling:

try {
    // Code that may throw an exception
} catch (Exception e) {
    // Code to handle the exception
} finally {
    // Code that will always execute
}

Understanding the Keywords

1. try

The try block contains code that might throw an exception.

try {
    int result = 10 / 0;
}

2. catch

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

catch (ArithmeticException e) {
    System.out.println("Cannot divide by zero!");
}

Real-Life Example

Imagine withdrawing money from an ATM:

If your balance is insufficient, the system shows an error message.
The machine doesn’t crash — it handles the error.

This is exactly how exception handling works in Java.

Conclusion

Exception handling is a powerful feature in Java that ensures your program runs reliably even when errors occur. By using try, catch, and finally blocks effectively, you can build robust and user-friendly applications.

Mastering exception handling is essential for writing professional and production-ready Java code.

String Methods Based Programs

KIRAN RAJ — Fri, 27 Mar 2026 06:36:09 +0000

1. Remove trailing space (password issue)

The trim() method removes unwanted spaces from the beginning and end of a string. It is commonly used to clean user input.

String pwd = " Admin123 ";
pwd = pwd.trim(); 
System.out.println(pwd);

2. Compare username safely (ignore case)

The equalsIgnoreCase() method compares two strings while ignoring case differences. It is useful for username validation.

String s1 = "Vijay";
String s2 = "vijay";
System.out.println(s1.equalsIgnoreCase(s2));

3. == vs equals()

== compares memory references, whereas equals() compares actual values. This is a very important concept for interviews.

String s1 = "Java";
String s2 = new String("Java");
System.out.println(s1 == s2);        // false (memory check) 
System.out.println(s1.equals(s2));   // true (value check)

4. Check email contains '@' and '.'

The contains() method checks whether a string contains a specific substring. It is useful in validations like email checking.

String email = "test@gmail.com";
if(email.contains("@") && email.contains(".")) {        System.out.println("Valid");
}
else {
 System.out.println("invalid");
}

5. Convert String to int

The Integer.parseInt() method converts a string into an integer. It is commonly used in form input processing.

String num = "12345";
int n = Integer.parseInt(num);
System.out.println(n+20);

6. Remove spaces only start & end

The split() method divides a string into multiple parts based on a delimiter. It is widely used in CSV parsing and data processing.

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

7. Count "Java" occurrences

The length() method returns the length of a string. It is very useful when working with loops.

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

String[] words = str.split(" ");
for(String w : words){
    if(w.equals("Java")) count++;
    }
System.out.println(count);

8. Reverse string (without StringBuilder)

The charAt() method returns the character at a specific index. It is used for string traversal.

String str = "Java";
String rev = "";

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

## 9. Check palindrome

The indexOf() method returns the position of a character or substring. It is useful for checking duplicates.

String str = "madam";
String rev = "";

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

if(str.equals(rev))
    System.out.println("Palindrome:"+rev);
else
 System.out.println("Not Palindrome");

10. Remove duplicate characters

The equals() method compares the actual content of two strings. It is commonly used in palindrome checks.

String str = "aabbccdd";
String result = "";

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

11. Extract message from log

The replace() method replaces one part of a string with another. It is useful for modifying text.

String log = "ERROR: File not found";

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

12. CSV extract

The matches() method uses regular expressions to validate patterns. It is commonly used for mobile number or password validation.

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]);

13. Replace word

The + operator is used to combine strings. It is often used in building new strings like in reverse logic.

String str = "I love Java programming";
str = str.replace("Java", "Spring Boot");

System.out.println(str);

14. Validate mobile number (10 digits)

After using split(), array indexing is used to access individual values.

String num = "9876543210";

if(num.matches("\\d{10}")){
   System.out.println("Valid");
}else{
   System.out.println("Invalid");
}

15. Split string

Loops are used to traverse strings. This is the base for solving most string problems.

String str = "apple#banana#mango";

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

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