DEV Community: Abinesh.R

Scanner Class

Abinesh.R — Sun, 06 Sep 2026 11:42:18 +0000

What is the Scanner Class?

Scanner is a class in the java.util package used to read input — from the keyboard (System.in), a file, or even a String. It breaks input into tokens (words, numbers, lines) using whitespace as the default delimiter, and provides methods to parse each token into the type you need (int, double, String, etc.).

Think of it as a "reader + parser" combined — it doesn't just grab raw text, it converts it into the exact data type your program expects.

Importing and Creating a Scanner

import java.util.Scanner;

Scanner sc = new Scanner(System.in);

System.in tells it to read from the keyboard/console. You can also pass a File object or a String to read from those sources instead.

Basic Example

import java.util.Scanner;

public class ScannerDemo {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);

    System.out.print("Enter your name: ");
    String name = sc.nextLine();

    System.out.print("Enter your age: ");
    int age = sc.nextInt();

    System.out.println("Hello " + name + ", you are " + age + " years old.");

    sc.close();
}

}

Commonly Used Methods

Method Reads
nextInt() an int
nextLong() a long
nextDouble() a double
nextFloat() a float
next() a single word (stops at whitespace)
nextLine() an entire line, including spaces
nextBoolean() true/false
hasNext() checks if more input is available
hasNextInt() checks if the next token is a valid int

The Classic Bug: Mixing nextInt() and nextLine()

Scanner sc = new Scanner(System.in);

System.out.print("Enter age: ");
int age = sc.nextInt(); // reads the number, but leaves "\n" in the buffer

System.out.print("Enter name: ");
String name = sc.nextLine(); // reads that leftover "\n" instead of waiting for real input!

nextInt() only consumes the digits — it leaves the newline character behind in the input buffer. The next nextLine() call then grabs that leftover newline instead of pausing for actual input, so name ends up empty.

Fix:
** consume the leftover newline with an extra nextLine() call:**

int age = sc.nextInt();
sc.nextLine();

String name = sc.nextLine();

Fix:
consume the leftover newline with an extra nextLine() call:

int age = sc.nextInt();
sc.nextLine(); // clears the leftover newline
String name = sc.nextLine();

Reading Multiple Inputs in a Loop

Scanner sc = new Scanner(System.in);
System.out.print("How many numbers? ");
int n = sc.nextInt();

int[] arr = new int[n];
for (int i = 0; i < n; i++) {
arr[i] = sc.nextInt();
}

Always Close Your Scanner

sc.close();

Summary

Scanner reads and parses input from the console, a file, or a string.
Use next()/nextLine() for text, and nextInt()/nextDouble()/etc. for numbers.
Watch out for the nextInt() → nextLine() buffer bug — it's the #1 gotcha for beginners.
Always close your Scanner when done.

Online Voting System in my facing challenges.....

Abinesh.R — Sun, 06 Sep 2026 11:14:11 +0000

1. JDBC Connection & SQL Errors

My first roadblock wasn't even logic — it was just getting connected. I kept hitting:

com.mysql.cj.jdbc.exceptions.CommunicationsException: Communications link failure
**
What was going wrong:**

Wrong JDBC URL format (missing useSSL=false or timezone parameter caused issues on newer MySQL versions)
MySQL service not running
Driver JAR not added to the classpath correctly

How I fixed it:

java
String url = "jdbc:mysql://localhost:3306/voting_db?useSSL=false&serverTimezone=UTC";
Connection con = DriverManager.getConnection(url, "root", "password");

I also wrapped every connection attempt in a proper try-catch-finally block instead of letting exceptions crash the whole app silently:

java
*try *(Connection con = DriverManager.getConnection(url, user, pass)) {
// queries here
} catch (SQLException e) {
System.out.println("DB connection failed: " + e.getMessage());
}

Lesson: Using try-with-resources for Connection, PreparedStatement, and ResultSet saved me from a bunch of "leaked connection" bugs later.
**

Preventing Duplicate Votes**

This was the trickiest logic problem. Nothing stops a user from just running the "vote" function twice unless you explicitly block it.
**
My approach:**

