Coder Legion - Recent posts tagged javaprogramming

My Journey as a Java Developer: Learning, Building, and Solving Problems Through Code

Sat, 10 Oct 2026 14:52:56 +0000

Software development is more than writing code. It is about understanding problems, finding practical solutions, and building applications that make people's work easier. As a Java Developer, I enjoy exploring how software works behind the scenes, improving my programming skills, and turning ideas into useful applications.

My journey in development is driven by curiosity, continuous learning, and the desire to become better at what I do every day.

Why I Chose Java Development

Java is one of the technologies that interests me because of its versatility, object-oriented approach, and ability to support reliable and scalable applications. From backend systems to enterprise-level software, Java provides a strong foundation for building applications that can grow and adapt to different requirements.

What I enjoy most is the process of understanding how a problem works and figuring out how to solve it through code. Sometimes the solution is simple, while other times it requires breaking the problem into smaller parts, testing different approaches, and learning from mistakes.

For me, programming is not just about making something work. It is about understanding why it works and finding ways to make it better.

My Approach to Writing Code

I believe that good software starts with clear thinking and well structured code. Writing code that works is important, but writing code that other developers can understand, maintain, and improve is equally valuable.

As I continue developing my skills, I focus on several important areas:

Java programming: Understanding core concepts and applying them to practical problems.
Object-oriented programming: Using classes, objects, encapsulation, inheritance, and polymorphism to organize code effectively.
Backend development: Learning how application logic, databases, and APIs work together to deliver useful functionality.
Problem-solving: Breaking complex challenges into manageable tasks and exploring efficient solutions.
Clean code: Writing readable, maintainable code that makes future improvements easier.

These areas help me build a stronger foundation and approach development tasks with more confidence.

Learning Beyond the Basics

Technology continues to evolve, and I believe developers should remain curious and open to learning. There is always something new to explore, whether it is a better programming technique, a different architectural approach, or a tool that improves the development process.

I enjoy experimenting with code, exploring new concepts, and learning from both successful projects and mistakes. Debugging is also an important part of this process. When something does not work as expected, I try to understand the root cause instead of simply looking for a quick fix.

Every bug can teach you something, and every project gives you an opportunity to improve.

I also recognize the importance of understanding the fundamentals before depending too heavily on frameworks or tools. Strong fundamentals make it easier to learn new technologies and adapt to different project requirements.

Building Reliable and Scalable Applications

One of my main interests is developing applications that are reliable, efficient, and easy to maintain. A good application should solve the immediate problem while also being flexible enough to support future changes.

This requires more than writing individual methods or classes. It involves thinking about application structure, data handling, error management, performance, and how different components communicate with each other.

As a Java Developer, I want to keep strengthening my understanding of backend architecture, database integration, REST APIs, testing, and software design principles. These skills are valuable for building applications that can handle real-world requirements.

I believe the best way to improve is to put knowledge into practice. Reading documentation and studying examples are useful, but building projects helps turn theoretical concepts into practical experience.

Challenges Are Part of the Process

Every developer faces challenges. Sometimes a problem seems straightforward until you start implementing the solution. Other times, an unexpected error forces you to rethink your approach.

I see these situations as opportunities to develop better problem-solving habits. Instead of giving up when something becomes difficult, I try to investigate the issue, test possible solutions, and understand what went wrong.

This mindset helps me become more patient and systematic when approaching technical problems.

Becoming a better developer is not about knowing everything. It is about being willing to learn, adapt, and keep improving.

Growing With the Developer Community

Software development is a continuous learning journey, and the developer community plays an important role in that process. Developers learn from sharing experiences, discussing different approaches, and helping one another overcome challenges.

I enjoy connecting with people who are passionate about technology, exploring their ideas, and learning how they approach software engineering problems.

I also believe that sharing knowledge is a useful way to reinforce what we learn. Explaining a concept, documenting a solution, or discussing a coding challenge can help both the writer and the reader gain a better understanding.

Through platforms like CoderLegion, I hope to share my experiences, exchange ideas, and connect with other developers who enjoy building useful things with technology.

My Goals as a Java Developer

My goal is to continue growing as a software developer by strengthening my Java knowledge, improving my problem-solving abilities, and gaining more practical experience in building real-world applications.

