Forem: Kanishka Shrivastava

#java #datastructures #programming #collections

Kanishka Shrivastava — Fri, 06 Mar 2026 12:09:48 +0000

Java Concepts I’m Mastering – Part 13: HashMap in Java (Key-Value Data Storage)

Continuing my journey of mastering Java fundamentals.

Today’s concept: HashMap — a powerful way to store and access data using key-value pairs.

What is a HashMap?

A HashMap stores data in the form of:

Key → Value

Each key is unique and maps to a specific value.

Example:

"Java" → 1995
"Python" → 1991
Creating a HashMap

import java.util.HashMap;

HashMap<String, Integer> languages = new HashMap<>();

languages.put("Java", 1995);
languages.put("Python", 1991);
languages.put("C++", 1985);
Accessing Values
System.out.println(languages.get("Java"));

Output:

Useful HashMap Methods

languages.put("Go", 2009);     // add element
languages.get("Python");       // access value
languages.remove("C++");       // delete element
languages.containsKey("Java"); // check key
languages.size();              // total elements

Why HashMap is Powerful

Very fast lookups

Stores structured data

Used heavily in real applications

Examples:

Caching systems

Database indexing

Counting frequencies

What I Learned

HashMap stores unique keys with values

Lookup operations are extremely fast

It's one of the most important structures in Java

Understanding HashMap is essential for efficient programming.

Next in the series: Java Streams API (Modern Data Processing)

#java #collections #programming #datastructures

Kanishka Shrivastava — Thu, 05 Mar 2026 12:19:39 +0000

Java Concepts I’m Mastering – Part 12: ArrayList vs LinkedList

Continuing my journey of mastering Java fundamentals.

Today’s concept: ArrayList vs LinkedList — two important classes from the Java Collections Framework.

Both store collections of elements, but they work differently internally.

ArrayList

ArrayList is backed by a dynamic array.

import java.util.ArrayList;

ArrayList<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");

Best for:

Fast random access

Reading data frequently

Limitation:

Inserting or deleting elements in the middle can be slower.

LinkedList

LinkedList is implemented using nodes connected by pointers.

import java.util.LinkedList;

LinkedList<String> list = new LinkedList<>();
list.add("Java");
list.add("Python");

Best for:

Frequent insertions and deletions

Working with queues or stacks

Limitation:

Accessing elements by index is slower.

Key Difference
ArrayList LinkedList
Dynamic array Doubly linked list
Faster access Slower access
Slower insert/delete Faster insert/delete

What I Learned

Use ArrayList for fast data access.

Use LinkedList when modifying data frequently.

Understanding data structures helps write efficient programs.

Next in the series: HashMap in Java (Key-Value Data Storage)

#java #exceptions #programming #backend

Kanishka Shrivastava — Wed, 04 Mar 2026 08:40:37 +0000

Java Concepts I’m Mastering – Part 11: Exception Handling (try-catch-finally)

Continuing my journey of mastering Java fundamentals.

Today’s concept: Exception Handling — because real programs must handle errors gracefully.

What is an Exception?

An exception is:

An unexpected event that disrupts normal program flow.

Examples:

Dividing by zero

Accessing invalid array index

Reading a missing file

If not handled → program crashes.

try-catch Block

We use try to write risky code
and catch to handle errors.

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

Instead of crashing, it prints a message.

finally Block

The finally block:

Always executes

Used for cleanup (closing files, DB connections, etc.)


try {
    System.out.println("Trying...");
} catch (Exception e) {
    System.out.println("Error occurred");
} finally {
    System.out.println("This always runs");
}

Types of Exceptions

Checked Exceptions (compile-time)

Must be handled

Example: IOException

Unchecked Exceptions (runtime)

Occur during execution

Example: NullPointerException

Why It’s Important

Prevents program crashes

Improves reliability

Makes applications production-ready

Good developers don’t just write logic —
they handle failure properly.

What I Learned

Always handle predictable errors

Use specific exceptions instead of generic ones

Clean up resources using finally

Exception handling separates beginners from professionals.

Next in the series: Collections Framework in Java (ArrayList vs LinkedList)

#devchallenge #geminireflections #gemini #ai #productivity

