Forem: M.Kabileshwaran

Day 1 of DSA: Arrays Fundamentals

M.Kabileshwaran — Thu, 01 Jan 2026 02:07:35 +0000

Day 1: Arrays

I chose arrays as the starting point for my DSA journey. Although I am not a complete beginner—I have learned Java and basic DSA earlier—I felt arrays are a good concept to revisit and strengthen before moving to more advanced topics.

However, I would not recommend absolute beginners to start directly with arrays. Beginners should first be comfortable with basic programming concepts such as variables, data types, and loops. Once those fundamentals are clear, arrays become much easier to understand.

Before learning DSA, it is important to choose a programming language. I have chosen Java as my primary language, and in this blog, I will cover DSA concepts specifically from a Java perspective, with brief comparisons to Python where necessary.

A quick thanks to the instructor of this YouTube tutorial—it helped me understand the concepts better.

Topics Covered in This Blog

Why do we need Arrays?
What is an Array?
Arrays in Java and Python
Syntax of an Array in Java
Rules of Arrays in Java
Declaration and Initialization
Example of Creating an Array
Indexing in Arrays
Length of an Array
Default Values in Arrays
String Arrays and Memory
Primitive Types vs Objects
Mutability of Arrays

Why Do We Need Arrays?

Arrays are used to store a collection of related values under a single name, which is usually called a reference variable.

For example, if we want to store the names of our friends, instead of creating multiple variables for each name, we can store all the names in a single array called friendsNames. This makes the code more organized, scalable, and easier to work with.

When I picture an array, I imagine a row of empty boxes on a shelf. Each box has a fixed position number, and I can drop one related item per box. That mental model makes it easier to write loops later because I know each index follows a predictable pattern.

What Is an Array?

A commonly used definition of an array is:

An array is a collection of elements of the same data type stored in contiguous memory locations.

This definition is completely accurate for low-level languages such as C and C++.

However, the internal implementation of arrays can differ across programming languages.

"Contiguous" simply means the slots are side by side in memory. The benefit is fast random access: jumping to index i is quick because the program can calculate the exact memory address. The trade-off is that resizing usually means creating a brand new array and copying items over.

Arrays in Java

In Java, an array can store only one data type, which makes arrays homogeneous.
Arrays in Java are objects, and they are created in the heap memory.
For primitive data types (int, double, etc.), the values are stored contiguously within the array object.
For reference types (String, Object, etc.), the array stores contiguous references, while the actual objects may be located at different places in the heap.

I like to remember that String[] names really holds references. Changing names[0] = "Bob" only swaps which String object that slot points to; it does not move or copy the underlying String objects elsewhere.

Arrays in Python

Python does not provide traditional arrays by default.
What is commonly used in Python is a list, which can store different data types.
A Python list stores references to objects, not the raw values themselves.

Because Python lists are dynamic, appending feels effortless. The runtime quietly reallocates and copies when needed. That is friendly for beginners but also hides the cost of growing a list compared to a fixed-size Java array.

Syntax of an Array in Java

datatype[] arrayName = new datatype[size];

Explanation:

datatype → specifies the type of elements the array can store
[] → indicates that the variable is of array type
arrayName → reference variable that points to the array object
new → used to create an array object in the heap
datatype[size] → specifies the data type and the number of elements the array can hold

When I first wrote this, the position of [] confused me. datatype[] arrayName and datatype arrayName[] both compile in Java, but I stick to the first style because it reads as "arrayName is an array of datatype." The size is fixed at creation time.

Rules of Arrays in Java

The reference variable name must follow the same naming conventions as normal variables.
All elements in an array must be of the same data type.
The size of an array is fixed once it is created and cannot be changed.

If I think I will need a changing size, I start with ArrayList instead. Sticking to plain arrays is great practice for learning indexing and for interview-style questions where fixed-size storage is expected.

Declaration and Initialization

datatype[] arr;           // declaration
arr = new datatype[size]; // initialization

During declaration, a reference variable is created.
During initialization, the array object is created in the heap.
Declaration is checked at compile time.
Memory allocation for the array happens at runtime.

