DEV Community: vidhya murali

Java Series — Day 1

vidhya murali — Mon, 24 Aug 2026 15:49:25 +0000

Java is a high-level, object-oriented programming language created in 1995. This language is very easy to learn and widely used. It is known for its platform independence, reliability, and security. It follows one principle, that is "Write Once, Run Anywhere" principle. It supports various features like portability, robustness, simplicity, multithreading, and high performance, which makes it a popular choice for beginners as well as for developers.

It is owned by Oracle, and more than 3 billion devices run Java.

It is used for:

Mobile applications (specially Android apps)
Desktop applications
Web applications
Web servers and application servers
Games
Database connection
And much, much more!

Why Use Java?

Java works on different platforms (Windows, Mac, Linux, Raspberry Pi, etc.)
It is one of the most popular programming languages in the world
It has a large demand in the current job market
It is easy to learn and simple to use
It is open-source and free
It is secure, fast and powerful
It has huge community support (tens of millions of developers)
Java is an object oriented language which gives a clear structure to programs and allows code to be reused, lowering development costs
As Java is close to C++ and C#, it makes it easy for programmers to switch to Java or vice versa

public class Main {
  public static void main(String[] args) {
    String name = "John";
    System.out.println("Hello " + name);
  }
}

Features in Java

Simple Syntax

Java syntax is very straightforward and very easy to learn. Java removes complex features like pointers and multiple inheritance, which makes it a good choice for beginners.

In Java, the execution starts with the main method, which is the entry point of any Java application

Object Oriented

Java is a pure object-oriented language. It supports core OOP concepts like,

Class
Objects
Inheritance
Encapsulation
Abstraction
Polymorphism

Platform Independent

Java is platform-independent because of Java Virtual Machine (JVM).

When we write Java code, it is first compiled by the compiler and then converted into bytecode (which is platform-independent).
This byte code can run on any platform which has JVM installed.

Interpreted

Java code is not directly executed by the computer. It is first compiled into bytecode. This byte code is then understand by the JVM. This enables Java to run on any platform without rewriting code.

Scalable

Java can handle both small and large-scale applications. Java provides features like multithreading and distributed computing that allows developers to manage loads more easily

Portable

When we write a Java program, the code first get converted into bytecode and this bytecode does not depend on any operating system or any specific computer. We can simply execute this bytecode on any platform with the help of JVM. Since JVMs are available on most devices and that's why we can run the same Java program on different platform

Secured and Robust

Java is a reliable programming language because it can catch mistakes early while writing the code and also keeps checking for errors when the program is running. It also has a feature called exception handling that helps deal with unexpected problems smoothly.

Memory Management

Memory management in Java is automatically handled by the Java Virtual Machine (JVM).

Java garbage collector reclaim memory from objects that are no longer needed.
Memory for objects are allocated in the heap
Method calls and local variables are stored in the stack.

High Performance

Java is faster than old interpreted languages. Java program is first converted into bytecode which is faster than interpreted code. It is slower than fully compiled languages like C or C++ because of interpretation and JIT compilation process. Java performance is improve with the help of Just-In-Time (JIT) compilation, which makes it faster than many interpreted languages but not as fast as fully compiled languages.

Multithreading

Multithreading in Java allows multiple threads to run at the same time.

It improves CPU utilization and enhancing performance in applications that require concurrent task execution.
Multithreading is especially important for interactive and high-performance applications, such as games and real-time systems.
Java provides build in support for managing multiple threads. A thread is known as the smallest unit of execution within a process.

PostgreSQL JOINS

vidhya murali — Mon, 24 Aug 2026 15:22:17 +0000

JOIN

A JOIN clause is used to combine rows from two or more tables, based on a related column between them.

Let's look at a selection from the products table:

product_id	product_name	category_id
33	Geitost	4
34	Sasquatch Ale	1
35	Steeleye Stout	1
36	Inlagd Sill	8

Then, look at a selection from the categories table:

category_id	category_name
1	Beverages
2	Condiments
3	Confections
4	Dairy Products

Notice that the category_id column in the products table refers to the category_id in the categories table. The relationship between the two tables above is the category_id column.

Then, we can create the following SQL statement (with a JOIN), that selects records that have matching values in both tables:

Example

Join products to categories using the category_id column:

SELECT product_id, product_name, category_name
FROM products
INNER JOIN categories ON products.category_id = categories.category_id

Result :

roduct_id	product_name	category_name
33	Geitost	Dairy Products
34	Sasquatch Ale	Beverages
35	Steeleye Stout	Beverages
36	Inlagd Sill	Seafood

Different Types of Joins

Here are the different types of the Joins in PostgreSQL:

INNER JOIN: Returns records that have matching values in both tables
LEFT JOIN: Returns all records from the left table, and the matched records from the right table
RIGHT JOIN: Returns all records from the right table, and the matched records from the left table
FULL JOIN: Returns all records when there is a match in either left or right table
CROSS JOIN: Returns the Cartesian product of two or more tables (combines every row from the first table with every row from the second table)

create table products
(product_id int,
product_name varchar(25),
category_id int);

insert into products values
(33,'apple',4),
(34,'carrot',2),
(35,'mango',4),
(36,'goodDay',1),(37,'laddu',3);


create table categories(
category_id int,
category_name  varchar(25));

insert into categories values
(1,'biscuit'),
(2,'veggies'),
(3,'sweet'),
(4,'fruits');

select product_id,product_name , category_name 
from products inner join  categories on products.category_id=categories.category_id

*Output *:

Aggregate Functions

vidhya murali — Sat, 22 Aug 2026 17:03:15 +0000

MAX
The MAX() function returns the largest value of the selected column.

MIN
The MIN() function returns the smallest value of the selected column

Set Column Name

When you use MIN() or MAX(), the returned column will be named min or max by default. To give the column a new name, use the AS keyword

COUNT

The COUNT() function returns the number of rows that matches a specified criterion.

If the specified criterion is a column name, the COUNT() function returns the number of rows with that name.

SUM

The SUM() function returns the total sum of a numeric column.

AVG
The AVG() function returns the average value of a numeric column.

select count(*) from employees

select sum(salary) from employees
select avg(salary) from employees
select max(salary) from employees
select min(salary) from employees

select count(*) from employees
where department='IT'

select avg(salary) from employees
where department='IT'

PostgreSQL LIMIT

vidhya murali — Sat, 22 Aug 2026 16:55:14 +0000

The LIMIT Clause

The LIMIT clause is used to limit the maximum number of records to return.

Ex :

Return only the 20 first records from the customers table:

SELECT * FROM customers
LIMIT 20;

**
The OFFSET Clause**

The OFFSET clause is used to specify where to start selecting the records to return.

If you want to return 20 records, but start at number 40, you can use both LIMIT and OFFSET.

Note: The first record is number 0, so when you specify OFFSET 40 it means starting at record number 41.

SELECT * FROM customers
LIMIT 20 OFFSET 40;

PostgreSQL ORDER BY

vidhya murali — Fri, 21 Aug 2026 17:44:10 +0000

Sort Data

The ORDER BY keyword is used to sort the result in ascending or descending order.

The ORDER BY keyword sorts the records in ascending order by default. To sort the records in descending order, use the DESC keyword.

. Display all employees ordered by salary from lowest to highest.
Display all employees ordered by salary from highest to lowest.
Display unique cities in alphabetical order.
Display unique departments in alphabetical order.
Display Chennai employees ordered by salary descending.
Display IT employees ordered by salary ascending.
Display all employees ordered by city ascending and salary descending.

select * from employees_india
order by salary asc

select * from employees_india
order by salary desc

select distinct city
from employees_india 
order by city asc

select distinct department
from employees_india 
order by department asc

select * from employees_india
where city='Chennai'
order by salary desc

select * from employees_india
where department='IT'
order by salary asc

select * from employees_india
order by city asc ,salary desc

The SELECT DISTINCT Statement

vidhya murali — Fri, 21 Aug 2026 16:46:23 +0000

Day -5

The SELECT DISTINCT statement is used to return only distinct (different) values.

Inside a table, a column often contains many duplicate values and sometimes you only want to list the different (distinct) values.

CREATE TABLE employees (
    emp_id INT,
    name VARCHAR(50),
    city VARCHAR(50),
    department VARCHAR(50),
    salary INT
);

INSERT INTO employees VALUES
(101, 'Vidhya', 'Chennai', 'IT', 35000),
(102, 'Anu', 'Chennai', 'HR', 30000),
(103, 'Ravi', 'Bangalore', 'IT', 40000),
(104, 'Kumar', 'Chennai', 'Finance', 45000),
(105, 'Priya', 'Bangalore', 'HR', 32000),
(106, 'Arun', 'Mumbai', 'IT', 38000),
(107, 'Divya', 'Mumbai', 'Finance', 42000),
(108, 'Siva', 'Chennai', 'IT', 35000);

Display all unique cities
Display all unique departments.
Display unique salaries.
Display unique combinations of city and department

select distinct city 
from empolyees

select distinct department 
from empolyees

select distinct salary 
from empolyees

select distinct department,city
from empolyees

Display unique cities where salary is greater than 35000.
Display unique departments where salary is greater than 30000.
Display unique cities of employees working in the IT department.
Display unique departments of employees working in Chennai.

select distinct city 
from employees_india
where salary>35000