Kanishka Shrivastava — Tue, 03 Mar 2026 09:34:37 +0000

What I Built with Google Gemini

I created “AI Code Companion”, a tool designed to help developers write, debug, and optimize code faster. The idea came from my own experience struggling to troubleshoot errors late at night during hackathons.

Using Google Gemini, the AI could:

Suggest solutions to bugs in real time.

Offer optimized alternatives for inefficient code.

Explain complex concepts in simple terms.

Gemini’s natural language understanding made it possible to interact with the AI conversationally, almost like having a coding mentor available 24/7.

What I Learned

This project was a crash course in practical AI integration:

Technical: Learned to handle API calls efficiently, parse AI responses, and create a seamless user interface.

Soft Skills: Patience, iterative design, and translating user feedback into functional improvements.

Unexpected Lessons: Even the smartest AI can be unclear without the right prompts. Crafting precise questions drastically improves the usefulness of the output.

Most importantly, I realized how AI can augment human learning and productivity, rather than just automate tasks.

Google Gemini Feedback

What Worked Well: Gemini’s responses were fast, contextually relevant, and easy to integrate into my desktop workflow.

Where I Struggled: For very niche coding scenarios, outputs could be too generic, requiring me to experiment with prompt phrasing.

Overall: The experience reaffirmed Gemini’s potential as a developer’s collaborative AI, and I’m excited to explore more complex use cases in the future.

Looking Forward

Next, I aim to:

Build team collaboration features so multiple developers can consult the AI simultaneously.

Expand the AI’s multi-language support for cross-platform development.

Explore integration with GitHub to suggest code improvements directly in pull requests.

This project has shown me the practical power of AI in real-world development, and I’m motivated to continue experimenting with Google Gemini to make coding faster, smarter, and more intuitive.

#java #oop #programming #100daysofcode

Kanishka Shrivastava — Tue, 03 Mar 2026 09:23:58 +0000

Java Concepts I’m Mastering – Part 10: The final Keyword in Java

Continuing my journey of mastering Java fundamentals.

Today’s concept: The final keyword — small word, strong restrictions.

final is used to prevent modification.

But its behavior depends on where it’s applied.

Final Variable

A final variable cannot be reassigned.


final int MAX_AGE = 100;

// MAX_AGE = 120; // Error

Once assigned → value cannot change.

If it's a reference variable:

final List<String> list = new ArrayList<>();
list.add("Java");   // Allowed
// list = new ArrayList<>(); // Not allowed

You cannot change the reference,
but you can modify the object.

Final Method

A final method cannot be overridden.

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

Child classes cannot modify this behavior.

Final Class

A final class cannot be inherited.


final class Utility {
    void print() {
        System.out.println("Utility class");
    }
}

No class can extend Utility.

Why It’s Important

Improves security

Prevents unwanted modification

Helps in writing immutable classes

Used heavily in system-level and framework code

What I Learned

final protects design decisions

Use it intentionally, not randomly

It strengthens object-oriented design

Small keyword. Big control.

Next in the series: Exception Handling in Java (try-catch-finally)

#java #springboot #backend #ai or #webdev

Kanishka Shrivastava — Sun, 01 Mar 2026 13:28:58 +0000

Let’s Connect!

LinkedIn: https://www.linkedin.com/in/kanishka-shrivastava-496785336

GitHub: https://github.com/KanishkaShrivastava07

Always open to collaborations, learning, and exciting projects

#java #oop #inheritance #programming

Kanishka Shrivastava — Sun, 01 Mar 2026 13:17:44 +0000

Java Concepts I’m Mastering – Part 9: Inheritance in Java (extends Keyword)

Continuing my journey of mastering Java fundamentals.

Today’s focus: Inheritance — the mechanism that allows one class to acquire properties and behavior of another class.

What is Inheritance?

Inheritance means:

A child class can reuse the fields and methods of a parent class.

This promotes:

Code reusability

Clean hierarchy

Logical relationships

Syntax


class ChildClass extends ParentClass {
    // additional features
}

Example

class Animal {
    void eat() {
        System.out.println("This animal eats food");
    }
}

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

Now:

Dog d = new Dog();
d.eat();   // inherited
d.bark();  // own method

The Dog class reuses behavior from Animal.

Types of Inheritance in Java

Single

Multilevel

Hierarchical

(Java does not support multiple inheritance with classes — but it does through interfaces.)

Why It Matters

Inheritance helps in:

Building scalable systems

Reducing code duplication

Implementing runtime polymorphism

It works closely with method overriding, which I covered earlier in this series.

What I Learned

Use inheritance for “is-a” relationships

Avoid unnecessary deep hierarchies

Combine with abstraction for clean design

Inheritance is a core building block of object-oriented design.

Next in the series: Final Keyword in Java (final variable, method, class)

#devchallenge #weekendchallenge #showdev

Kanishka Shrivastava — Sat, 28 Feb 2026 09:36:24 +0000

ExamMate AI 🚀

Smart Crash Planner for Engineering Students

This is a submission for the DEV Weekend Challenge: Community

🚨 The Problem

Every engineering student knows this moment:

The exam timetable gets announced.

You open the syllabus.

It’s huge.

And you think:

“Where do I even start?”

As part of this community myself, I’ve experienced the stress, confusion, and last-minute panic that comes with technical subjects and limited time.

Engineering students don’t just need motivation.

We need structure.

👩‍💻 The Community

I built this project for engineering students — a high-pressure academic community constantly balancing:

Dense technical syllabi
Multiple exams in a short window
Weak topics that need extra attention
Last-minute crash preparation

This tool is designed to make exam prep feel manageable instead of overwhelming.

🧠 What I Built

I created ExamMate AI, a lightweight AI-inspired crash planner that:

📅 Generates personalized day-wise study plans
⏳ Automatically calculates days left until the exam
🎯 Distributes weak topics intelligently
🚨 Activates Panic Mode when ≤ 3 days remain
✅ Tracks daily progress with checkboxes
📊 Displays a dynamic progress bar
🌙 Includes Light/Dark mode toggle
🤖 Simulates an AI “Analyzing…” experience

The goal:

Turn panic into a plan.

No login.

No backend.

No friction.

Just clarity and focus.

🔥 Demo

🌐 Live App:

https://kanishkashr07.github.io/ExamMate-AI/

📸 Preview:

💻 Code

GitHub Repository:

https://github.com/kanishkashr07/ExamMate-AI

The entire project is built as a clean, single-page frontend application for simplicity and accessibility.

⚙️ How I Built It

This project was built using:

HTML5 — Semantic structure
CSS3 — Responsive design + dark/light theming
Vanilla JavaScript —
- Date calculations
- Dynamic schedule generation
- Panic Mode logic
- Progress tracking
- Interactive UI updates

No frameworks.

No libraries.

Just core web technologies.

I intentionally kept it simple to demonstrate that impactful tools for communities can be built without heavy infrastructure.

💡 Why This Matters

This isn’t just a challenge submission.

It’s a solution to a real problem I face as a student.

Community-driven development means building for people whose struggles you genuinely understand.

ExamMate AI is my attempt to make exam season just a little less stressful for engineering students everywhere.

Thank you DEV for hosting this challenge 🙌

I’m excited to continue improving ExamMate AI into a smarter academic companion.

#java #oop #encapsulation #programming

Kanishka Shrivastava — Thu, 26 Feb 2026 13:06:58 +0000

Java Concepts I’m Mastering – Part 8: Encapsulation & Data Hiding

Continuing my journey of mastering Java fundamentals.

Today’s concept: Encapsulation — one of the core pillars of OOP.

What is Encapsulation?

Encapsulation means:

Wrapping data (variables) and methods (functions) together inside a class
and restricting direct access to data.

It protects the internal state of an object.

How Do We Achieve It?

Make variables private

Provide public getter and setter methods

Example