An easy mistake: calling arr[0] before arr is initialized triggers a NullPointerException because the reference points to nothing. I keep reminding myself that declaration alone does not create the boxes—initialization does.

Example of Creating an Array

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

This creates and initializes an integer array containing six elements.

Whenever I declare with curly braces, I read the values out loud—"one, two, three, four, five, six"—to check I did not skip a number. Printing nums.length also confirms the size matches what I expect.

Indexing in Arrays

Indexing is used to access elements of an array.

Array indexing in Java starts from 0.
The first element is stored at index 0.

Example:

int[] num = {2, 7, 8};

num[0] → 2
num[1] → 7
num[2] → 8

Here:

Length of the array = 3
Last index = length - 1 = 2

Many beginners confuse the length of an array with the last index, but they are not the same.

If we try to access an index greater than the last index, Java throws an exception called:

ArrayIndexOutOfBoundsException

I still pause before writing loop bounds: for (int i = 0; i < num.length; i++) is safer than <= because it naturally stops at the last valid index. Drawing three boxes labeled 0, 1, 2 helps me visualize where the loop should end.

Length of an Array

num.length

length gives the number of elements present in the array.
It is a property, not a method.

To find the last index of an array:

int lastIndex = num.length - 1;

length is a field, not a method, so there are no parentheses. Using num.length() by accident will not compile, which is a helpful reminder when switching between arrays and ArrayList (which uses size()).

Default Values in Arrays

If an array is created without explicitly assigning values, Java automatically assigns default values.

Example:

int[] n = new int[5];

Since int is a primitive data type, each element is initialized to 0.

For reference types:

String[] names = new String[5];

Each element is initialized to null.

This demonstrates the difference in behavior between primitive types and reference types in arrays.

Defaults are great for quick experiments, but they can also hide missing data. When I see 0 or null in logs, I double-check if that value is intentional or just the default placeholder I forgot to overwrite.

String Arrays and Memory

String[] languages = {"Java", "Python", "C++"};

The array stores references to String objects.
Each String object is stored separately in the heap.
The array itself is an object and is also stored in the heap.

If I reassign languages[1] = "Go", only that slot changes. The original "Python" string still exists until garbage collection cleans it up, which is why arrays of references feel lightweight to modify.

Primitive Types vs Objects

Primitive values can be stored in the stack (for local variables) or inside objects in the heap, depending on where they are declared.
Objects and arrays are always stored in the heap.
Reference variables that point to objects are stored in the stack.

Thinking in two layers helps me: the reference lives on the stack (quick to access), while the actual array object lives on the heap (shared and resizable only by creating new objects). When I pass an array into a method, I am really passing the reference, so changes inside the method affect the original array.

Mutability of Arrays

Arrays in Java are mutable, meaning their elements can be changed after creation.

However, the size of an array cannot be modified once it is created.

Example:

int[] scores = {10, 20, 30};
scores[1] = 25; // updates the second element

scores still has three elements, but the middle value is now 25. If I need a fourth score, I must create a new array or use a dynamic structure like ArrayList.

Day 1 Takeaway

Arrays form the foundation for many data structures in DSA. A clear understanding of how arrays work—especially indexing, memory behavior, and limitations—is essential before moving on to more advanced topics.

Free Resources I Found Helpful

Oracle Java Tutorials on arrays: https://docs.oracle.com/javase/tutorial/java/nutsandbolts/arrays.html
GeeksforGeeks introduction to arrays: https://www.geeksforgeeks.org/introduction-to-arrays/
W3Schools Java arrays overview: https://www.w3schools.com/java/java_arrays.asp
FreeCodeCamp guide on array basics: https://www.freecodecamp.org/news/arrays-explained/

If you made it here, thanks for learning with me. I am still treating this like a lab notebook: simple drawings, small code snippets, and honest mistakes I catch along the way. If you spot gaps or have a favorite beginner-friendly resource, let me know so I can keep improving this journal.

OOP in Java: A First-Year Student’s Cheat Sheet

M.Kabileshwaran — Wed, 02 Jul 2025 10:50:42 +0000