select distinct department 
from employees_india
where salary>30000

select distinct city 
from employees_india
where department='IT'

select distinct department 
from employees_india
where city='Chennai'

Display unique combinations of city and department for employees whose salary is greater than 35000.
Display unique cities where employees belong to either IT or Finance.
Display unique departments where employees are from Chennai or Mumbai.
Display unique salary values for employees working in IT.

select distinct city,department 
from employees_india
where salary>35000

select distinct city 
from employees_india
where department in ('IT','Finance');

select distinct department 
from employees_india
where city in ('chennai','Mumbai);

select distinct salary 
from employees_india
where department='IT';

Filter Records

The WHERE **clause **is used to filter records.

It is used to extract only those records that fulfill a specified condition.

Understanding Strong Numbers and Duck Number with Python

vidhya murali — Fri, 21 Aug 2026 15:17:06 +0000

Strong Number

A number is called a Strong Number if the sum of the factorials of its digits equals the original number.

ex: 145 =====> 1! + 4! + 5! ====>1 + 24 + 120 ===> 145

def findfactorial(n):
    fac=1
    while n>0:
        fac*=n
        n-=1

    return  fac




def IsStrongNo(num):
    total = 0
    while num>0:
        last=num%10
        factorial=findfactorial(last)
        total+=factorial
        num//=10

    return total



num=int(input("ENter a num"))
result=IsStrongNo(num)
if result==num:
    print("Strong Number")
else:
    print("Not a Strong Number")

input : 145

Duck number

A Duck Number is a number that contains at least one 0, but must not start with 0

no = input("Enter no: ")

if no[0] == '0':
    print("Not a Duck Number")
else:
    if '0' in no:
        print("Duck Number")
    else:
        print("Not a Duck Number")

Solving Number-Based Problems in Python Without Strings

vidhya murali — Fri, 21 Aug 2026 14:40:03 +0000

Task:
1) user input number: 123456 -> 1+3+5
2) user input number: 123456 -> 2 + 4 + 6
3) user input number: 123456 -> 56 34 12
4) user input number: 123456 -> 456 123
5) user input number: 123456 -> 56 45 34 23 12
6) user input number: 123456 -> Sum of 56 34 12
7) user input number: 123456 -> Sum of 456 123

# num=int(input("Enter a Number"));
num=123456

reverse=0
sumOfEven=0;
sumOfOdd=0;
while num>0:
    last=num%10;
    if last%2==0:
        sumOfEven+=last
    else:
        sumOfOdd+=last
    num=num//10;

print("Sum of even numbers: ",sumOfEven)
print("sum of Odd : ",sumOfOdd)

output :

def lastTwodigits():
    # num=int(input("Enter a Number"));
    num=123456
    original=num
    reverse=0
    while num>0:
        last=num%100
        print(last)
        num//=100

lastTwodigits()

output :

def lastThreedigits():
    # num=int(input("Enter a Number"));
    num=123456

    reverse=0
    while num>0:
        last=num%1000
        print(last)
        num//=1000

lastThreedigits()

def sumOfThree():
    num = 123456
    sum_Of_First_Three = 0
    sum_Of_Last_Three = 0

    lastThree = num % 1000       # 456
    firstThree = num // 1000     # 123

    # Sum of first three digits
    while firstThree > 0:
        last = firstThree % 10
        sum_Of_First_Three += last
        firstThree //= 10

    # Sum of last three digits
    while lastThree > 0:
        last = lastThree % 10
        sum_Of_Last_Three += last
        lastThree //= 10

    print("sumOfFirstThree : ", sum_Of_First_Three)
    print("sumOfLastThree : ", sum_Of_Last_Three)


sumOfThree()

def sumOfTwoDigits():

    num = 123456

    while num > 0:
        lastTwo = num % 100     #  56  34  12

        digit1 = lastTwo // 10    #5
        digit2 = lastTwo % 10       #6

        sum = digit1 + digit2
        print(sum)
        num //= 100


sumOfTwoDigits()

PostgreSQL Operators

vidhya murali — Thu, 20 Aug 2026 17:42:22 +0000

select * from employee
where salary >30000

select * from employee
where salary < 30000

select * from employee
where salary=40000

select * from employee
where salary >=35000

select * from employee
where age <= 25

select * from employee
where department != 'IT'  ---or <>

** AND , OR**

select * from employee
where department='IT' and salary>30000

select * from employee
where department='IT' or department='Finance'

select * from employee
where city='Chennai' and salary>30000

select * from employee
where city!='Chennai'

select * from employee
where  salary>30000 and age<30

select * from employee
where department='IT' or salary>45000

BETWEEN

select * from employee
where salary between 30000 and 40000

select * from employee
where age between 25 and 30

select * from employee
where salary not between 30000 and 40000

