DEV Community: SIVAGANESH L

Understanding Java Arrays: A Beginner's Perspective

SIVAGANESH L — Fri, 27 Jun 2025 09:58:32 +0000

What is an Array in Java?
In simple terms, an array is like a row of containers that can store multiple values of the same type.

Why Do We Use Arrays in Java?
Imagine you want to store the marks of 3 students. You might do this:

int mark1 = 10;
int mark2 = 20;
int mark3 = 30;

But what if there are 100 students?

Using so many separate variables becomes difficult to write, read, and manage. That’s why we use arrays.

When we Should Use an Array?

You know how many values you need to store.

All values are of the same type (e.g. all integers, all strings).

You want to loop through the data easily.

You need fast access to elements using index numbers.

Array example:

int[] numbers = {1, 2, 3, 4, 5}; //Here, numbers is an array that holds 5 integers.
String[] fruits = {"Apple", "Banana", "Mango"};
boolean[] flags = {true, false, true};

How to Declare an Array
There are two main steps:

Declare the array:

int[] myArray;            // Declaration

Initialize it with values or size:

myArray = new int[3];     // Initialization with size

You can also do both in one line:

int[] myArray = new int[3];

Storing Values in an Array:
Array uses indexes to store values and index starts from 0.

myArray[0] = 10;
myArray[1] = 20;
myArray[2] = 30;

Array looks like [10,20,30]

Accessing Array Elements

System.out.println(myArray[1]); //Output: 20

Looping Through Arrays

for (int i = 0; i < myArray.length; i++) {
    System.out.println(myArray[i]);
}

When Not to Use Arrays?

You don’t know the size of elements in advance.

You need to frequently add or remove elements.

Shallow Copy Vs Deep Copy

SIVAGANESH L — Fri, 13 Jun 2025 10:08:26 +0000

Shallow Copy:
A shallow copy of an object is a copy where only the references to the objects are copied, not the objects themselves. This means that the new object will share the same references to the objects inside the original object. If the internal objects are modified, the changes will be reflected in both the original and the copied objects.

public class ShallowEx {
    int a;
    int b;
    public ShallowEx(){
        this.a =100;
        this.b = 200;
    }
      }

public class ShallowCopyMain {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ShallowEx obj1 = new ShallowEx();
        System.out.println("Before Copying");
        System.out.println(obj1.a);
        System.out.println(obj1.b);
        //Copying Objects
        ShallowEx obj2= obj1;
        System.out.println(obj2.a);
        System.out.println(obj2.b);
        obj2.a=1000;
        obj2.b=2000;
        System.out.println("After Copying");
        System.out.println("object1value "+obj1.a);
        System.out.println("object1value "+obj1.b);
        System.out.println("object1value "+obj2.a);
        System.out.println("object1value "+obj2.b);
        }
            }

Output:
Before Copying
object1 a value 100
object1 b value 200
object2 a value 100
object2 b value 200
After Copying
object1 a value 1000
object1 b value 2000
object2 a value 1000
object2 b value 2000

Deep Copy:
A deep copy creates a completely independent copy of an object, including all the objects it refers to. This means the copied object and the original object are fully separate. Changes made to the copied object or its internal parts will not affect the original object, and vice versa.

public class DeepCopySupport implements Cloneable {
    int a;
    DeepCopySupport(int a){
    this.a=a;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
      }

public class DeepCopyMain {
    public static void main(String[] args) throws CloneNotSupportedException {
        // TODO Auto-generated method stub
        DeepCopySupport obj1= new DeepCopySupport(90);
        DeepCopySupport obj2= (DeepCopySupport) obj1.clone();
        System.out.println("Before Deep Copy");
        System.out.println("Object1 a value "+obj1.a);
        System.out.println("Object2 a value "+obj2.a);
        obj2.a=100;
        System.out.println("After Deep Copy");
        System.out.println("Object1 a value "+obj1.a);
        System.out.println("Object2 a value "+obj2.a);
      }
        }

Output:
Before Deep Copy
Object1 a value 90
Object2 a value 90
After Deep Copy
Object1 a value 90
Object2 a value 100

In real time example:
Shallow Copy:
1. Sharing a calendar with your roommate -> If one updates an event, the other sees it.
2. Lending your notes to a friend -> If they mark/highlight something, it stays.

Deep Copy:
1. Both keeping individual planners -> Each person’s schedule is independent.
2. Both of you take notes separately during class -> Your notes won't reflect their changes.

Shallow Copy Vs Deep Copy

SIVAGANESH L — Fri, 13 Jun 2025 09:41:38 +0000

public class ShallowEx {
    int a;
    int b;
    public ShallowEx(){
        this.a =100;
        this.b = 200;
    }
      }

public class ShallowCopyMain {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ShallowEx obj1 = new ShallowEx();
        System.out.println("Before Copying");
        System.out.println(obj1.a);
        System.out.println(obj1.b);
        //Copying Objects
        ShallowEx obj2= obj1;
        System.out.println(obj2.a);
        System.out.println(obj2.b);
        obj2.a=1000;
        obj2.b=2000;
        System.out.println("After Copying");
        System.out.println("object1value "+obj1.a);
        System.out.println("object1value "+obj1.b);
        System.out.println("object1value "+obj2.a);
        System.out.println("object1value "+obj2.b);
        }
            }