Think of OOP like building with blueprints and real-world creations.
1. Classes vs. Objects – The Simple Difference
A class is like a recipe for a cake. It lists the ingredients (data) and steps (actions). An object is the actual cake you bake using that recipe. You can make many cakes from one recipe, just like you can create many objects from one class.
Example:
Class (Recipe): "How to make a car" (has wheels, color, speed).
Object (Real Car): Your red Toyota (with 4 wheels, going 60 mph).
In Java:

Class = blueprint or template
Object = an instance of that blueprint, a real thing created based on the class

Example:
Think of a Car class — it describes what a car is (color, model, year) and what it can do (drive, brake). When you create a Car object, say myCar, you’re making a specific car, like a red 2020 Toyota.

class Car {
    String color;
    int year;

    void drive() {
        System.out.println("The " + color + " car is driving.");
    }
}

public class Main {
    public static void main(String[] args) {
        Car myCar = new Car();  // Creating an object
        myCar.color = "Red";
        myCar.year = 2020;
        myCar.drive();  // Output: The Red car is driving.
    }
}

2. What Are Constructors? Do We Have Destructors in Java Like C++?
Constructor:
Think of it as a special method that builds your object. When you create an object, the constructor sets up initial values — like choosing the color and year of your car right when you build it.

class Car {
    String color;
    int year;

    // Constructor
    Car(String c, int y) {
        color = c;
        year = y;
    }
}

Destructors?
In C++, destructors clean up when an object is destroyed (like cleaning your room after playing). In Java, there are no destructors because Java has a garbage collector that automatically cleans up unused objects. So, you don’t have to worry about manually deleting objects.

3. What Is static?
static is like a shared property or method that belongs to the class itself, not to any specific object.
Example: Imagine a school where every student has a name (instance variable), but the school’s name is the same for all students (static variable).

class Student {
    String name;              // each student has a name
    static String school = "ABC High School";  // shared by all students
}

You can access static stuff without creating an object:
System.out.println(Student.school); // Output: ABC High School

4. What Are Access Modifiers?

Access modifiers control who can see or use your class members (variables, methods). Think of them as privacy levels:

public: Everyone can see and use it — like a public park.
private: Only the class itself can see it — like your diary.
protected: The class and its subclasses (children) can see it — like family secrets.
default (no modifier): Only classes in the same package can see it — like your neighborhood friends.

5. Example Scenarios & Scope of Access Modifiers

6. The 4 Pillars of OOP and How to Implement Them in Java
Encapsulation — Wrapping data and methods together, hiding details. Use private variables + public getters/setters.

class Person {
    private String name;

    public String getName() { return name; }
    public void setName(String n) { name = n; }
}

Inheritance — A class inherits properties/methods from another (like a child inheriting traits).

class Animal {
    void eat() { System.out.println("Eating"); }
}

class Dog extends Animal {
    void bark() { System.out.println("Barking"); }
}

Polymorphism — One interface, many forms. Methods can behave differently in subclasses.

class Animal {
    void sound() { System.out.println("Some sound"); }
}

class Dog extends Animal {
    void sound() { System.out.println("Bark"); }
}

Abstraction — Hiding complex details, showing only what’s necessary. Use abstract classes or interfaces.

abstract class Vehicle {
    abstract void move();
}

class Bike extends Vehicle {
    void move() { System.out.println("Bike is moving"); }
}

7. How Are Objects Instantiated in Memory?
When you create an object with new, Java allocates memory for it on the heap (the big memory area for objects). The reference (like a pointer) to that object lives on the stack.
Example:

Car myCar = new Car("Blue", 2021);

myCar is a reference on the stack.
The actual Car object is stored on the heap.

8. Can We Pass Objects as Arguments to Other Objects? How?
Objects can be passed as parameters to methods or constructors, enabling interaction between objects.
Example: A Driver object can have a Car object passed to it.

class Car {
    String model;
    Car(String m) { model = m; }
}

class Driver {
    void drive(Car car) {
        System.out.println("Driving a " + car.model);
    }
}

public class Main {
    public static void main(String[] args) {
        Car myCar = new Car("Tesla");
        Driver d = new Driver();
        d.drive(myCar);  // Output: Driving a Tesla
    }
}