I want to explore better software design practices, understand scalable backend systems, and develop solutions that are useful, reliable, and maintainable.

I know that becoming a skilled developer takes time, practice, and consistency. There will always be new technologies to learn and new challenges to solve, and that is part of what makes this field interesting to me.

Final Thoughts

My journey as a Java Developer is built around learning, experimenting, solving problems, and creating better software. I enjoy the challenge of turning ideas into working applications and discovering new ways to write efficient, maintainable code.

I do not believe growth happens overnight. It comes from consistent effort, practical experience, curiosity, and the willingness to learn from mistakes.

I look forward to continuing this journey, building meaningful projects, sharing what I learn, and connecting with developers who share the same passion for technology.

Always learning, always building, and always looking for a better way to solve problems.

What if your wardrobe could teach you Sorting Algorithms?👗

Wed, 23 Sep 2026 05:05:37 +0000

You open your wardrobe.

T-shirts mixed with jeans.
Dresses hiding behind hoodies.
Everything is everywhere. 😭

You need to sort it.

But here's the catch...

There isn't just one way to organize a messy wardrobe.

And that's exactly what happens in DSA.

An unsorted array is basically a messy wardrobe.
The goal is the same: put everything in order.

But every sorting algorithm has its own strategy.

Let's meet them. 👀

1. Bubble Sort — Compare the neighbors

Imagine checking your clothes two at a time.

If the two neighboring clothes are in the wrong order:

🔄 Swap them.

Then move to the next pair.

Keep doing this until the largest item gradually reaches the end.

That's why it's called Bubble Sort—elements "bubble" toward their correct positions.

💻 Java

public class BubbleSort {