Added a has_voted boolean column to the voters table.
Before casting a vote, I check this flag. After a successful vote, I flip it immediately in the same transaction — not as an afterthought.
java
public boolean hasVoted(String voterId) throws SQLException {
String query = "SELECT has_voted FROM voters WHERE voter_id = ?";
try (PreparedStatement ps = con.prepareStatement(query)) {
ps.setString(1, voterId);
ResultSet rs = ps.executeQuery();
return rs.next() && rs.getBoolean("has_voted");
}
}

I also added a UNIQUE constraint at the database level as a backup — never trust application logic alone to enforce something this important. If the app logic has a bug, the database still refuses the duplicate insert.
**

Designing the DAO Pattern Cleanly**

At first, my DB queries were scattered across the main class — messy and hard to test. Refactoring into a proper DAO layer took a few iterations to get right.

Final structure I settled on:

*VoterDAO * -> handles voter lookup & verification
*CandidateDAO * -> handles candidate data
*VoteDAO * -> handles casting + counting votes
*DBConnection * -> single utility class for getting connections

Each DAO interface has an implementation class, so if I ever swap MySQL for another database, only the implementation changes — not the code calling it.

java
public interface VoterDAO {
boolean verifyVoter(String voterId);
boolean hasVoted(String voterId);
}
**
Lesson:** Separating "what" (interface) from "how" (implementation) made my code far easier to debug and extend later.

4. Generating the Vote Result File

Once voting closes, I needed to tally results and write them to a file — but my first attempt kept producing incomplete or garbled output because I wasn't flushing/closing the file writer properly.

Fix:

java
try (BufferedWriter writer = new BufferedWriter(new FileWriter("vote_results.txt"))) {
for (Map.Entry entry : results.entrySet()) {
writer.write(entry.getKey() + " : " + entry.getValue() + " votes");
writer.newLine();
}
} catch (IOException e) {
System.out.println("Error writing results: " + e.getMessage());
}

SQL COMMANDS,AND FUNCTIONS CONCEPTS

Abinesh.R — Sat, 05 Sep 2026 03:06:06 +0000

1. SQL Basics & Filtering
SELECT **
SELECT — SELECT name FROM users; → picks which columns to return.
**Example:
SELECT * FROM users;
→ returns all columns.
*DISTINCT *

SELECT DISTINCT city FROM users; → removes duplicate rows from results.

*FROM *
SELECT * FROM users;
→ names the table to query.

WHERE
SELECT * FROM users WHERE age > 18;
→ filters rows before grouping/output.
EXAMPLE:
*AND *
WHERE age > 18 AND city='Chennai';
→ all conditions must be true.

OR —
WHERE city='Chennai' OR city='Trichy';
→ at least one condition must be true.

*NOT *
WHERE NOT city='Chennai';
→ negates a condition.
*IN *
WHERE city IN ('Chennai','Trichy');
→ matches any value in a list.

*NOT IN *
WHERE city NOT IN ('Chennai');
→ excludes values in a list.

BETWEEN
WHERE age BETWEEN 18 AND 25;
→ inclusive range check.