class Student {
    private String name;   // Data hidden

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

Now:


Student s = new Student();
s.setName("Kanishka");
System.out.println(s.getName());

Direct access like s.name is not allowed.

Why is This Important?

Protects data from unwanted modification

Improves security

Makes code more maintainable

Allows validation inside setters

Example with validation:

public void setAge(int age) {
    if(age > 0) {
        this.age = age;
    }
}

Now invalid data cannot enter the system.

What I Learned

Always keep variables private

Control access through methods

Encapsulation makes classes robust and secure

This concept is heavily used in real-world applications and frameworks.

Next in the series: Inheritance in Java (extends keyword)

#java #oop #abstraction #programming

Kanishka Shrivastava — Tue, 24 Feb 2026 10:54:47 +0000

Java Concepts I’m Mastering – Part 7: Abstraction in Java (Abstract Class vs Interface)

Continuing my journey of mastering Java fundamentals.

Today’s focus: Abstraction — hiding implementation details and showing only essential behavior.

Abstraction helps us focus on what an object does, not how it does it.

-> Abstract Class

An abstract class:

Can have abstract methods (without body)

Can have normal methods (with body)

Cannot be instantiated

abstract class Vehicle {
    abstract void start();

    void fuelType() {
        System.out.println("Petrol or Diesel");
    }
}

class Car extends Vehicle {
    void start() {
        System.out.println("Car starts with key");
    }
}

Used when classes share common behavior.

-> Interface

An interface:

Contains method declarations (by default public & abstract)

Supports multiple inheritance

Defines a contract

interface Payment {
    void pay();
}

class UPI implements Payment {
    public void pay() {
        System.out.println("Payment via UPI");
    }
}

Used when you want unrelated classes to follow the same contract.

Key Differences
Abstract Class Interface
Can have constructors Cannot have constructors
Can have instance variables Only constants
Supports single inheritance Supports multiple inheritance
Used for shared base behavior Used for defining contracts

What I Learned

Use abstract class when classes are closely related.

Use interface when defining capability/behavior.

Abstraction makes systems scalable and loosely coupled.

This concept is heavily used in frameworks and real-world applications.

Next in the series: Encapsulation & Data Hiding in Java

#java #oop #polymorphism #programming

Kanishka Shrivastava — Mon, 23 Feb 2026 10:56:26 +0000

Java Concepts I’m Mastering – Part 6: Method Overriding & Runtime Polymorphism

Continuing my journey of mastering Java fundamentals.

Today’s concept: Method Overriding — the foundation of runtime polymorphism.

What is Method Overriding?

Method Overriding happens when:

A child class provides its own implementation

Of a method already defined in the parent class

Same method name.
Same parameters.
Different behavior.

Example

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

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

Now:

Animal a = new Dog();
a.sound();

Output:

Dog barks

Even though the reference type is Animal,
the method of Dog is called.

This is Runtime Polymorphism.

Why is it Powerful?

Enables dynamic behavior

Supports clean extensible design

Core concept behind frameworks & APIs

Important Rules

Method name must be same

Parameters must be same

Access level cannot be more restrictive

Use @override for safety

What I Learned

Overloading = Compile-time

Overriding = Runtime

Polymorphism makes Java flexible and scalable

This concept changed how I see object-oriented design.

Next in the series: Abstraction in Java (Abstract Classes vs Interfaces)

#java #oop #programming #100daysofcode

Kanishka Shrivastava — Sun, 22 Feb 2026 10:19:55 +0000

Java Concepts I’m Mastering – Part 5: Method Overloading

Continuing my journey of mastering Java fundamentals while building real projects.

Today’s concept: Method Overloading.

What is Method Overloading?

Method Overloading means:

Same method name, but different parameters.

Java decides which method to call based on:

Number of parameters

Type of parameters

Order of parameters

Example

class Calculator {

    int add(int a, int b) {
        return a + b;
    }

    double add(double a, double b) {
        return a + b;
    }

    int add(int a, int b, int c) {
        return a + b + c;
    }
}

Same method name → add
Different parameter lists → Overloading

Why is it Useful?

Improves code readability

Makes APIs cleaner

Supports compile-time polymorphism

Important Rule

You cannot overload methods by only changing the return type.

This is invalid:

int add(int a, int b)
double add(int a, int b)   // Error

Parameters must differ.

What I Learned

Overloading makes code flexible

It’s resolved at compile-time

It’s one of the foundations of Polymorphism

Understanding this makes class design much stronger.

Next in the series: Method Overriding & Runtime Polymorphism