    public static void main(String[] args) {

        int[] arr = {5, 3, 8, 4, 2};

        for (int i = 0; i < arr.length - 1; i++) {

            for (int j = 0; j < arr.length - i - 1; j++) {

                if (arr[j] > arr[j + 1]) {

                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }

        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

Time: O(n²)
Space: O(1)

🧠 Remember:
Bubble = Compare neighbors + Swap

🎯 2. Selection Sort — Find the right one

Now you change your strategy.

Instead of repeatedly comparing neighbors, you look through the entire unsorted section.

You find the smallest item.

Then...

📍 Put it in its correct position.

Repeat.

It's like saying:

"First, I'll find the smallest shirt. Then the next smallest. Then the next..."

That's Selection Sort.

💻 Java

public class SelectionSort {

    public static void main(String[] args) {

        int[] arr = {64, 25, 12, 22, 11};

        for (int i = 0; i < arr.length - 1; i++) {

            int minIndex = i;

            for (int j = i + 1; j < arr.length; j++) {

                if (arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }

            int temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }

        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

Time: O(n²)
Space: O(1)

🧠 Remember:
Selection = Find minimum + Place it

🃏 3. Insertion Sort — Insert it where it belongs

Now imagine arranging clothes one by one.

You already have a few clothes arranged.

You pick the next one.

Look at the sorted section.

"Where does this belong?"

You make space and insert it there.

Just like arranging playing cards in your hand. 🃏

That's Insertion Sort.

💻 Java

public class InsertionSort {

    public static void main(String[] args) {

        int[] arr = {5, 3, 4, 1, 2};

        for (int i = 1; i < arr.length; i++) {

            int key = arr[i];
            int j = i - 1;

            while (j >= 0 && arr[j] > key) {

                arr[j + 1] = arr[j];
                j--;
            }

            arr[j + 1] = key;
        }

        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

Best: O(n)
Worst: O(n²)
Space: O(1)

🧠 Remember:
Insertion = Take + Shift + Insert

✂️ 4. Merge Sort — Don't organize everything at once

You look at the wardrobe.

"There are WAY too many clothes. I'm splitting this." 😭

Divide the clothes into two sections.

Then divide those sections again.

Keep dividing until each section is tiny.

Now sort them.

Then merge the sorted sections back together.

Divide → Sort → Merge

That's Merge Sort.

💻 Java

public class MergeSort {

    static void mergeSort(int[] arr, int left, int right) {

        if (left < right) {

            int mid = left + (right - left) / 2;

            mergeSort(arr, left, mid);
            mergeSort(arr, mid + 1, right);

            merge(arr, left, mid, right);
        }
    }

    static void merge(int[] arr, int left, int mid, int right) {

        int[] temp = new int[right - left + 1];

        int i = left;
        int j = mid + 1;
        int k = 0;

        while (i <= mid && j <= right) {

            if (arr[i] <= arr[j]) {
                temp[k++] = arr[i++];
            } else {
                temp[k++] = arr[j++];
            }
        }

        while (i <= mid) {
            temp[k++] = arr[i++];
        }

        while (j <= right) {
            temp[k++] = arr[j++];
        }

        for (int x = 0; x < temp.length; x++) {
            arr[left + x] = temp[x];
        }
    }

    public static void main(String[] args) {

        int[] arr = {8, 3, 5, 4, 7, 6, 1, 2};

        mergeSort(arr, 0, arr.length - 1);

        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

Time: O(n log n)
Space: O(n)

🧠 Remember:
Merge = Divide + Sort + Merge

⚡ 5. Quick Sort — Choose a pivot

Now you want a faster strategy.

You pick one item as your pivot.

Everything smaller goes to one side.

Everything larger goes to the other.

Now you've created smaller problems.

Repeat the same process.

That's Quick Sort.

💻 Java

public class QuickSort {

    static void quickSort(int[] arr, int low, int high) {

        if (low < high) {

            int pivotIndex = partition(arr, low, high);

            quickSort(arr, low, pivotIndex - 1);
            quickSort(arr, pivotIndex + 1, high);
        }
    }

    static int partition(int[] arr, int low, int high) {

        int pivot = arr[high];

        int i = low - 1;

        for (int j = low; j < high; j++) {

            if (arr[j] < pivot) {

                i++;

                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }

        int temp = arr[i + 1];
        arr[i + 1] = arr[high];
        arr[high] = temp;

        return i + 1;
    }

    public static void main(String[] args) {

        int[] arr = {10, 7, 8, 9, 1, 5};

        quickSort(arr, 0, arr.length - 1);

        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

Average: O(n log n)
Worst: O(n²)
Space: O(log n) average recursion stack

🧠 Remember:
Quick = Pivot + Partition

🌳 6. Heap Sort — Priority comes first

Now imagine you want the highest-priority clothing item to always be easy to find.

You organize the items using a special structure:

🌳 Heap

The largest element can stay at the top of a Max Heap.

Take it.

Put it in its final position.

Restore the heap.

Repeat.

That's Heap Sort.

💻 Java

public class HeapSort {

    static void heapSort(int[] arr) {

        int n = arr.length;

        // Build Max Heap
        for (int i = n / 2 - 1; i >= 0; i--) {
            heapify(arr, n, i);
        }

        // Move maximum to the end
        for (int i = n - 1; i > 0; i--) {

            int temp = arr[0];
            arr[0] = arr[i];
            arr[i] = temp;

            heapify(arr, i, 0);
        }
    }

    static void heapify(int[] arr, int n, int i) {

        int largest = i;

        int left = 2 * i + 1;
        int right = 2 * i + 2;

        if (left < n && arr[left] > arr[largest]) {
            largest = left;
        }

        if (right < n && arr[right] > arr[largest]) {
            largest = right;
        }

        if (largest != i) {

            int temp = arr[i];
            arr[i] = arr[largest];
            arr[largest] = temp;

            heapify(arr, n, largest);
        }
    }

    public static void main(String[] args) {

        int[] arr = {12, 11, 13, 5, 6, 7};

        heapSort(arr);

        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

Time: O(n log n)
Space: O(1)

🧠 Remember:
Heap = Build heap + Extract repeatedly

🔢 7. Counting Sort — Stop comparing. Start counting.

Here's where things get interesting.

Imagine your clothes can only have sizes:

1, 2, 3, 4, 5

Instead of comparing every item...

You simply count how many times each size appears.

That's the idea behind Counting Sort.

💻 Java

public class CountingSort {

    static void countingSort(int[] arr) {

        int max = arr[0];

        for (int num : arr) {
            if (num > max) {
                max = num;
            }
        }

        int[] count = new int[max + 1];

        for (int num : arr) {
            count[num]++;
        }

        int index = 0;

        for (int i = 0; i < count.length; i++) {

            while (count[i] > 0) {

                arr[index] = i;
                index++;

                count[i]--;
            }
        }
    }

    public static void main(String[] args) {

        int[] arr = {4, 2, 2, 8, 3, 3, 1};

        countingSort(arr);

        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

Time: O(n + k)
Space: O(k)

🧠 Remember:
Counting = Count frequencies

⚠️ Works well when the range of values is reasonably small.

📚 8. Radix Sort — One digit at a time

Now imagine numbers are your clothes.

Instead of comparing the whole number...

You organize them digit by digit.

First:

➡️ Ones digit

Then:

➡️ Tens digit

Then:

➡️ Hundreds digit

For example:

170, 45, 75, 90, 802, 24, 2, 66

The algorithm gradually builds the final ordering.

That's Radix Sort.

💻 Java

public class RadixSort {

    static void radixSort(int[] arr) {

        int max = arr[0];

        for (int num : arr) {
            if (num > max) {
                max = num;
            }
        }

        for (int exp = 1; max / exp > 0; exp *= 10) {

            countingSort(arr, exp);
        }
    }

    static void countingSort(int[] arr, int exp) {

        int n = arr.length;

        int[] output = new int[n];
        int[] count = new int[10];

        for (int num : arr) {

            int digit = (num / exp) % 10;

            count[digit]++;
        }

        for (int i = 1; i < 10; i++) {

            count[i] += count[i - 1];
        }

        for (int i = n - 1; i >= 0; i--) {

            int digit = (arr[i] / exp) % 10;

            output[count[digit] - 1] = arr[i];

            count[digit]--;
        }

        for (int i = 0; i < n; i++) {

            arr[i] = output[i];
        }
    }

    public static void main(String[] args) {

        int[] arr = {170, 45, 75, 90, 802, 24, 2, 66};

        radixSort(arr);

        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

Time: O(d × (n + k))
Space: O(n + k)

🧠 Remember:
Radix = Digit by digit

🪣 9. Bucket Sort — Group first, sort later

One last strategy.

Instead of throwing every piece of clothing into one giant pile...

You create buckets.

🪣 Bucket 1 → small values
🪣 Bucket 2 → medium values
🪣 Bucket 3 → large values

Then sort each bucket individually.

Finally...

Combine them.

That's Bucket Sort.

💻 Java

import java.util.*;

public class BucketSort {

    static void bucketSort(float[] arr) {

        int n = arr.length;

        List<Float>[] buckets = new ArrayList[n];

        for (int i = 0; i < n; i++) {
            buckets[i] = new ArrayList<>();
        }

        for (float num : arr) {

            int index = (int) (num * n);

            buckets[index].add(num);
        }

        for (List<Float> bucket : buckets) {
            Collections.sort(bucket);
        }

        int index = 0;

        for (List<Float> bucket : buckets) {

            for (float num : bucket) {

                arr[index++] = num;
            }
        }
    }

    public static void main(String[] args) {

        float[] arr = {
            0.42f, 0.32f, 0.23f,
            0.52f, 0.25f, 0.47f, 0.51f
        };

        bucketSort(arr);

        for (float num : arr) {
            System.out.print(num + " ");
        }
    }
}

Average:O(n + k)
Worst: O(n²)

🧠 Remember:
Bucket = Distribute → Sort → Combine

🧠 So... which algorithm would YOU use?

Now look back at your messy wardrobe.

Same problem.

Different strategies.

Algorithm	Wardrobe Strategy	Main Idea
Bubble	Compare neighbors	Swap
🎯 Selection	Find the right item	Select
🃏 Insertion	Place one item at a time	Insert
✂️ Merge	Split the wardrobe	Divide & Merge
⚡ Quick	Pick a reference item	Pivot
🌳 Heap	Prioritize items	Heap
🔢 Counting	Count categories	Frequency
📚 Radix	Sort digit by digit	Digits
🪣 Bucket	Make groups first	Distribution

And here's the part I want you to remember:

Sorting isn't just about arranging numbers.

It's about learning that the same problem can have completely different solutions.

And in DSA, the real question isn't:

"Can I sort this?"

It's:

"How efficiently can I sort this?" 👀

That's where Time Complexity enters the story.

Because if your wardrobe has 10 clothes, almost anything works.

But what if it has 10 lakh clothes? 😭

Suddenly, your choice of algorithm matters.