LIKE **
WHERE name LIKE 'A%';
→ pattern match (%=any chars, _=one char).
*Like *
**case-insensitive
LIKE (Postgres only;
MySQL's LIKE is case-insensitive by default on most collations).

IS NULL
WHERE phone IS NULL;
→ checks for missing values.
*IS NOT NULL *
WHERE phone IS NOT NULL;
→ checks value exists.

ORDER BY **
ORDER BY age DESC;
→ sorts result rows.
**ASC
ascending sort order (default).
DESC **
descending sort order.
**LIMIT
LIMIT 10;
→ caps number of rows returned.

*OFFSET *
LIMIT 10 OFFSET 20;
→ skips rows before returning (pagination).

*AS *
SELECT name AS full_name;
→ renames a column/table (alias).

CASE WHEN
CASE WHEN age<18 THEN 'Minor' ELSE 'Adult' END → conditional logic in a query.

COALESCE()
*COALESCE(phone,'N/A') *
→ returns first non-null value from a list.

*NULLIF() *
NULLIF(a,b)
→ returns NULL if a=b, else returns a.

*CAST() *
CAST(salary AS DECIMAL(10,2))
→converts data type.
*ROUND() *
ROUND(3.14159,2)
→ rounds a number to given decimals.

UPPER()
converts text to uppercase.
*LOWER() *
converts text to lowercase.
*TRIM() *
removes leading/trailing spaces.

**CONCAT()
CONCAT(first,' ',last)
→ joins strings together.

2*. Aggregation & Functions*

*COUNT() *

COUNT(*)
counts rows; COUNT(col) counts non-null values.

COUNT() *
counts total rows including NULLs.
*COUNT(DISTINCT) *
counts unique non-null values.
*SUM() *
total of a numeric column.
**AVG()
average of a numeric column.
*MIN() *
smallest value.
*MAX() *
largest value.
*GROUP BY *
GROUP BY department
→ groups rows to apply aggregates per group.
*HAVING *
HAVING COUNT()>5
→ filters groups after aggregation (WHERE can't do this).
**GROUPING SETS *
lets you compute multiple GROUP BY combinations in one query.

ROLLUP
adds subtotal + grand total rows to grouped results.

CUBE
like ROLLUP but generates subtotals for every combination of grouped columns.

*DATE() * extracts the date part from a datetime value.

*EXTRACT() *
EXTRACT(YEAR FROM order_date)
→ pulls a specific part (year/month/day) from a date.

DATE_TRUNC()
rounds a timestamp down to a unit (day, month, year)
Postgres; MySQL uses DATE_FORMAT.

*CURRENT_DATE *
returns today's date.
*CURRENT_TIMESTAMP *
returns current date and time.

*INTERVAL *
date + INTERVAL 7 DAY
→ adds/subtracts a time span.

ABS()
absolute (non-negative) value.
CEIL() **
rounds a number up.
**FLOOR()
rounds a number down.
POWER()

POWER(2,3)
→ 2³ = 8.
*MOD() *
remainder of division.
*LENGTH() *
number of characters in a string.
*SUBSTRING() * SUBSTRING(name,1,3)
→ extracts part of a string.
*REPLACE() * REPLACE(str,'a','b')
→ replaces substring occurrences.

*POSITION() *
finds the index of a substring within a string.

STRING_AGG()
concatenates values from multiple rows into one string with a separator
(Postgres; MySQL equivalent is GROUP_CONCAT).

GREATEST() **
returns the largest of a list of values.
*LEAST() *
returns the smallest of a list of values.
**3. Joins & Subqueries
INNER JOIN
returns only rows matching in both tables.
LEFT JOIN
all rows from left table, matched rows from right (NULL if no match).
RIGHT JOIN
all rows from right table, matched rows from left.
FULL OUTER JOIN
all rows from both tables, matched where possible (not supported directly in MySQL — simulate with UNION of LEFT and RIGHT joins).
CROSS JOIN
every row of table A paired with every row of table B (Cartesian product).
SELF JOIN **
a table joined with itself
(e.g., comparing employees to their managers in the same table).
**JOIN ... ON
JOIN table2 ON t1.id=t2.id
→ join condition
using arbitrary columns.

JOIN ... USING
JOIN table 2 *USING(id)
→ **shorthand join when column names match exactly.
**UNION *
combines results of two queries, removing duplicates.

UNION ALL

combines results of two queries, keeping duplicates (faster).

INTERSECT
returns rows common to both queries.
EXCEPT
returns rows in the first query not present in the second
(MySQL: use NOT IN/NOT EXISTS instead).
EXISTS
WHERE EXISTS (subquery)
→ true if subquery returns any row.
NOT EXISTS
true if subquery returns no rows.
*ANY — *
compares a value to any result of a subquery
(e.g., > ANY(...)).

*ALL *
compares a value to all results of a subquery
(e.g., > ALL(...)).

IN (Subquery)
WHERE id IN (SELECT ...)
→ filters using a subquery result set.
Scalar Subquery
a subquery that returns exactly one value, used like a single value.
*Correlated Subquery *
a subquery that references the outer query's columns, run once per outer row.
*Nested Subquery *
a subquery inside another subquery.

WITH
starts a Common Table Expression (CTE), a named temporary result set.
CTE
WITH temp AS (SELECT ...)

SELECT * FROM temp;
→ improves readability of complex queries.

*Recursive CTE *
a CTE that references itself, used for hierarchical/tree data
(e.g., org charts).

CREATE VIEW
saves a query as a virtual, reusable table.

CREATE TABLE AS
creates a new table populated from a query's results.

INSERT INTO
adds new rows to a table.
UPDATE
modifies existing rows.
DELETE **
removes rows from a table.
*MERGE *— combines **INSERT/UPDATE/DELETE
logic based on a match condition
("upsert" in Oracle/SQL Server; MySQL uses INSERT ... ON DUPLICATE KEY UPDATE).

UPSERT — general term for "insert, or update if it already exists."

4. Window & Advanced SQL
*OVER() *
turns an aggregate/ranking function into a window function that doesn't collapse rows.

*PARTITION BY *
OVER(PARTITION BY dept)
→ resets the window calculation for each group.

ORDER BY (in window)
defines row order within each partition for ranking/running calcs.

*ROW_NUMBER() *
assigns a unique sequential number to each row within a partition.

RANK()
ranks rows, skipping numbers after ties (1,2,2,4).

*DENSE_RANK() *
ranks rows without skipping after ties (1,2,2,3).

NTILE()
splits rows into N roughly equal buckets (e.g., quartiles).

*LAG() *
accesses a value from the previous row in the partition.

*LEAD() *
accesses a value from the next row in the partition.

FIRST_VALUE()
returns the first value in the window frame.

*LAST_VALUE() *
returns the last value in the window frame.

NTH_VALUE()
returns the value at a specific position in the window frame.

SUM() OVER()
running/grouped total without collapsing rows.

AVG() OVER()
running/grouped average.

COUNT() OVER() running/grouped count.

MIN() OVER()
running/grouped minimum.

*MAX() OVER() *
running/grouped maximum.

*ROWS BETWEEN *
defines a physical row-based window frame
(e.g., ROWS BETWEEN)

2 PRECEDING AND CURRENT ROW).

RANGE BETWEEN
defines a value-based window frame instead of row-count based.

*UNBOUNDED PRECEDING *
window frame starts from the very first row of the partition.

*CURRENT ROW *
window frame boundary set at the current row.

*PERCENT_RANK() *

relative rank of a row as a percentage (0 to 1).

*CUME_DIST() *
cumulative distribution fraction of rows with value ≤ current row.

*PERCENTILE_CONT() *
interpolated percentile value (continuous).

PERCENTILE_DISC()
percentile value taken from actual data (discrete).

QUALIFY
filters rows based on a window function result
(Snowflake/BigQuery; in MySQL/Oracle, wrap in a subquery and filter with WHERE instead).

PIVOT
rotates row values into columns (native in Oracle/SQL Server; MySQL simulates with CASE WHEN + GROUP BY).
UNPIVOT

rotates columns into rows (opposite of PIVOT).
JSON_EXTRACT() **
pulls a value out of a JSON column by path.
**EXPLAIN
shows the database's query execution plan, used to analyze/optimize performance.

Basic of SQL

Abinesh.R — Sun, 23 Aug 2026 06:04:27 +0000

OOP (Object-Oriented Programming).

Abinesh.R — Sun, 23 Aug 2026 04:55:34 +0000

JAVA OOPS CONCEPTS
│
├── 1. Class
├── 2. Object
├── 3. Encapsulation
├── 4. Inheritance
├── 5. Polymorphism
└── 6. Abstraction

1. Class

Blueprint for creating objects. Defines what data (fields) and behavior (methods) objects will have.
Example
class Student {
String name;
int age;
void study() { System.out.println(name + " is studying"); }
}

2. Object
An actual instance created from the class, using new.
Example
Student s1 = new Student(); // object
s1.name = "Abinesh";
**

Encapsulation** Hiding data using private, exposing it safely via getters/setters.

Example
class Account {
private double balance;
public double getBalance() { return balance; }
public void deposit(double amt) { balance += amt; }
}

4. Inheritance
Child class reuses parent class's code via extends.
Example
class Animal {
void eat() { System.out.println("eating"); }
}
class Dog extends Animal {
void bark() { System.out.println("barking"); }
}

5. Polymorphism
Same method name, different behavior.
Overloading (compile-time) — same method, different parameters, same class.
Overriding (runtime) — child class redefines parent's method.
Example
// Overloading
void add(int a, int b) {}
void add(int a, int b, int c) {}

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

6. Abstraction

Hiding implementation details, showing only essential features. Done via abstract class or interface.

example

abstract class Shape {
abstract void draw(); // no implementation
}
class Circle extends Shape {
void draw() { System.out.println("drawing circle"); }
}

important oops concept **
**1.Constructor

Special method that runs automatically when an object is created. Same name as class, no return type. Used to initialize values.
Example
class Student {
String name;
Student(String n) { // constructor
name = n;
}
}
Student s1 = new Student("Abinesh"); // auto-called

2. this keyword

Refers to the current object. Mainly used to fix naming conflicts between instance variables and parameters.

example
class Student {
String name;
Student(String name) {
this.name = name; // this.name = instance var, name = parameter
}
}

String name;
Student(String name) {
    this.name = name;  // this.name = instance var, name = parameter
}

}
5. Instance vs Static
**
Instance members belong to each object separately.
Static members belong to the class itself — shared by all objects.
**Example
class Counter {
int id; // instance — different for each object
static int count = 0; // static — shared, one copy only
Counter() {
count++;
id = count;
}
}