IN , NOT IN

select * from employee
where department in ('IT','HR','Finance')

select * from employee
where city in ('chennai','bangalore')

select * from employee
where department not in ('HR', 'Finance')

Like

remember :

% → zero or more characters
_ → exactly one character

select * from employee
where employee_name like 'v%'

select * from employee
where employee_name like '%a'

select * from employee
where employee_name like '_a%'


select * from employee
where employee_name like '_i%'

NUll

select * from employee
where city is Null

select * from employee
where city is not Null

select * 
from employee
where city='Chennai;
 and department in ('HR','IT')

select * from employee
where salary>30000 and department!='IT'

select * from employee
where city in ('Chennai','Bangalore') and salary>30000

select * from employee
where salary between 30000 and 50000
 and department='IT'

select * 
from employee
where department in ('IT','Finance') and 
salary >40000

select * from employee
where salary>=30000 and age<30
 and department in ('IT','HR')
and city!='mumbai'

PostgreSQL DROP & DELETE

vidhya murali — Thu, 20 Aug 2026 17:05:49 +0000

Day - 4

DDL vs DML Commands

DDL — Data Definition Language

it defines or change the structure of a database.
we use DDL to create, modify and delete the structure like table and columns

Ex :

CREATE - used to create a new table or database
ALTER - to change the existing structure
DROP - to delete the complete object, table, column
TRUNCATE - to remove all the rows from the table

DML — Data Manipulation Language

It is used to manipulate the datas and rows inside a table

Ex:

INSERT -to add new data
UPDATE - to modify the Existing data
DELETE - to delete the existing rows

DELETE- DML

DELETE removes rows (data) from a table

Note: Be careful when deleting records in a table! Notice the WHERE clause in the DELETE statement. The WHERE clause specifies which record(s) should be deleted.

If you omit the WHERE clause,
all records in the table will be deleted!.

DROP-DDL

DROP removes the entire database object.

DROP TABLE employee;

The DROP TABLE statement is used to drop an existing table in a database.

DELETE → ROW delete
TRUNCATE → ALL ROWS delete
DROP TABLE → ENTIRE TABLE delete
DROP COLUMN → COLUMN delete

PostgreSQL UPDATE

vidhya murali — Wed, 19 Aug 2026 17:02:38 +0000

Day 3

The UPDATE Statement

The UPDATE statement is used to modify the value(s) in existing records in a table.

UPDATE employee 
SET salary = 25000 
WHERE salary IS NULL;

to Update multiple columns

UPDATE employee
SET salary = 45000,
    gender = 'Female'
WHERE id = 1;

Update using multiple conditions

UPDATE employee
SET salary = salary + 3000
WHERE experience = 4
AND role = 'Developer';

UPDATE employee
SET department='IT'
WHERE department IS NUll;

UPDATE employee
SET salary = 30000
WHERE salary < 30000;

PostgreSQL Select and ALTER TABLE Statements

vidhya murali — Wed, 19 Aug 2026 16:30:23 +0000

Day - 2

Select Data

To retrieve data from a data base, we use the SELECT statement.

Specify Columns

By specifying the column names, we can choose which columns to select:

select name,role from employee;

Return ALL Columns

Specify a * instead of the column names to select all columns:

select * from employee

The ALTER TABLE Statement

To add a column to an existing table, we have to use the ALTER TABLE statement.

The ALTER TABLE statement is used to add, delete, or modify columns in an existing table.
The ALTER TABLE statement is also used to add and drop various constraints on an existing table.

ADD COLUMN

Alter table employee
add salary int

we can all Multiple columns

Alter table employee
add Department varchar(25),
add gender varchar(20);

to Rename column

alter table employee
rename name to emp_name

to Rename a table

alter table employee
rename to employee_details

To drop table

alter table employee_details
drop column department

Add NOT NULL

alter table employee_details
alter column emp_name set not null

Remove NOT NULL

alter table employee_details
alter column emp_name drop not null

Add and Remove DEFAULT value

alter table emp_details
alter column salary set default 25000;

alter table emp_details
alter column salary drop default ;

Setting a DEFAULT value only applies to new rows inserted into the table after the constraint is added. It does not update existing rows that already contain NULL values.

Add Primary Key

alter table emp_details
add primary key(id);

Alter Table statment used to change Table Structure

ADD COLUMN
DROP COLUMN
RENAME COLUMN ... TO
ALTER COLUMN ... TYPE
ALTER COLUMN ... SET NOT NULL
ALTER COLUMN ... DROP NOT NULL
ALTER COLUMN ... SET DEFAULT
ALTER COLUMN ... DROP DEFAULT
ADD CONSTRAINT ... UNIQUE
ADD CONSTRAINT ... CHECK