public class DeepCopySupport implements Cloneable {
    int a;
    DeepCopySupport(int a){
    this.a=a;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
      }

public class DeepCopyMain {
    public static void main(String[] args) throws CloneNotSupportedException {
        // TODO Auto-generated method stub
        DeepCopySupport obj1= new DeepCopySupport(90);
        DeepCopySupport obj2= (DeepCopySupport) obj1.clone();
        System.out.println("Before Deep Copy");
        System.out.println("Object1 a value "+obj1.a);
        System.out.println("Object2 a value "+obj2.a);
        obj2.a=100;
        System.out.println("After Deep Copy");
        System.out.println("Object1 a value "+obj1.a);
        System.out.println("Object2 a value "+obj2.a);
      }
        }

Output:
Before Deep Copy
Object1 a value 90
Object2 a value 90
After Deep Copy
Object1 a value 90
Object2 a value 100

Basic Git commands for beginners

SIVAGANESH L — Thu, 05 Jun 2025 04:55:00 +0000

I want to share what i have learnt so for from git. Git is version control system which helps us to track changes in our code and shared among the team members. It's really a great tool.

Here are some Basic commands that i have learned with simple words.

git init
It creates a new git repository, .git a hidden file will be created in the project folder and git starts to track everything.
git status
Shows the current state of your files and any time we can see what's going on
git add
Changes to include in the next commit and can be used before commit changes.
To add specific file:
git add filename.txt

To add everything:
git add .

git commit command used to saves the changes after you add the your changes

git commit -m "Latest changes in home page"

git log Show the history if commits

git log

git branch shows all the branches or create a new branch

List out the branches:
git branch

Create a Branch:
git branch newfeature

git checkout Command will switch between branches

git checkout newfeature

git merge Command will merge or combine one branch to another branch and used when a newfeature is ready and you want add it to the main or master branch.

git checkout master
git merge new-feature

git clone
Command will copy remote repository to local machine and its used when multiple person work on same project.
git clone https://github.com/
git push
Command will upload the changes into remote repository and its used after committing the changes locally.

git push origin main

git pull Command will get the latest changes from the remote repository and its used before starting your work so that you are upto date .

git pull origin main

These are the basics git command.

Core Java Data Types – For Beginner's

SIVAGANESH L — Mon, 02 Jun 2025 06:50:09 +0000

When I started learning the Java basics. One of the first things I came across was data types. it’s very important.

Let me share what I understood so far.

Data Types:
I simple words, Data types nothing but what kind of data we want to store in a variable.
In real time when we shift our home to another home, we might have different types of boxes where we wanted to store our house hold items and name those boxes accordingly(Ex: Toys, Books, Tools), so java want to know what kind box we are using for numbers, letters etc.

Java has two main types of data types:

Primitive Data Types.
Non-Primitive (Reference) Data Types.

In this post I will give the outline Primitive Data Types.

There are 8 Primitive Data Types:
| Data Type | Size | What It Stores | Example |
| --------- | ------- | ------------------------- | --------------------------- |
| byte | 1 byte | Small whole numbers | byte a = 10; |
| short | 2 bytes | Bit bigger numbers | short b = 1000; |
| int | 4 bytes | Most common whole numbers | int age = 25; |
| long | 8 bytes | Huge whole numbers | long stars = 123456789L; |
| float | 4 bytes | Decimal numbers | float price = 12.5f; |
| double | 8 bytes | More accurate decimals | double pi = 3.14159; |
| char | 2 bytes | Single character | char letter = 'A'; |
| boolean | 1 bit | True or False | boolean isJavaFun = true; |

My Personal Suggesion:
First start with int for numbers and double for decimals.

Calculating Bike Mileage in simple Java program

SIVAGANESH L — Mon, 26 May 2025 05:36:57 +0000

create a simple Java class called Bike to calculate mileage based on distance traveled and fuel consumed.

What is Mileage?
Mileage is nothing but how much distance a vehicle is travelled consuming certain amount of fuel. Its calculated as
mileage = distance traveled / fuel used.
EX: 150/5 = 30km/l

The program has:
A method to get distance travelled
A method to calculate mileage

public class Bike {

public int getDistance(int distance){

    return distance;
}

public int getMileage(int distance, int fuelQuantity) {

    return distance/fuelQuantity;
}

public static void main(String[] args) {
    Bike myBike = new Bike();
    int distance = myBike.getDistance(300);
    int mileage = myBike.getMileage(distance, 5);
    System.out.println("Mileage of this bike:" +mileage);
    }
         }

getDistance(): This method return the distance value
getMileage(): This method calculate the mileage using the formula
main(): create a Bike object myBike in main method and input the value for distance and fuelQuantity and prints the mileage.