basci of java

Abinesh.R — Sun, 23 Aug 2026 04:22:17 +0000

what is java?
Java is a highly popular, object-oriented programming language used to build mobile apps, web applications, and large enterprise systems.

It follows the rule "Write Once, Run Anywhere" (WORA), meaning Java code can run on any computer that supports Java without being rewritten.

📦 The Development Tools (JDK vs JRE vs JVM)
Think of these three structural pieces as boxes packed inside each other.
JVM:
The inner engine that executes the program bytes line-by-line.
JRE (Java Runtime Environment):
The middle box containing the JVM engine plus standard libraries to help run the code.
JDK (Java Development Kit):
The complete outer kit containing the JRE, compilers, and debuggers needed to build programs from scratch.

🧱 Core Concepts of Java
To understand Java, you need to know how it runs and how it handles data.1.
How Java RunsJVM (Java Virtual Machine): The engine that actually runs the Java code.
JRE (Java Runtime Environment): The toolbox that contains the JVM and packages your code.
**JDK (Java Development Kit): **The full developer kit containing the JRE and tools to write code.

2. Variables and Data Types
Variables hold data in memory.
Java requires you to state the type of data first.

int: Holds whole numbers (e.g., int age = 25;).
double: Holds decimal numbers (e.g., double price = 19.99;).
char: Holds a single letter (e.g., char grade = 'A';).
boolean: Holds true or false values (e.g., boolean isJavaFun = true;).
String: Holds text (e.g., String name = "Developer";).

3. Control Flow (Decision Making)
Control flow structures let your program make decisions or repeat tasks.

if-else statements: Run code only if a condition is true.
for and while loops:
Repeat code blocks multiple times.
💻 Your First Java Program Here is the traditional "Hello World" program in Java.
class Main {
public static void main(String[] args) {

    System.out.println("Hello, World!");
}

}
Object-Oriented Programming (OOP)
Java organizes code into "Objects" based on real-world things.
OOP relies on four main pillars:
Class: A blueprint or template for creating objects (e.g., a "Car" blueprint).
Object: An instance of a class (e.g., a specific "Red Tesla" built from the blueprint).
Inheritance: Letting a new class adopt properties of an existing class.
Polymorphism: Allowing different objects to respond to the same action in their own way.