Download Free Java Notes PDF for Easy Learning
0 likes29 views
Our Free Java Notes PDF is the perfect study companion for beginners and students. These notes are created by industry experts at CodersNote.com by Amend Ed Tech, focusing on clarity, simplicity, and practical understanding. Inside, you'll find well-structured Java notes covering core concepts, including variables, data types, operators, loops, OOPs, exceptions, collections, and more. Whether you're preparing for exams or interviews, this Java notes PDF will help you learn effectively.
![Writing a Simple Java Program
1. Open Eclipse IDE.
2. Create a New Java Project: File > New > Java Project.
3. Write a Simple Program:
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, World!");
}
}
4. Run the Program: Right-click on the file and select "Run As" > "Java
Application".
Summary
JVM: Executes Java bytecode, ensuring platform independence.
JDK: Provides tools for Java development, including the compiler and
debugger.
JRE: Runs Java applications, providing necessary libraries and JVM.
Further Learning
In the upcoming sessions, we will delve deeper into Java’s core concepts,
including data types, control structures, and advanced OOP features. Ensure you
have Eclipse installed and are familiar with its basic operations as we proceed with
hands-on coding exercises.
Introduction
In this session, we'll explore the concept of RAM (Random Access Memory) and
its functionality in computer systems. RAM is a crucial component in computing,
enabling quick access and processing of data by the CPU.
Basic 6
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-7-320.jpg)
![Inside the class, write the main method which serves as the entry point for
the program.
3. Example Code:
public class Main {
public static void main(String[] args) {
// Print a message to the console
System.out.println("Learn to code");
// Examples of using different data types
byte b = 10;
short s = 1000;
int i = 100000;
long l = 10000000000L;
// Print the values of the variables
System.out.println("Byte value: " + b);
System.out.println("Short value: " + s);
System.out.println("Int value: " + i);
System.out.println("Long value: " + l);
}
}
1. Running the Code:
Execute the code in the IDE to see the output in the console.
The output will display the message and the values of different data types.
Understanding Debugging in Java
Case Sensitivity: Java is case-sensitive, meaning System and system are
different identifiers.
Comments: Use // for single-line comments and /* ... */ for multi-line
comments. Comments are ignored during code execution and are used for
documentation.
Basic 9
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-10-320.jpg)
![String result = (age >= 18) ? "Eligible to vote" : "Not eligible to vote";
Example with User Input:
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("Enter your age: ");
int age = scanner.nextInt();
String result = (age >= 18) ? "Eligible to vote" : "Not eligible to vote";
System.out.println(result);
}
}
Summary
Arithmetic Operators: Perform basic mathematical operations.
Type Casting: Convert data types from one form to another.
Increment/Decrement Operators: Increase or decrease values by one.
Relational Operators: Compare values and return boolean results.
Logical Operators: Combine multiple boolean expressions.
Assignment Operators: Assign and modify values in a concise manner.
Ternary Operator: Provide a shorthand for if-else statements.
Understanding these operators is crucial for writing effective and efficient Java
programs. Practice using them in various scenarios to strengthen your grasp of
their functionalities.
Introduction
Basic 23
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-24-320.jpg)
![Step 2: Checking for Leap Year
Inside the valid year condition, we check if the year is a leap year.
if (year > 0 && year <= 9999) {
if (year % 400 == 0) {
System.out.println("Leap year");
} else if (year % 100 == 0) {
System.out.println("Not a leap year");
} else if (year % 4 == 0) {
System.out.println("Leap year");
} else {
System.out.println("Not a leap year");
}
} else {
System.out.println("Invalid year");
}
Example Code
Here is the complete code with all conditions checked and properly ordered:
import java.util.Scanner;
public class LeapYearChecker {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Enter a year: ");
int year = scanner.nextInt();
if (year > 0 && year <= 9999) { // Primary condition: valid year
if (year % 400 == 0) { // Century year divisible by 400
System.out.println("Leap year");
} else if (year % 100 == 0) { // Century year not divisible by 400
System.out.println("Not a leap year");
} else if (year % 4 == 0) { // Normal year divisible by 4
Basic 25
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-26-320.jpg)
![int sum = 0;
for (int i = 1; i <= num / 2; i++) {
if (num % i == 0) {
sum += i;
}
}
3. Output Section
String result = (num == sum) ? "Perfect number" : "Not a perfect number";
System.out.println(result);
Complete Code
import java.util.Scanner;
public class PerfectNumber {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int num = scanner.nextInt();
int sum = 0;
for (int i = 1; i <= num / 2; i++) {
if (num % i == 0) {
sum += i;
}
}
String result = (num == sum) ? "Perfect number" : "Not a perfect numbe
r";
System.out.println(result);
}
}
Intermediat 3
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-35-320.jpg)
![Efficiency Improvement
Instead of iterating up to num-1 , iterate only up to num/2 .
Example: For num = 100 , factors are within 1 to 50 .
Prime Number Exercise
Task: Determine if a number is prime.
1. Input a number.
2. Check if it has any divisors other than 1 and itself.
3. Output "Prime number" or "Not a prime number".
Code Outline
import java.util.Scanner;
public class PrimeNumber {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int num = scanner.nextInt();
boolean isPrime = true;
for (int i = 2; i <= num / 2; i++) {
if (num % i == 0) {
isPrime = false;
break;
}
}
String result = isPrime ? "Prime number" : "Not a prime number";
System.out.println(result);
}
}
Conclusion
Intermediat 4
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-36-320.jpg)
![public class PrimeNumber {
public static void main(String[] args) {
Scanner ss = new Scanner(System.in);
int num = ss.nextInt();
boolean isPrime = true;
for (int i = 2; i <= num / 2; i++) {
if (num % i == 0) {
isPrime = false;
break;
}
}
if (isPrime) {
System.out.println(num + " is a prime number");
} else {
System.out.println(num + " is not a prime number");
}
}
}
Detailed Steps
1. Input Handling: Scan the number using Scanner .
2. Flag Initialization: Initialize a boolean flag isPrime to true .
3. Loop for Divisibility Check:
Iterate from 2 to ( n/2 ) (since a larger factor would have a corresponding
smaller factor).
If ( n % i == 0 ), set isPrime to false and break the loop.
4. Output Result: After the loop, check the flag:
If isPrime is true , print that ( n ) is a prime number.
Intermediat 6
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-38-320.jpg)
![Otherwise, print that ( n ) is not a prime number.
Prime Numbers in a Given Range
Problem Extension
To list all prime numbers within a given range (e.g., 1 to 50):
1. Iterate through each number in the range.
2. Use the prime number check logic for each number.
Code Explanation
public class PrimeNumberRange {
public static void main(String[] args) {
Scanner ss = new Scanner(System.in);
int range = ss.nextInt();
for (int num = 2; num <= range; num++) {
boolean isPrime = true;
for (int i = 2; i <= num / 2; i++) {
if (num % i == 0) {
isPrime = false;
break;
}
}
if (isPrime) {
System.out.print(num + " ");
}
}
}
}
Detailed Steps
Intermediat 7
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-39-320.jpg)
![1. Input Handling: Scan the upper limit of the range.
2. Outer Loop for Range: Iterate through each number from 2 to the given range.
3. Prime Check for Each Number:
Initialize a boolean flag isPrime to true for each number.
Iterate from 2 to ( num/2 ) to check for divisibility.
If a divisor is found, set isPrime to false and break the loop.
4. Output Prime Numbers: If isPrime remains true after the inner loop, print the
number.
Optimizations and Best Practices
Reducing Iterations
Instead of checking up to ( n-1 ), check up to ( sqrt{n} ) for efficiency.
Using a Boolean Array for Multiple Queries
For handling multiple prime checks efficiently, especially in a range, use the Sieve
of Eratosthenes algorithm.
Example: Sieve of Eratosthenes
Code Explanation
public class SieveOfEratosthenes {
public static void main(String[] args) {
int range = 50; // Example range
boolean[] isPrime = new boolean[range + 1];
// Initialize all entries as true
Arrays.fill(isPrime, true);
isPrime[0] = false;
isPrime[1] = false;
for (int p = 2; p * p <= range; p++) {
Intermediat 8
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-40-320.jpg)
![if (isPrime[p]) {
for (int i = p * p; i <= range; i += p) {
isPrime[i] = false;
}
}
}
for (int i = 2; i <= range; i++) {
if (isPrime[i]) {
System.out.print(i + " ");
}
}
}
}
Detailed Steps
1. Initialize Array: Create a boolean array isPrime initialized to true .
2. Mark Non-Primes: For each prime p , mark its multiples as false .
3. Output Primes: Print all indices that remain true .
Conclusion
Understanding prime numbers and implementing efficient algorithms to check for
primes and list them within a range are fundamental concepts in programming and
number theory. Practice these concepts with different ranges and further optimize
the code for better performance.
Overview
This study guide will cover the following key concepts and coding techniques for
understanding and implementing Armstrong numbers and number crunching in
Java. We'll break down the process, code, and logic in a detailed and easy-to-
understand manner.
Intermediat 9
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-41-320.jpg)
![Key Concepts
1. Number Crunching
2. Armstrong Numbers
3. For Loops and While Loops
4. Flag Concept and Reset Importance
5. Efficient Coding Practices
Detailed Notes
Number Crunching
Number crunching refers to performing a series of calculations on numerical data.
It's a fundamental skill in programming that involves iterating over numbers,
performing mathematical operations, and efficiently managing data.
Armstrong Numbers
An Armstrong number (also known as a Narcissistic number) is a number that is
equal to the sum of its own digits each raised to the power of the number of digits.
Example:
For a 3-digit number like 153:
[ 1^3 + 5^3 + 3^3 = 153 ]
Thus, 153 is an Armstrong number.
Steps to Determine an Armstrong Number
1. Scan the Input Number: Read the number provided by the user.
2. Count the Digits: Determine the number of digits in the input number.
3. Access Each Digit: Extract each digit from the number.
4. Raise to Power: Raise each digit to the power of the total number of digits.
5. Sum the Values: Sum all the powered values.
6. Compare the Sum: Check if the sum is equal to the original number.
Intermediat 10
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-42-320.jpg)
![Coding Implementation
Here is a step-by-step breakdown of the code used to determine if a number is an
Armstrong number in Java:
Step 1: Read the Input Number
import java.util.Scanner;
public class ArmstrongNumber {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Enter a number: ");
int num = scanner.nextInt();
scanner.close();
if (isArmstrong(num)) {
System.out.println(num + " is an Armstrong number");
} else {
System.out.println(num + " is not an Armstrong number");
}
}
// Function to check if a number is an Armstrong number
public static boolean isArmstrong(int num) {
int count = countDigits(num);
int sum = calculateSumOfPowers(num, count);
return sum == num;
}
// Function to count the number of digits
public static int countDigits(int num) {
int count = 0;
while (num != 0) {
num /= 10;
count++;
Intermediat 11
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-43-320.jpg)
![4. Compare the Sum with the Original Number:
In the main function isArmstrong , check if the computed sum is equal to the
original number.
Exercise
To practice and understand the concept better, try writing a program to find all
Armstrong numbers in a given range (e.g., 1 to 10,000).
import java.util.ArrayList;
import java.util.List;
public class ArmstrongNumberRange {
public static void main(String[] args) {
int start = 1;
int end = 10000;
List<Integer> armstrongNumbers = findArmstrongNumbersInRange(start,
end);
System.out.println("Armstrong numbers between " + start + " and " + end
+ ": " + armstrongNumbers);
}
public static List<Integer> findArmstrongNumbersInRange(int start, int end)
{
List<Integer> armstrongNumbers = new ArrayList<>();
for (int num = start; num <= end; num++) {
if (isArmstrong(num)) {
armstrongNumbers.add(num);
}
}
return armstrongNumbers;
}
public static boolean isArmstrong(int num) {
int count = countDigits(num);
int sum = calculateSumOfPowers(num, count);
Intermediat 13
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-45-320.jpg)
![Detailed Walkthrough: Example Pattern
Step-by-Step Explanation:
1. Rows and Columns:
The pattern consists of 5 rows and 9 columns.
2. Conditions for Spaces and Stars:
First Condition: Space is printed when j < num - i
For Row 1 ( i=1 ), j < 5 - 1 = 4 (print spaces until j=4 )
For Row 2 ( i=2 ), j < 5 - 2 = 3 (print spaces until j=3 )
Continue similarly for other rows.
Second Condition: Print stars after the spaces.
Code Implementation:
import java.util.Scanner;
public class Pattern {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt(); // User input
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= 2 * n - 1; j++) {
if (j < n - i + 1 || j > n + i - 1) {
System.out.print(" ");
} else {
System.out.print("*");
}
}
System.out.println(); // Move to the next line after each row
}
}
}
Explanation:
Intermediat 20
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-52-320.jpg)
![import java.util.Scanner;
public class HollowSquarePattern {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt(); // User input
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i == 1 || i == n || j == 1 || j == n) {
System.out.print("* ");
} else {
System.out.print(" ");
}
}
System.out.println(); // Move to the next line after each row
}
}
}
Explanation:
1. Outer Loop: Runs from 1 to n for rows.
2. Inner Loop: Runs from 1 to n for columns.
3. Conditions:
Print stars at the borders ( i == 1 , i == n , j == 1 , j == n ).
Print spaces for inner cells.
Output:
Input: 5
Output:
* * * * *
* *
* *
Intermediat 22
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-54-320.jpg)
![Implementing the Solution
1. Printing a Rectangle Box Pattern:
Basic structure to print stars ( ) in a rectangle box:
for (int i = 1; i <= num; i++) {
for (int j = 1; j <= 2 * num - 1; j++) {
System.out.print("*");
}
System.out.println();
}
2. Adding Spaces and Stars:
Determine where to print spaces and stars based on the position.
Use conditions to control the printing:
Spaces before stars: if (j <= num - i) System.out.print(" ");
Stars after spaces: else System.out.print("*");
3. Pattern with Number Decreasing and Increasing:
Determine the positions for spaces and stars, ensuring correct placement:
if (j <= num - i) {
System.out.print(" ");
} else if (j <= num + i - 1) {
System.out.print("*");
}
Example Code: Diamond Shape
public class PatternExample {
public static void main(String[] args) {
int num = 5; // Example input
for (int i = 1; i <= num; i++) {
Intermediat 24
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-56-320.jpg)
![Example Code: Diagonal String Pattern
import java.util.Scanner;
public class StringPatternExample {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String input = scanner.nextLine();
int num = input.length();
for (int i = 1; i <= num; i++) {
for (int j = 1; j <= 2 * num - 1; j++) {
if (j == i || j == (2 * num - i)) {
System.out.print(input.charAt(i - 1));
} else {
System.out.print(" ");
}
}
System.out.println();
}
}
}
Summary
Pattern Coding involves understanding the structure and applying loops and
conditions.
Handling Inequality in rows and columns requires careful condition
management.
Advanced Patterns can include characters and strings, adding complexity but
following similar logical rules.
By breaking down the problem, identifying patterns, and applying correct
conditions, various intricate patterns can be created effectively using basic loops
and conditions in Java.
Intermediat 26
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-58-320.jpg)
![Definition: An array is a data structure that stores a collection of elements of
the same data type.
Purpose: It allows efficient management of multiple data items under a single
name, reducing the need for multiple variables.
Array Creation
Declaration: Arrays are declared with a specific data type and size in Java.
int[] a = new int[5];
int[] denotes an array of integers.
new int[5] allocates memory for 5 integer elements.
Memory Allocation: When an array is declared, memory is allocated in the
RAM:
Each element in the array occupies a contiguous memory location.
Indexing starts from 0 up to length-1 .
Accessing Array Elements
Indexing: Elements in an array are accessed using their index:
a[0] = 748; // Assigning value to the first element
int value = a[0]; // Accessing value from the first element
Indexing starts at 0 ( a[0] refers to the first element).
Inputting and Outputting Array Elements
Inputting Values: Using Scanner for user input:
Scanner sc = new Scanner(System.in);
for (int i = 0; i < a.length; i++) {
Intermediat 27
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-59-320.jpg)
![a[i] = sc.nextInt();
}
Reads input values and assigns them to array elements.
Outputting Values: Printing array elements:
for (int i = 0; i < a.length; i++) {
System.out.println("Element at index " + i + ": " + a[i]);
}
Outputs each element along with its index.
Efficiency with Loops
For Loops: Using loops for efficient operations:
// Initialization, Condition, Increment
for (int i = 0; i < a.length; i++) {
// Perform operations with array elements
}
Simplifies repetitive tasks such as assigning values or printing elements.
Important Concepts
Array Size: Determined at declaration ( new int[5] allocates space for 5 integers).
Indexing: Starts from 0 to length-1 .
Looping through Arrays: Enhances efficiency in tasks like input, output, and
manipulation.
Conclusion
Arrays are fundamental in programming, crucial for both product-based and
service-based companies.
Practice is essential for mastering array operations such as creation, insertion,
searching, deletion, and sorting.
Intermediat 28
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-60-320.jpg)
![Next Steps
Explore advanced array operations such as insertion, searching, deletion, and
sorting in upcoming sessions.
Practice solving array-based problems to strengthen understanding and
proficiency.
Introduction to Array Insertion
Understanding Array Limits
An array in Java is a fixed-size data structure where each element is indexed
sequentially from 0 to size-1.
Attempting to access or insert elements beyond the array's declared size
leads to ArrayIndexOutOfBoundsException .
Efficient Insertion Concept
Efficient code is characterized by minimal time and space complexity. For
arrays, efficient insertion involves shifting elements to accommodate new
entries.
Insertion Process
Step-by-Step Insertion Methodology
1. Array Declaration and Initialization
Start by declaring an array of a predetermined size or dynamically based
on input.
int[] a = new int[10]; // Example array of size 10
2. Prompt for Array Size
Ask the user for the actual number of elements they intend to insert into
the array ( size ).
Intermediat 29
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-61-320.jpg)
![System.out.println("Enter the number of elements:");
int size = scanner.nextInt(); // Assuming 'scanner' is initialized for input
3. Populating the Array
Use a loop to populate the array with values up to the specified size.
System.out.println("Enter " + size + " elements:");
for (int i = 0; i < size; i++) {
a[i] = scanner.nextInt(); // Read and store each element in the array
}
4. Insertion Function
Define a function/method to insert a new element at a specified position
( pos ) in the array.
public static void insertElement(int[] a, int size, int element, int pos) {
// Shift elements to the right to make space for the new element
for (int i = size - 1; i >= pos; i--) {
a[i + 1] = a[i];
}
// Insert the new element at the specified position
a[pos] = element;
// Increment the size of the array
size++;
}
5. Implementation of Insertion
Call the insertElement method after populating the array to add a new element
( element ) at a specific position ( pos ).
insertElement(a, size, 26, 3); // Example: Inserting 26 at position 3
6. Output the Updated Array
Intermediat 30
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-62-320.jpg)
![Display the updated array to verify the insertion operation.
System.out.println("Array after insertion:");
for (int i = 0; i < size; i++) {
System.out.println("Index " + i + ": " + a[i]);
}
Summary
Key Points:
Array size is fixed once declared.
Insertion requires shifting existing elements to accommodate new entries.
Efficient insertion minimizes both time and space complexities.
Implementation Tips:
Always handle edge cases, such as inserting at the beginning or end of
the array.
Use a backward traversal loop for shifting elements during insertion to
avoid overwriting values prematurely.
Conclusion
Understanding array insertion in Java involves grasping the concepts of array
limits, efficient coding practices, and the step-by-step methodology for safely
inserting elements. By mastering this process, programmers can effectively
manage data within fixed-size arrays, ensuring optimal performance and reliability
in their applications.
Overview
Array deletion involves removing an element from a specific index in an array and
shifting subsequent elements to fill the gap. This operation is essential for
managing dynamic arrays and efficiently using memory space.
Detailed Steps and Explanation
Intermediat 31
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-63-320.jpg)
![1. Initialization and Setup
Start with an array a and initialize its size ( size ) and capacity ( capacity ).
Ensure size tracks the number of elements actually stored in the array,
while capacity indicates the maximum number of elements it can hold
without resizing.
2. Deleting an Element
To delete an element at index pos :
Adjust Size: Decrease the size by one ( size-- ) to reflect the removal of
one element.
Shift Elements: Traverse the array from pos to size-1 and shift each
element one position to the left.
for (int i = pos; i < size - 1; i++) {
a[i] = a[i + 1];
}
After the loop completes, the last position ( size-1 ) will contain a
duplicate of the previous last element, which is now redundant.
3. Update Size
Ensure to update the size after shifting elements:
size--;
4. Edge Cases
Bounds Checking: Always ensure that the index pos is within the valid
range ( 0 to size-1 ) to avoid accessing out-of-bound memory.
Memory Management: If the array reaches its capacity ( capacity ), consider
resizing operations to accommodate more elements efficiently.
5. Example Implementation
Intermediat 32
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-64-320.jpg)
![public class ArrayDeletionExample {
private int[] a;
private int size;
private int capacity;
public ArrayDeletionExample(int capacity) {
this.a = new int[capacity];
this.size = 0;
this.capacity = capacity;
}
public void deleteElement(int pos) {
if (pos < 0 || pos >= size) {
System.out.println("Invalid position to delete.");
return;
}
// Shift elements
for (int i = pos; i < size - 1; i++) {
a[i] = a[i + 1];
}
// Update size
size--;
}
}
Practical Application
Scenario: Suppose we have an array representing student scores. Deleting a
score at a specific index ( pos ) allows us to manage and update the array
dynamically as scores change or new scores are added.
Implementation: By following the steps above, we ensure that our array
remains consistent and efficient, managing memory effectively without
unnecessary gaps or duplicates.
Intermediat 33
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-65-320.jpg)
![Conclusion
Understanding array deletion is crucial for anyone working with data structures
and algorithms. It forms the basis for more complex operations like sorting and
searching, enabling efficient manipulation of data stored in arrays.
Introduction
In this tutorial session, we'll delve into the fundamental concepts of searching and
sorting arrays in Java. These operations are essential for organizing and retrieving
data efficiently in programming.
Searching Arrays
1. Searching by Value:
To search for a specific value in an array, traverse through each element and
compare it with the target value ( element ).
System.out.println("Enter the array size:");
int size = sc.nextInt();
int[] a = new int[size];
// Input array elements
for (int i = 0; i < size; i++) {
a[i] = sc.nextInt();
}
System.out.println("Enter the value to search:");
int element = sc.nextInt();
// Search for element in the array
for (int i = 0; i < size; i++) {
if (a[i] == element) {
System.out.println("Element found at index: " + i);
break;
Intermediat 34
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-66-320.jpg)
![}
}
2. Searching by Index:
If you know the index ( position ) and want to retrieve the element directly:
System.out.println("Enter the position to search:");
int position = sc.nextInt();
System.out.println("Element at position " + position + ": " + a[position]);
Sorting Arrays
1. Bubble Sort:
Bubble sort is a straightforward sorting algorithm where adjacent elements are
compared and swapped if necessary to arrange elements in ascending or
descending order.
// Bubble Sort implementation
for (int i = 0; i < a.length - 1; i++) {
for (int j = 0; j < a.length - i - 1; j++) {
if (a[j] > a[j + 1]) {
// Swap elements
int temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
}
2. Selection Sort:
Selection sort works by repeatedly finding the minimum element from the
unsorted part of the array and swapping it with the first unsorted element.
Intermediat 35
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-67-320.jpg)
![// Selection Sort implementation
for (int i = 0; i < a.length - 1; i++) {
int minIndex = i;
for (int j = i + 1; j < a.length; j++) {
if (a[j] < a[minIndex]) {
minIndex = j;
}
}
// Swap elements
int temp = a[minIndex];
a[minIndex] = a[i];
a[i] = temp;
}
Practical Application
Searching Use Case: Finding a specific student record by ID in a student
database stored as an array.
Sorting Use Case: Organizing a list of scores in ascending order to determine
top performers.
Conclusion
Understanding these fundamental operations—searching and sorting—is crucial
for efficient data manipulation in programming. Mastery of these concepts forms
the basis for tackling more complex algorithms and data structures.
Intermediat 36
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-68-320.jpg)
![Advanced
Introduction
In this session, we will learn how to find the smallest and second smallest
elements in an array efficiently. This problem is crucial for coding interviews and
exams, where time complexity constraints are common. We will discuss:
1. Basic concept and naive solution.
2. Efficient solution with time complexity considerations.
Concepts Covered
Array Basics: Understanding how to manipulate arrays.
Time Complexity: Importance of optimizing code to run within permissible
limits.
Finding Smallest and Second Smallest Elements: Using single and nested
loops.
Finding the Smallest Element
To find the smallest element in an array, follow these steps:
1. Initialize a variable min to store the minimum value.
2. Iterate through the array and update min whenever a smaller element is
found.
int min = array[0]; // Assume the first element is the smallest
for (int i = 1; i < array.length; i++) {
if (array[i] < min) {
min = array[i]; // Update min if a smaller element is found
}
}
System.out.println("The smallest element is: " + min);
Advanced 1
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-69-320.jpg)
![Finding the Second Smallest Element (Naive Approach)
The naive approach involves sorting the array and picking the first two elements.
This method, however, has a time complexity of O(n log n) due to sorting.
Arrays.sort(array);
int smallest = array[0];
int secondSmallest = array[1];
System.out.println("The smallest element is: " + smallest);
System.out.println("The second smallest element is: " + secondSmallest);
Efficient Approach with O(n) Time Complexity
To find the second smallest element efficiently:
1. Initialize two variables min and secondMin to store the smallest and second
smallest elements, respectively.
2. Iterate through the array to find these elements in a single pass.
Step-by-Step Implementation:
1. Initialize min and secondMin :
int min = Integer.MAX_VALUE;
int secondMin = Integer.MAX_VALUE;
2. Iterate through the array:
for (int i = 0; i < array.length; i++) {
if (array[i] < min) {
// Update secondMin before changing min
secondMin = min;
min = array[i];
} else if (array[i] < secondMin && array[i] != min) {
// Update secondMin if current element is not equal to min
secondMin = array[i];
Advanced 2
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-70-320.jpg)
![}
}
3. Handle Edge Cases:
Ensure the array has at least two distinct elements.
Code Example
public class SecondSmallest {
public static void main(String[] args) {
int[] array = {2, 4, 1, 3, 5, -2, -4};
if (array.length < 2) {
System.out.println("Array must have at least two elements.");
return;
}
int min = Integer.MAX_VALUE;
int secondMin = Integer.MAX_VALUE;
for (int i = 0; i < array.length; i++) {
if (array[i] < min) {
secondMin = min;
min = array[i];
} else if (array[i] < secondMin && array[i] != min) {
secondMin = array[i];
}
}
if (secondMin == Integer.MAX_VALUE) {
System.out.println("No second smallest element found.");
} else {
System.out.println("The smallest element is: " + min);
System.out.println("The second smallest element is: " + secondMin);
}
Advanced 3
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-71-320.jpg)
![}
}
Explanation of the Efficient Approach
Initialization: We start with min and secondMin set to Integer.MAX_VALUE to ensure
any element in the array will be smaller initially.
Single Pass: We iterate through the array once. The first condition ( array[i] <
min ) ensures that we always have the smallest element in min . The second
condition ( array[i] < secondMin && array[i] != min ) ensures that secondMin is the smallest
element greater than min .
Edge Cases: If the array has fewer than two distinct elements, we handle it by
checking the length and final values of min and secondMin .
Summary
Understanding Array Manipulation: Finding specific elements using loops.
Importance of Time Complexity: Reducing nested loops to optimize
performance.
Hands-On Coding: Implementing both naive and efficient solutions.
By following these steps and understanding the code, you can efficiently find the
smallest and second smallest elements in an array, a crucial skill for technical
interviews and exams.
Introduction
The sliding window technique is a powerful method used to solve various array-
related problems. It involves creating a "window" that slides over the array to
evaluate a subset of elements at a time. This tutorial focuses on finding the
maximum value within each subset (window) of a fixed size.
Problem Explanation
Given an array of integers and a window size ( k ), the goal is to find the
maximum value within each window as it slides from the start to the end of the
Advanced 4
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-72-320.jpg)
![array. For example, if the array is [3, 5, 4, 8, 6, 7, 2, 9] and the window size is 3,
the task is to find the maximum values for each subset of 3 consecutive elements.
Steps to Solve the Problem
1. Understanding the Inputs and Outputs:
Input: An array of integers and a window size ( k ).
Output: An array of maximum values from each sliding window.
2. Initialize Variables:
An array to store the input values.
Variables to hold the size of the array and the window size ( k ).
A variable to track the maximum value in the current window.
3. Sliding Window Mechanism:
Use nested loops to iterate through the array.
The outer loop defines the starting point of the window.
The inner loop iterates through the elements within the window to find the
maximum value.
Update the maximum value as needed while iterating through the window.
Example
Consider the array [3, 5, 4, 8, 6, 7, 2, 9] with a window size ( k = 3 ):
1. The first window is [3, 5, 4]. The maximum value is 5.
2. The second window is [5, 4, 8]. The maximum value is 8.
3. The third window is [4, 8, 6]. The maximum value is 8.
4. The fourth window is [8, 6, 7]. The maximum value is 8.
5. The fifth window is [6, 7, 2]. The maximum value is 7.
6. The sixth window is [7, 2, 9]. The maximum value is 9.
The output array of maximum values is [5, 8, 8, 8, 7, 9].
Advanced 5
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-73-320.jpg)
![Implementation in Java
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// Input size of the array
System.out.println("Enter the size of the array:");
int n = scanner.nextInt();
// Create the array and take input values
int[] array = new int[n];
System.out.println("Enter the elements of the array:");
for (int i = 0; i < n; i++) {
array[i] = scanner.nextInt();
}
// Input the window size
System.out.println("Enter the window size:");
int k = scanner.nextInt();
// Implement the sliding window algorithm
for (int i = 0; i <= n - k; i++) {
int max = array[i];
for (int j = i; j < i + k; j++) {
if (array[j] > max) {
max = array[j];
}
}
System.out.print(max + " ");
}
}
}
Advanced 6
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-74-320.jpg)
![Introduction
In this session, we delve into solving an array rotation problem frequently
encountered in product-based company interviews. The goal is to rotate an array
to the right by a given number of positions. We'll explore a detailed step-by-step
approach to understand the problem, develop a solution, and optimize the code.
Problem Explanation
Given an array and a number k , rotate the array to the right by k positions. For
example, rotating the array [1, 2, 3, 4, 5] to the right by 2 positions results in [4, 5, 1, 2,
3] .
Steps to Approach the Problem
1. Understand the Input and Output:
Input: Array [1, 2, 3, 4, 5] , Rotation count k = 2
Output: Array [4, 5, 1, 2, 3]
2. Identify Key Concepts:
Rotation: Shifting elements of the array to the right.
Modulo Operation: Helps in wrapping around the array indices.
Visualizing the Rotation
Consider an array: [1, 2, 3, 4, 5]
Rotate by 1: [5, 1, 2, 3, 4]
Rotate by 2: [4, 5, 1, 2, 3]
Explanation:
Each element is shifted right by one position.
The last element wraps around to the beginning.
Advanced 8
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-76-320.jpg)
![Detailed Solution
Initial Approach
1. Manual Rotation:
Take the last element and insert it at the beginning.
Repeat this k times.
Code Implementation (Initial Approach)
import java.util.Scanner;
public class ArrayRotation {
public static void main(String[] args) {
Scanner ss = new Scanner(System.in);
int n = ss.nextInt();
int[] array = new int[n];
for (int i = 0; i < n; i++) {
array[i] = ss.nextInt();
}
int rotate = ss.nextInt();
for (int k = 1; k <= rotate; k++) {
int temp = array[n - 1];
for (int i = n - 2; i >= 0; i--) {
array[i + 1] = array[i];
}
array[0] = temp;
}
for (int i = 0; i < n; i++) {
System.out.print(array[i] + " ");
}
}
}
Advanced 9
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-77-320.jpg)
![Explanation:
Outer Loop: Runs rotate times.
Inner Loop: Shifts elements to the right.
Temp Variable: Holds the last element to place it at the beginning.
Optimized Approach
1. Modulo Operation:
Avoid unnecessary rotations by reducing k using k = k % n .
Create a new array b to hold rotated values.
Code Implementation (Optimized Approach)
import java.util.Scanner;
public class ArrayRotation {
public static void main(String[] args) {
Scanner ss = new Scanner(System.in);
int n = ss.nextInt();
int[] array = new int[n];
for (int i = 0; i < n; i++) {
array[i] = ss.nextInt();
}
int rotate = ss.nextInt();
rotate = rotate % n; // Optimized rotation count
int[] b = new int[n];
for (int i = 0; i < n; i++) {
b[(i + rotate) % n] = array[i];
}
for (int i = 0; i < n; i++) {
System.out.print(b[i] + " ");
}
Advanced 10
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-78-320.jpg)
![element are less than the key and all elements on the right are greater than the
key. This problem is useful for understanding array manipulation and optimizing
operations within constraints.
Key Concepts
1. Array Basics: Understanding basic operations on arrays, such as iteration and
element comparison.
2. Two-Pointer Technique: Using two pointers to traverse the array from both
ends.
3. Conditional Logic: Applying conditions to determine when to perform swaps.
4. Optimization: Minimizing the number of operations needed to achieve the
desired arrangement.
Problem Statement
Given an array and a key value, rearrange the array so that all elements less than
the key are on the left, and all elements greater than the key are on the right.
Determine the minimum number of swaps required to achieve this arrangement.
Example
Array: [2, 5, 3, 6, 7, 1]
Key:
3
Desired Output: Minimum number of swaps to rearrange the array.
Steps to Solve the Problem
1. Initialize Variables:
I : Pointer starting from the left (index 0).
J : Pointer starting from the right (index n-1).
count : To keep track of the number of swaps.
2. Iterate Until Pointers Meet:
Loop until I is less than J .
Advanced 12
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-80-320.jpg)
![3. Left Pointer Condition:
If array[I] is less than or equal to the key, increment I .
Otherwise, pause at the current position.
4. Right Pointer Condition:
If array[J] is greater than or equal to the key, decrement J .
Otherwise, pause at the current position.
5. Swap Elements:
If the current element at I is greater than the key and the current element
at J is less than the key, swap them.
Increment the count of swaps.
Move I and J to the next positions.
6. Edge Cases:
Ensure that the algorithm handles cases where elements are already in the
correct position.
Handle duplicate values gracefully.
Example Walkthrough
Consider the array [2, 5, 3, 6, 7, 1] and key 3 .
1. Initialization:
I = 0 , J = 5 , count = 0
2. Iteration:
First iteration: I = 0 , J = 5
array[I] = 2 (less than key) -> I++
array[J] = 1 (less than key) -> Pause J
Second iteration: I = 1 , J = 5
array[I] = 5 (greater than key) -> Pause I
array[J] = 1 (less than key) -> Swap array[I] and array[J]
Advanced 13
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-81-320.jpg)
![count++ , I++ , J--
Continue this process until I meets or exceeds J .
Implementation in Java
import java.util.Scanner;
public class MinimumSwaps {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt(); // Array size
int[] array = new int[n];
// Reading array elements
for (int i = 0; i < n; i++) {
array[i] = scanner.nextInt();
}
int key = scanner.nextInt(); // Key value
int count = 0; // Swap count
int i = 0, j = n - 1; // Pointers
while (i < j) {
while (i < j && array[i] <= key) {
i++;
}
while (i < j && array[j] > key) {
j--;
}
if (i < j) {
// Swap elements
int temp = array[i];
array[i] = array[j];
array[j] = temp;
Advanced 14
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-82-320.jpg)
![Definitions
One-Dimensional Array: A list of elements, each identified by a single index.
Two-Dimensional Array: A grid or matrix where each element is identified by
two indices, representing rows and columns.
Three-Dimensional Array: Conceptually a cube of data, identified by three
indices (row, column, and depth).
Syntax and Initialization
One-Dimensional Array
int[] a = new int[5];
This creates an array a of size 5.
Two-Dimensional Array
int[][] a = new int[5][5];
This creates a 5x5 matrix, an array of arrays.
Visualization
Consider a 2D array:
[
[0, 1, 2, 3, 4],
[0, 1, 2, 3, 4],
[0, 1, 2, 3, 4],
[0, 1, 2, 3, 4],
[0, 1, 2, 3, 4]
]
Each element in this array can be accessed using two indices. For example, a[2][3]
accesses the element at the 3rd column of the 2nd row.
Advanced 16
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-84-320.jpg)
![Implementation Steps
Declaring and Initializing a 2D Array
int n = scanner.nextInt(); // User-defined size
int[][] a = new int[n][n];
Scanning Values into a 2D Array
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
a[i][j] = scanner.nextInt();
}
}
Printing a 2D Array
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
System.out.print(a[i][j] + " ");
}
System.out.println();
}
Using printf for Better Formatting
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
System.out.printf("%2d ", a[i][j]);
}
System.out.println();
}
Advanced 17
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-85-320.jpg)
![Using printf with %2d ensures that each number occupies at least two spaces,
making the output more readable.
Example Code
Here is a complete example code that demonstrates the initialization, input, and
output of a 2D array:
import java.util.Scanner;
public class MultiDimensionalArray {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("Enter the size of the array:");
int n = scanner.nextInt(); // Reading the size of the array
int[][] a = new int[n][n]; // Declaring a 2D array
// Scanning values into the array
System.out.println("Enter the elements of the array:");
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
a[i][j] = scanner.nextInt();
}
}
// Printing the array
System.out.println("The 2D array is:");
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
System.out.printf("%2d ", a[i][j]);
}
System.out.println();
}
Advanced 18
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-86-320.jpg)
![}
}
Manually Initializing a 2D Array
Instead of taking input from the user, you can directly initialize a 2D array with
predefined values:
int[][] a = {
{1, 2, 3, 4, 5},
{6, 7, 8, 9, 10},
{11, 12, 13, 14, 15},
{16, 17, 18, 19, 20},
{21, 22, 23, 24, 25}
};
This creates a 5x5 matrix with specified values.
Summary
1D Array: Simple list, single index.
2D Array: Matrix or grid, two indices.
3D Array: Cube-like structure, three indices.
Syntax and Initialization: Use square brackets to denote dimensions.
Indexing: Access elements using indices corresponding to the dimensions.
Printing and Formatting: Use nested loops and printf for structured output.
In the next session, we will solve a practical problem using 2D arrays and move on
to working with strings. Practice initializing and manipulating arrays to get a solid
understanding before proceeding.
Introduction
Advanced 19
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-87-320.jpg)
![Step-by-Step Strategy
1. Initialization:
Define four variables to keep track of the boundaries of the matrix:
row_start , row_end , col_start , and col_end .
Initialize them to the respective starting and ending indices of the matrix.
2. Traversal:
Use a while loop to traverse the matrix until the boundaries overlap.
Inside the loop, use four nested for loops to traverse:
From left to right across the top row.
From top to bottom down the right column.
From right to left across the bottom row.
From bottom to top up the left column.
Adjust the boundaries after each traversal to move inward.
3. Edge Case:
Ensure to handle the case where the matrix center needs to be printed
separately if the boundaries converge at a single point.
Implementation
def spiral_order(matrix):
result = []
if not matrix:
return result
row_start, row_end = 0, len(matrix) - 1
col_start, col_end = 0, len(matrix[0]) - 1
while row_start <= row_end and col_start <= col_end:
# Traverse from left to right
for col in range(col_start, col_end + 1):
Advanced 21
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-89-320.jpg)
![result.append(matrix[row_start][col])
row_start += 1
# Traverse from top to bottom
for row in range(row_start, row_end + 1):
result.append(matrix[row][col_end])
col_end -= 1
# Traverse from right to left
if row_start <= row_end:
for col in range(col_end, col_start - 1, -1):
result.append(matrix[row_end][col])
row_end -= 1
# Traverse from bottom to top
if col_start <= col_end:
for row in range(row_end, row_start - 1, -1):
result.append(matrix[row][col_start])
col_start += 1
return result
# Example usage
matrix = [
[1, 2, 3, 4, 5],
[16, 17, 18, 19, 6],
[15, 24, 25, 20, 7],
[14, 23, 22, 21, 8],
[13, 12, 11, 10, 9]
]
print(spiral_order(matrix))
Explanation of Code
Initialization:
Advanced 22
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-90-320.jpg)
![Printing a String
To print a string, you can use the System.out.println method:
System.out.println(s); // Output: learn to code
Accessing Characters in a String
You cannot directly access characters in a string using square brackets as you do
with arrays. Instead, use the charAt method:
char c = s.charAt(2); // Output: 'a'
Converting String to Character Array
You can convert a string to a character array using the toCharArray method:
char[] charArray = s.toCharArray();
System.out.println(charArray[2]); // Output: 'a'
String Manipulation Methods
Length of a String
To find the length of a string, use the length method:
int length = s.length(); // Output: 13
Changing Case
To convert a string to uppercase or lowercase, use the toUpperCase and toLowerCase
methods:
String upper = s.toUpperCase(); // Output: LEARN TO CODE
String lower = s.toLowerCase(); // Output: learn to code
Advanced 28
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-96-320.jpg)
![1. Input and Scanner Initialization:
import java.util.Scanner;
import java.util.StringTokenizer;
import java.util.StringBuffer;
public class Main {
public static void main(String[] args) {
Scanner sh = new Scanner(System.in);
String s = sh.nextLine(); // Read entire line as input
2. String Tokenizer:
StringTokenizer st = new StringTokenizer(s, " "); // Tokenize based on
space
3. Loop Through Tokens:
int count = 0; // To keep track of word position
while (st.hasMoreTokens()) {
String word = st.nextToken(); // Get next word
StringBuffer sb = new StringBuffer(word); // Convert word to String
Buffer
word = sb.reverse().toString(); // Reverse the word
count++; // Increment word count
4. Alternate Case Conversion and Printing:
if (count % 2 != 0) { // Odd word position
System.out.print(word.toLowerCase() + " ");
} else { // Even word position
System.out.print(word.toUpperCase() + " ");
}
}
sh.close(); // Close the scanner
Expert 2
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-106-320.jpg)
![Use conditions to check if a character is an alphabet or a digit.
3. Convert Characters to Numbers:
Convert the sequence of digits into an integer using ASCII arithmetic.
Formula: num = num * 10 + (int_of_char - 48)
4. Implementation:
Write code to read the string, segregate characters and numbers, convert
the numbers, and then print the characters the specified number of times.
Detailed Code Explanation
import java.util.Scanner;
public class NumberBasedStrings {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// Read input string
System.out.println("Enter the string:");
String input = scanner.next();
// Convert string to character array
char[] arr = input.toCharArray();
int num = 0; // To store the number part
char ch = ' '; // To store the character part
for (int i = 0; i < arr.length; i++) {
if (arr[i] >= '0' && arr[i] <= '9') { // Check if it's a digit
num = num * 10 + (arr[i] - '0'); // Convert char digit to integer
} else { // It's a character
// Print the previous character the specified number of times
if (i > 0) {
for (int j = 0; j < num; j++) {
System.out.print(ch);
}
Expert 5
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-109-320.jpg)
![}
// Reset num and update the character
num = 0;
ch = arr[i];
}
}
// Print the last character the specified number of times
for (int j = 0; j < num; j++) {
System.out.print(ch);
}
}
}
Key Points
1. Initialization:
num is initialized to 0 to hold the numeric value.
ch is initialized to a space or a placeholder character.
2. Iteration:
The loop iterates through each character in the input string.
If the character is a digit, it updates num .
If the character is an alphabet, it prints the previous character num times
and updates ch to the current character.
3. Printing:
After exiting the loop, it prints the last character the specified number of
times.
Practical Usage
Example:
Input: "A10B12C3D4"
Expert 6
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-110-320.jpg)
![Defining Custom Data Types (Classes)
Classes are templates for creating objects.
For example, to define a Dog class, you consider attributes like breed, name,
and age, and behaviors like barking and eating.
class Dog {
String breed;
String name;
int age;
void bark() {
System.out.println("Bark!");
}
void eat() {
System.out.println("Eating...");
}
}
Attributes vs. Methods
Attributes (States): Describe the characteristics of an object (e.g., breed ,
name , age ).
Methods (Behaviors): Describe the actions that an object can perform (e.g.,
bark() , eat() ).
Example: Defining and Using a Dog Class
public class Main {
public static void main(String[] args) {
Dog myDog = new Dog();
myDog.breed = "Husky";
myDog.name = "Max";
myDog.age = 3;
Expert 8
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-112-320.jpg)
![System.out.println("Breed: " + myDog.breed);
System.out.println("Name: " + myDog.name);
System.out.println("Age: " + myDog.age);
myDog.bark();
myDog.eat();
}
}
In this example, myDog is an object of the Dog class.
We set its attributes ( breed , name , age ) and call its methods ( bark() , eat() ).
Key OOP Concepts
1. Class: Blueprint for creating objects.
2. Object: Instance of a class.
3. Method: Function defined inside a class that describes the behaviors of the
objects.
4. Attribute: Variable defined inside a class that describes the characteristics of
the objects.
Understanding Classes and Methods
A class is defined using the class keyword followed by the class name and
curly braces.
Methods are defined inside the class and describe the actions the objects can
perform.
Methods typically contain a return type, name, parentheses for parameters,
and curly braces for the method body.
Main Method in Java
The main method is the entry point of a Java program.
It must be defined as public static void main(String[] args) .
Expert 9
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-113-320.jpg)
![public class Demo {
public static void main(String[] args) {
System.out.println("Main function");
}
}
Naming Conventions and File Structure
The name of the class should match the name of the file.
The Java compiler searches for a class with the same name as the file and a
main method to start execution.
Public, Static, and Void Keywords
Public: Indicates the method is accessible from any other class.
Static: Indicates the method belongs to the class rather than any instance of
the class.
Void: Indicates the method does not return any value.
Practical Example: Understanding Main Method Execution
When you run a Java program, the compiler looks for a class with the same
name as the file and a main method.
If the file is named Main.java , the class should be named Main .
The main method should be defined as public static void main(String[] args) .
public class Main {
public static void main(String[] args) {
System.out.println("Main function");
}
}
Running the Code
Save the file as Main.java .
Expert 10
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-114-320.jpg)
![2. Same Name as Class: The name of the constructor must match the class
name.
3. Initialization: Constructors are primarily used to initialize the object with
specific values or to perform certain actions when the object is created.
Example of a Simple Constructor
public class Dog {
String name;
int age;
// Constructor
public Dog(String name, int age) {
this.name = name;
this.age = age;
System.out.println("Dog object created with name: " + name + " and age:
" + age);
}
public static void main(String[] args) {
Dog dog1 = new Dog("Husky", 2);
Dog dog2 = new Dog("Beagle", 1);
}
}
How Constructors Work
When Dog dog1 = new Dog("Husky", 2); is executed, the Dog constructor is called.
It initializes the name and age attributes with the values provided and prints the
message.
Using this Keyword in Constructors
The this keyword refers to the current object. It is used to differentiate between
class attributes and parameters with the same name.
Expert 12
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-116-320.jpg)
![// Getter for password
public String getPassword() {
return password;
}
// Setter for password
public void setPassword(String password) {
this.password = password;
}
}
public class Main {
public static void main(String[] args) {
Login login = new Login();
login.setUsername("user123");
login.setPassword("pass123");
System.out.println("Username: " + login.getUsername());
System.out.println("Password: " + login.getPassword());
}
}
How Encapsulation Works
The Login class has private variables username and password .
Public methods ( getUsername , setUsername , getPassword , setPassword ) are provided to
access and modify these private variables.
This ensures that direct access to the sensitive data (username and password)
is restricted and can only be accessed through these methods.
Hands-On Exercise
1. Create a Constructor for a Class
Expert 14
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-118-320.jpg)
![Define a class Book with attributes title and author .
Create a constructor that initializes these attributes and prints a message.
public class Book {
String title;
String author;
// Constructor
public Book(String title, String author) {
this.title = title;
this.author = author;
System.out.println("Book created: " + title + " by " + author);
}
public static void main(String[] args) {
Book book1 = new Book("1984", "George Orwell");
Book book2 = new Book("To Kill a Mockingbird", "Harper Lee");
}
}
2. Implement Encapsulation
Modify the Book class to encapsulate its attributes.
Provide getter and setter methods for title and author .
public class Book {
private String title;
private String author;
// Constructor
public Book(String title, String author) {
this.title = title;
this.author = author;
System.out.println("Book created: " + title + " by " + author);
Expert 15
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-119-320.jpg)
![}
// Getter for title
public String getTitle() {
return title;
}
// Setter for title
public void setTitle(String title) {
this.title = title;
}
// Getter for author
public String getAuthor() {
return author;
}
// Setter for author
public void setAuthor(String author) {
this.author = author;
}
public static void main(String[] args) {
Book book1 = new Book("1984", "George Orwell");
book1.setTitle("Animal Farm");
System.out.println("Updated title: " + book1.getTitle());
Book book2 = new Book("To Kill a Mockingbird", "Harper Lee");
System.out.println("Author: " + book2.getAuthor());
}
}
Summary
Expert 16
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-120-320.jpg)
![3. Single Inheritance
Example:
class A {
public void displayA() {
System.out.println("Class A");
}
}
class B extends A {
public void displayB() {
System.out.println("Class B");
}
}
public class Main {
public static void main(String[] args) {
B obj = new B();
obj.displayA(); // Accessing method of superclass
obj.displayB(); // Accessing method of subclass
}
}
In single inheritance, class B inherits from class A. The object of class B can
access methods of both class A and class B.
4. Multi-level Inheritance
Example:
class A {
public void displayA() {
System.out.println("Class A");
}
}
Expert 18
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-122-320.jpg)
![class B extends A {
public void displayB() {
System.out.println("Class B");
}
}
class C extends B {
public void displayC() {
System.out.println("Class C");
}
}
public class Main {
public static void main(String[] args) {
C obj = new C();
obj.displayA(); // Accessing method of superclass A
obj.displayB(); // Accessing method of superclass B
obj.displayC(); // Accessing method of subclass C
}
}
In multi-level inheritance, class C inherits from class B, which in turn inherits from
class A. The object of class C can access methods of all three classes.
5. Hierarchical Inheritance
Example:
class A {
public void displayA() {
System.out.println("Class A");
}
}
class B extends A {
public void displayB() {
Expert 19
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-123-320.jpg)
![System.out.println("Class B");
}
}
class C extends A {
public void displayC() {
System.out.println("Class C");
}
}
public class Main {
public static void main(String[] args) {
B objB = new B();
objB.displayA(); // Accessing method of superclass A
objB.displayB(); // Accessing method of subclass B
C objC = new C();
objC.displayA(); // Accessing method of superclass A
objC.displayC(); // Accessing method of subclass C
}
}
In hierarchical inheritance, multiple classes inherit from a single superclass. Class
B and class C both inherit from class A.
6. Method Overriding
Method overriding occurs when a subclass provides a specific implementation for
a method that is already defined in its superclass. The method in the subclass
should have the same name, return type, and parameters as the method in the
superclass.
Example:
class A {
public void display() {
System.out.println("Display from Class A");
Expert 20
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-124-320.jpg)
![}
}
class B extends A {
@Override
public void display() {
System.out.println("Display from Class B");
}
}
public class Main {
public static void main(String[] args) {
A objA = new A();
objA.display(); // Outputs: Display from Class A
B objB = new B();
objB.display(); // Outputs: Display from Class B
A objAB = new B();
objAB.display(); // Outputs: Display from Class B
}
}
In method overriding, the method in the subclass overrides the method in the
superclass.
7. Polymorphism
Polymorphism allows methods to perform different tasks based on the object that
is calling them. Method overriding is an example of polymorphism in Java.
Example:
class A {
public void display() {
System.out.println("Display from Class A");
}
Expert 21
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-125-320.jpg)
![}
class B extends A {
@Override
public void display() {
System.out.println("Display from Class B");
}
}
public class Main {
public static void main(String[] args) {
A obj; // Reference of superclass
obj = new A();
obj.display(); // Outputs: Display from Class A
obj = new B();
obj.display(); // Outputs: Display from Class B
}
}
Here, the same method display() behaves differently based on the object that calls
it.
8. Summary and Key Points
Inheritance promotes code reuse and establishes a relationship between
classes.
Method overriding allows a subclass to provide a specific implementation of a
method already defined in its superclass.
Polymorphism in Java is achieved through method overriding.
Java supports single, multi-level, and hierarchical inheritance but does not
support multiple and hybrid inheritance.
The extends keyword is used to establish inheritance.
Expert 22
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-126-320.jpg)
![@Override
void eat() {
System.out.println("Eat");
}
@Override
void sleep() {
System.out.println("Sleep");
}
}
3. Instantiating the Concrete Class:
public class Main {
public static void main(String[] args) {
Proxy dog = new Dog();
dog.bark(); // Outputs: Bark
dog.eat(); // Outputs: Eat
dog.sleep(); // Outputs: Sleep
}
}
In this example, Proxy is an abstract class with abstract methods bark() , eat() , and
sleep() . Dog extends Proxy and provides concrete implementations for these
methods. In the Main class, an object of type Proxy is instantiated as a Dog , and
the methods are called.
4. What is an Interface?
Definition:
An interface in Java is a reference type, similar to a class, that can contain only
constants, method signatures, default methods, static methods, and nested types.
Interfaces cannot contain instance fields or constructors.
Syntax:
Expert 25
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-129-320.jpg)
![class Dog implements Proxy {
@Override
public void bark() {
System.out.println("Bark");
}
@Override
public void eat() {
System.out.println("Eat");
}
@Override
public void sleep() {
System.out.println("Sleep");
}
}
3. Instantiating the Concrete Class:
public class Main {
public static void main(String[] args) {
Proxy dog = new Dog();
dog.bark(); // Outputs: Bark
dog.eat(); // Outputs: Eat
dog.sleep(); // Outputs: Sleep
}
}
In this example, Proxy is an interface with methods bark() , eat() , and sleep() . Dog
implements Proxy and provides concrete implementations for these methods. In
the Main class, an object of type Proxy is instantiated as a Dog , and the methods
are called.
6. Differences Between Abstract Classes and Interfaces
Expert 27
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-131-320.jpg)
![@Override
void sleep() {
System.out.println("Sleep");
}
}
public class Main {
public static void main(String[] args) {
Proxy dog = new Dog();
dog.start(); // Outputs: Bark Eat Sleep
}
}
Using Interface:
interface Proxy {
void bark();
void eat();
void sleep();
}
class Dog implements Proxy {
@Override
public void bark() {
System.out.println("Bark");
}
@Override
public void eat() {
System.out.println("Eat");
}
@Override
public void sleep() {
System.out.println("Sleep");
Expert 29
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-133-320.jpg)
![}
}
public class Main {
public static void main(String[] args) {
Proxy dog = new Dog();
dog.bark(); // Outputs: Bark
dog.eat(); // Outputs: Eat
dog.sleep(); // Outputs: Sleep
}
}
8. Summary and Key Points
Abstract Classes:
Used to define base classes with partial implementation.
Can have both abstract and concrete methods.
Ideal when there is a clear hierarchical relationship.
Interfaces:
Used to define a contract for classes to implement.
Cannot have instance fields or constructors.
Useful for achieving multiple inheritance.
Practical Use:
Abstract classes and interfaces are essential for hiding implementation
details and exposing only necessary functionality.
They help in reducing code duplication and increase maintainability.
Introduction to Exception Handling
Exception handling in Java is a crucial aspect of robust software development. It
enables the program to handle runtime errors gracefully and maintain normal
application flow. This session will cover the basics of exception handling, the
Expert 30
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-134-320.jpg)
![public void myMethod() throws IOException {
// Method code
}
Practical Example
Consider a web application where users enter their email addresses. If the input
doesn't include @gmail.com , we can throw a custom exception to prompt the user
for a correct email format.
Implementation:
public class EmailValidator {
public static void main(String[] args) {
try {
validateEmail("username");
} catch (InvalidEmailException e) {
System.out.println(e.getMessage());
}
}
public static void validateEmail(String email) throws InvalidEmailException {
if (!email.contains("@gmail.com")) {
throw new InvalidEmailException("Email must contain '@gmail.com'");
}
}
}
class InvalidEmailException extends Exception {
public InvalidEmailException(String message) {
super(message);
}
}
Expert 33
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-137-320.jpg)
![public void myMethod() throws ExceptionType {
// Method code
}
Detailed Examples
ArrayIndexOutOfBoundsException
This exception occurs when trying to access an array index that is out of
bounds.
public class Main {
public static void main(String[] args) {
int[] array = new int[5];
try {
array[5] = 10; // This will throw ArrayIndexOutOfBoundsException
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("Exception: " + e);
}
}
}
ArithmeticException
This exception occurs when an illegal arithmetic operation is performed, such
as dividing by zero.
public class Main {
public static void main(String[] args) {
try {
int result = 10 / 0; // This will throw ArithmeticException
} catch (ArithmeticException e) {
System.out.println("Exception: " + e);
}
Expert 36
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-140-320.jpg)
![}
}
Practical Scenarios
Handling Multiple Exceptions
Multiple exceptions can be handled using multiple catch blocks.
public class Main {
public static void main(String[] args) {
try {
int result = 10 / 0;
int[] array = new int[5];
array[5] = 10;
} catch (ArithmeticException e) {
System.out.println("ArithmeticException: " + e);
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("ArrayIndexOutOfBoundsException: " + e);
} catch (Exception e) {
System.out.println("General Exception: " + e);
}
}
}
Using finally
The finally block can be used to execute code that must run regardless of
whether an exception was thrown.
public class Main {
public static void main(String[] args) {
try {
int result = 10 / 0;
} catch (ArithmeticException e) {
System.out.println("Exception: " + e);
Expert 37
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-141-320.jpg)
![} finally {
System.out.println("This will always be executed");
}
}
}
Custom Exceptions
Custom exceptions can be created by extending the Exception class.
class AgeException extends Exception {
public AgeException(String message) {
super(message);
}
}
public class Main {
public static void validateAge(int age) throws AgeException {
if (age < 18) {
throw new AgeException("Age must be above 18");
}
}
public static void main(String[] args) {
try {
validateAge(15);
} catch (AgeException e) {
System.out.println("Exception: " + e);
}
}
}
Types of Exceptions
Checked Exceptions
Expert 38
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-142-320.jpg)
![These are exceptions that are checked at compile time.
Examples: IOException , SQLException
Handling Checked Exceptions:
public void readFile() throws IOException {
FileReader file = new FileReader("file.txt");
BufferedReader fileInput = new BufferedReader(file);
fileInput.close();
}
Unchecked Exceptions
These are exceptions that are not checked at compile time.
Examples: ArithmeticException , NullPointerException
Handling Unchecked Exceptions:
public class Main {
public static void main(String[] args) {
try {
int result = 10 / 0;
} catch (ArithmeticException e) {
System.out.println("Exception: " + e);
}
}
}
Best Practices
1. Always Catch Specific Exceptions: Catch the most specific exception first.
2. Use finally for Cleanup: Use the finally block for resource cleanup (e.g.,
closing file streams).
3. Don't Use Exceptions for Control Flow: Avoid using exceptions for regular
control flow.
Expert 39
c
o
d
e
r
s
n
o
t
e
.
c
o
m](https://image.slidesharecdn.com/freejavanotespdf-250526110702-a1888534/85/Download-Free-Java-Notes-PDF-for-Easy-Learning-143-320.jpg)
Download Free Java Notes PDF for Easy Learning
- 1. Learn Java – Educational Notes by Amend Ed Tech Disclaimer This Java notes PDF is created and distributed by CodersNote.com, a product of Amend Ed Tech. This material is intended solely for educational purposes. Reselling or unauthorized distribution of this content is strictly prohibited. You may find this PDF available through our official channels only: Udemy Topmate.io Slideshare.net CodersNote.com © Amend Ed Tech. All rights reserved. Learn Java – Educational Notes by Amend Ed Tech 1
- 2. Basic Introduction to Java Java is a versatile and widely-used programming language known for its robustness, platform independence, and object-oriented capabilities. This tutorial will take you through the foundational aspects of Java, its history, and its key features. By the end of this session, you should have a clear understanding of what makes Java special and why it remains a popular choice for developers. History of Java Java was developed by James Gosling and his team at Sun Microsystems in the early 1990s and officially released in 1995. It has since evolved significantly, with the latest version being Java 22, released in 2023. Java is now owned by Oracle Corporation. Key Historical Milestones: 1991: James Gosling initiated the Java project, originally named "Oak." 1995: Official release of Java 1.0. 2009: Oracle acquired Sun Microsystems, taking over Java. 2024: Release of Java 22. Major Features of Java Java stands out due to its three major features: 1. High-Level Language 2. Platform Independence 3. Object-Oriented Programming Basic 1 c o d e r s n o t e . c o m
- 3. High-Level Language A high-level language like Java is designed to be easy for humans to read and write. It abstracts away most of the complex details of the computer's hardware. Here's a brief comparison: High-Level Language: Code is written in a form that is easy for humans to understand and is translated into machine code by a compiler. Low-Level Language: Code is closer to machine language and directly interacts with the hardware. Examples include assembly language. Compiler Role A compiler translates high-level language code into machine code (binary format: 0s and 1s) that the computer's hardware can execute. This process is essential for converting Java code into a format that can be run on different machines. Platform Independence One of Java's most significant advantages is its platform independence, meaning the same Java code can run on different operating systems without modification. How Platform Independence Works Java Code: Written by the programmer. Compiler: Translates Java code into bytecode, a platform-independent code. Java Virtual Machine (JVM): Converts bytecode into machine-specific code for the operating system being used (Windows, macOS, Linux). This feature allows Java programs to be "write once, run anywhere" (WORA). Object-Oriented Programming (OOP) Java's object-oriented nature means it uses objects to represent data and methods to manipulate that data. This approach makes the code more modular, reusable, and easier to maintain. Setting Up Java Development Environment Basic 2 c o d e r s n o t e . c o m
- 4. Installing Eclipse IDE Eclipse is a popular integrated development environment (IDE) for Java programming. 1. Download Eclipse: Go to the official Eclipse website and download the installer for your operating system. Select the "Eclipse IDE for Java Developers" package for installation. 2. Install Eclipse: Follow the installation instructions provided by the installer. Once installed, launch Eclipse and set up your workspace directory. Alternative: Visual Studio Code For those interested in front-end development (HTML, CSS, JavaScript) alongside Java, Visual Studio Code is another excellent choice. It supports various extensions for different programming languages and offers a versatile coding environment. Next Steps In the upcoming sessions, we will cover: Java Development Kit (JDK), Java Runtime Environment (JRE), and JVM in detail. Introduction In this session, we will explore the key components that make Java a robust and widely-used programming language: JVM (Java Virtual Machine), JDK (Java Development Kit), and JRE (Java Runtime Environment). These components are essential for developing and running Java applications efficiently. Recap: Importance of Java Basic 3 c o d e r s n o t e . c o m
- 5. In the previous session, we discussed why Java is favored among programming languages: 1. Platform Independence: Java code can run on any operating system without modification. 2. High-Level Language: Java is easy to read and write, abstracting complex details. 3. Object-Oriented Programming (OOP): Java uses the principles of OOP, making it versatile and modular. Installing Eclipse For developing Java applications, we recommend using Eclipse IDE. Here’s a quick guide to installing Eclipse: 1. Search for Eclipse Download: Open your browser and type "Eclipse download." 2. Choose the Correct Version: Select the appropriate version for your operating system (Windows, Mac, Linux). 3. Install Java Developer Package: Once you download the installer, choose the "Java Developer" package to set up your development environment. Understanding JVM, JDK, and JRE To develop and run Java applications, you need to understand the roles of JVM, JDK, and JRE. Java Virtual Machine (JVM) Function: JVM is responsible for converting bytecode into machine code that can be executed by the operating system. It ensures Java’s platform independence by handling the conversion process for different OS. Role in Platform Independence: JVM translates bytecode into the specific format required by each OS (e.g., Windows, Mac, Linux). Java Development Kit (JDK) Basic 4 c o d e r s n o t e . c o m
- 6. Components: JDK includes JRE and development tools necessary for Java programming. JRE (Java Runtime Environment): Contains libraries and other components required to run Java applications. Development Tools: Includes the compiler (javac) and debugger. Usage: JDK is used by developers to write and compile Java code. Java Runtime Environment (JRE) Components: JRE consists of libraries and JVM. Libraries: Predefined code and classes necessary for running Java applications. JVM: As explained, it executes the Java bytecode. Role: JRE provides the environment necessary for Java applications to run, handling execution and resource management. Detailed Explanation and Analogies Memory Management: RAM and ROM RAM (Random Access Memory): Used for processing active tasks. Comparable to a workspace where you perform real-time computations. ROM (Read-Only Memory): Stores essential instructions and processes that are not actively modified. It’s like a reference book you consult repeatedly. Compiler and Debugger in JDK Compiler (javac): Translates Java source code into bytecode. It’s like a translator converting a human language into machine language (binary). Debugger: Helps identify and fix errors in code. It’s akin to an autocorrect feature, suggesting and making necessary corrections to ensure code runs smoothly. Practical Example Basic 5 c o d e r s n o t e . c o m
- 7. Writing a Simple Java Program 1. Open Eclipse IDE. 2. Create a New Java Project: File > New > Java Project. 3. Write a Simple Program: public class HelloWorld { public static void main(String[] args) { System.out.println("Hello, World!"); } } 4. Run the Program: Right-click on the file and select "Run As" > "Java Application". Summary JVM: Executes Java bytecode, ensuring platform independence. JDK: Provides tools for Java development, including the compiler and debugger. JRE: Runs Java applications, providing necessary libraries and JVM. Further Learning In the upcoming sessions, we will delve deeper into Java’s core concepts, including data types, control structures, and advanced OOP features. Ensure you have Eclipse installed and are familiar with its basic operations as we proceed with hands-on coding exercises. Introduction In this session, we'll explore the concept of RAM (Random Access Memory) and its functionality in computer systems. RAM is a crucial component in computing, enabling quick access and processing of data by the CPU. Basic 6 c o d e r s n o t e . c o m
- 8. What is RAM? Definition: RAM stands for Random Access Memory. It is a type of volatile memory used to store data that is being actively used or processed by the CPU. Composition: RAM is primarily composed of a chemical element called silicon, which is also found in sand. Pure silicon is used for RAM due to its high quality and efficiency. Structure of RAM Bytes and Bits: RAM is organized into units called bytes. Each byte consists of 8 bits. Bits: A bit is the smallest unit of data in computing and can represent either a 0 or a 1 (binary state). Memory Blocks: Each byte (memory block) has eight switches, which can be turned on or off to represent binary values. How RAM Works 1. Storage and Processing: RAM stores data that the CPU needs to process quickly. The data in RAM is volatile, meaning it is lost when the power is turned off. 2. Binary Representation: Data in RAM is represented using binary numbers (0s and 1s). Each bit in a byte corresponds to a binary digit. The value of a byte can be calculated by adding the binary values of each bit. Example: Representing Numbers in RAM Byte Structure: A byte consists of 8 bits, each with a specific value (2^0, 2^1, ..., 2^7). Basic 7 c o d e r s n o t e . c o m
- 9. Bit positions: 7 6 5 4 3 2 1 0 Binary values: 128 64 32 16 8 4 2 1 Representing the Number 1: Binary: 00000001 Only the bit at 2^0 (value 1) is set to 1, all others are 0. Representing the Number 3: Binary: 00000011 Bits at 2^1 (value 2) and 2^0 (value 1) are set to 1, summing to 3. Representing the Number 15: Binary: 00001111 Bits at 2^3 (value 8), 2^2 (value 4), 2^1 (value 2), and 2^0 (value 1) are set to 1, summing to 15. Data Types in Java Primitive Data Types: Java has several primitive data types for handling numbers: byte : 8-bit integer short : 16-bit integer int : 32-bit integer long : 64-bit integer Coding Example: Using Data Types in Java 1. Setting Up the Environment: Use an IDE like Eclipse to write and execute Java code. Create a new Java project and a Java class within the project. 2. Creating a Java Class: Define a class named Main . Basic 8 c o d e r s n o t e . c o m
- 10. Inside the class, write the main method which serves as the entry point for the program. 3. Example Code: public class Main { public static void main(String[] args) { // Print a message to the console System.out.println("Learn to code"); // Examples of using different data types byte b = 10; short s = 1000; int i = 100000; long l = 10000000000L; // Print the values of the variables System.out.println("Byte value: " + b); System.out.println("Short value: " + s); System.out.println("Int value: " + i); System.out.println("Long value: " + l); } } 1. Running the Code: Execute the code in the IDE to see the output in the console. The output will display the message and the values of different data types. Understanding Debugging in Java Case Sensitivity: Java is case-sensitive, meaning System and system are different identifiers. Comments: Use // for single-line comments and /* ... */ for multi-line comments. Comments are ignored during code execution and are used for documentation. Basic 9 c o d e r s n o t e . c o m
- 11. // This is a single-line comment /* This is a multi-line comment */ Summary RAM is a vital component in computing, used for quick data access and processing. It is composed of bytes, each consisting of 8 bits, and uses binary representation for data. In Java, primitive data types such as byte , short , int , and long are used to store numerical values. Understanding RAM and data types is crucial for efficient programming and system performance. By understanding these concepts, students can better grasp how memory works in computers and how to use Java data types effectively in their coding projects. Overview In this lesson, we explore various numerical data types in Java, including byte , short , int , and long . We learn how to declare these data types, assign values to them, and understand their ranges and behaviors. Additionally, we discuss variable naming conventions and a concept called "looping" in data types. Numerical Data Types in Java 1. byte Size: 1 byte (8 bits) Range: -128 to 127 Example: byte a = 1; System.out.println(a); // Outputs: 1 Basic 10 c o d e r s n o t e . c o m
- 12. 2. short Size: 2 bytes (16 bits) Range: -32,768 to 32,767 Example: short b = 134; System.out.println(b); // Outputs: 134 3. int Size: 4 bytes (32 bits) Range: -2,147,483,648 to 2,147,483,647 Example: int c = 2147483647; System.out.println(c); // Outputs: 2147483647 4. long Size: 8 bytes (64 bits) Range: -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807 Example: long d = 2147483648L; System.out.println(d); // Outputs: 2147483648 Printing Values To print a variable's value, use System.out.println(variable); When using double quotes around a variable in System.out.println() , it prints the variable name, not its value: Basic 11 c o d e r s n o t e . c o m
- 13. System.out.println("a"); // Outputs: a System.out.println(a); // Outputs: 1 Variable Naming Conventions Allowed: Letters (both uppercase and lowercase), digits (0-9), and underscores (_). Rules: Must not start with a digit. Must not contain spaces or other special symbols. Example of valid names: int a1 = 10; int _a = 20; int A2 = 30; Understanding Ranges and Looping The size of each data type determines its range of values. When a value exceeds the maximum range of a data type, it "loops" to the minimum value, and vice versa. Example with int : int maxInt = 2147483647; System.out.println(maxInt + 1); // Outputs: -2147483648 (looping occurs) This concept applies to all numerical data types. Exercise Try creating variables of different data types and experiment with values within and beyond their ranges. Basic 12 c o d e r s n o t e . c o m
- 14. Observe how the values loop when they exceed their maximum or minimum limits. Summary byte, short, int, long are used for different ranges of integer values in Java. Always choose the smallest data type that fits the range of values you need to optimize memory usage. Understand and follow variable naming conventions to avoid errors. The concept of looping helps in understanding how data types handle values beyond their defined ranges. Introduction to Data Types in Java Primitive Data Types: Basic data types in Java are categorized as numerical (integers and real numbers) and non-numerical (characters and boolean). Reference Data Types: These include objects and arrays which are not covered in this session. Numerical Data Types 1. Integer Types: byte: 1 byte, range: -128 to 127 short: 2 bytes, range: -32,768 to 32,767 int: 4 bytes, range: -2^31 to 2^31-1 long: 8 bytes, range: -2^63 to 2^63-1 (must suffix with L or l ) 2. Real Number Types: float: 4 bytes, 6-7 decimal digits precision (suffix with f or F ) double: 8 bytes, 15-16 decimal digits precision (default for real numbers) Declaring and Using Variables Basic 13 c o d e r s n o t e . c o m
- 15. Syntax: dataType variableName = value; Example: float myFloat = 12.34f; double myDouble = 123.4567890123456; Float and Double Float: Uses 4 bytes. Precision: Up to 6-7 decimal places. Example: float myFloat = 12.123456f; System.out.println(myFloat); // Output: 12.123456 Double: Uses 8 bytes. Precision: Up to 15-16 decimal places. Example: double myDouble = 12.123456789012345; System.out.println(myDouble); // Output: 12.123456789012345 Rounding Issues: Floating-point arithmetic may introduce rounding errors. Example: Basic 14 c o d e r s n o t e . c o m
- 16. float myFloat = 12.123456789f; // Actual stored value might be slightly different Printing with Precision Using printf for formatted output: Syntax: System.out.printf(formatString, arguments); Format Specifiers: %f for floating-point numbers. %.nf for floating-point numbers with n decimal places. Example: System.out.printf("%.2f", myFloat); // Output: 12.12 Boolean Data Type Usage: Represents true/false values. Uses 1 bit of memory. Example: boolean isJavaFun = true; boolean isFishTasty = false; Character Data Type Usage: Represents a single 16-bit Unicode character. Uses 2 bytes of memory. Basic 15 c o d e r s n o t e . c o m
- 17. Example: char myChar = 'A'; char myCharNumeric = 65; // ASCII value of 'A' ASCII Values: Characters can be represented using ASCII values. Example: char myChar = 65; // A char myDigit = 49; // 1 Practical Example 1. Float Example: float floatVar = 12.123456f; System.out.println("Float value: " + floatVar); // Float value: 12.123456 System.out.printf("Formatted float value: %.2fn", floatVar); // Formatted f loat value: 12.12 2. Double Example: double doubleVar = 12.123456789012345; System.out.println("Double value: " + doubleVar); // Double value: 12.1234 56789012345 System.out.printf("Formatted double value: %.5fn", doubleVar); // Format ted double value: 12.12346 3. Boolean Example: boolean isJavaFun = true; System.out.println("Is Java fun? " + isJavaFun); // Is Java fun? true Basic 16 c o d e r s n o t e . c o m
- 18. 4. Character Example: char charVar = 'A'; char charFromASCII = 65; // ASCII value for 'A' System.out.println("Character: " + charVar); // Character: A System.out.println("Character from ASCII: " + charFromASCII); // Characte r from ASCII: A Summary Java provides various data types to handle different types of data efficiently. float and double handle real numbers with varying degrees of precision. boolean represents true/false values and is used in decision-making. char represents single characters using Unicode. Understanding and using these data types correctly is crucial for effective Java programming. Introduction to Operators in Java Purpose of Operators: Operators are special symbols that perform operations on variables and values. Types of Operators: Java provides various operators grouped into different categories based on their functionality. Arithmetic Operators Arithmetic operators are used to perform basic mathematical operations. 1. Addition ( + ): int a = 10; int b = 20; int c = a + b; // c is 30 Basic 17 c o d e r s n o t e . c o m
- 19. 2. Subtraction ( ): int a = 20; int b = 10; int c = a - b; // c is 10 3. Multiplication ( ): int a = 10; int b = 20; int c = a * b; // c is 200 4. Division ( / ): int a = 20; int b = 10; int c = a / b; // c is 2 5. Modulus ( % ): Returns the remainder of the division. int a = 20; int b = 10; int c = a % b; // c is 0 Code Example: int a = 10; int b = 20; int sum = a + b; // 30 int diff = a - b; // -10 int product = a * b; // 200 int quotient = a / b; // 0 (integer division) int remainder = a % b; // 10 Basic 18 c o d e r s n o t e . c o m
- 20. Type Casting in Java Type casting is the process of converting one data type to another. 1. Implicit Casting (Widening Conversion): Automatically converts a smaller data type to a larger one. int a = 10; double b = a; // No explicit cast needed 2. Explicit Casting (Narrowing Conversion): Manually converts a larger data type to a smaller one. double a = 10.5; int b = (int) a; // Explicit cast needed Practical Example: int a = 10; int b = 20; float result = (float) a / b; // 0.5 Increment and Decrement Operators 1. Increment ( ++ ): Increases a value by 1. Pre-Increment ( ++a ): Increments before using the value. Post-Increment ( a++ ): Increments after using the value. int a = 10; int b = ++a; // b is 11, a is 11 int c = a++; // c is 11, a is 12 2. Decrement ( - ): Decreases a value by 1. Pre-Decrement ( -a ): Decrements before using the value. Basic 19 c o d e r s n o t e . c o m
- 21. Post-Decrement ( a-- ): Decrements after using the value. int a = 10; int b = --a; // b is 9, a is 9 int c = a--; // c is 9, a is 8 Relational Operators Relational operators are used to compare two values. 1. Equal to ( == ): int a = 10; int b = 20; boolean result = (a == b); // false 2. Not equal to ( != ): int a = 10; int b = 20; boolean result = (a != b); // true 3. Greater than ( > ): int a = 20; int b = 10; boolean result = (a > b); // true 4. Less than ( < ): int a = 10; int b = 20; boolean result = (a < b); // true 5. Greater than or equal to ( >= ): Basic 20 c o d e r s n o t e . c o m
- 22. int a = 20; int b = 20; boolean result = (a >= b); // true 6. Less than or equal to ( <= ): int a = 10; int b = 20; boolean result = (a <= b); // true Logical Operators Logical operators are used to combine multiple boolean expressions. 1. AND ( && ): boolean result = (true && false); // false 2. OR ( || ): boolean result = (true || false); // true 3. NOT ( ! ): boolean result = !true; // false Assignment Operators Assignment operators are used to assign values to variables. 1. Simple Assignment ( = ): int a = 10; 2. Addition Assignment ( += ): Basic 21 c o d e r s n o t e . c o m
- 23. int a = 10; a += 5; // a is now 15 3. Subtraction Assignment ( = ): int a = 10; a -= 5; // a is now 5 4. Multiplication Assignment ( = ): int a = 10; a *= 5; // a is now 50 5. Division Assignment ( /= ): int a = 10; a /= 5; // a is now 2 6. Modulus Assignment ( %= ): int a = 10; a %= 3; // a is now 1 Ternary Operator The ternary operator is a shorthand for if-else statements. Syntax: variable = (condition) ? expressionTrue : expressionFalse; Example: int age = 18; Basic 22 c o d e r s n o t e . c o m
- 24. String result = (age >= 18) ? "Eligible to vote" : "Not eligible to vote"; Example with User Input: import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.println("Enter your age: "); int age = scanner.nextInt(); String result = (age >= 18) ? "Eligible to vote" : "Not eligible to vote"; System.out.println(result); } } Summary Arithmetic Operators: Perform basic mathematical operations. Type Casting: Convert data types from one form to another. Increment/Decrement Operators: Increase or decrease values by one. Relational Operators: Compare values and return boolean results. Logical Operators: Combine multiple boolean expressions. Assignment Operators: Assign and modify values in a concise manner. Ternary Operator: Provide a shorthand for if-else statements. Understanding these operators is crucial for writing effective and efficient Java programs. Practice using them in various scenarios to strengthen your grasp of their functionalities. Introduction Basic 23 c o d e r s n o t e . c o m
- 25. In this session, we will delve into practical examples to understand how to use if- else statements effectively in Java. We will cover the concepts of statement precedence and condition precedence through a series of examples, including how to determine if a given year is a leap year. Key Concepts 1. Statement Precedence: The order in which statements are evaluated. 2. Condition Precedence: The order in which conditions are checked within the statements. Example: Determining Leap Years A leap year in the Gregorian calendar has the following rules: A year is a leap year if it is divisible by 4. However, if the year is a century year (ending in 00), it is only a leap year if it is also divisible by 400. Steps to Determine Leap Year 1. Primary Condition: Check if the year is valid. 2. Secondary Conditions: Determine if the year is a leap year based on the rules for normal years and century years. Writing the Code Step 1: Checking for Valid Year We need to ensure the input year is greater than zero and within a realistic range. int year = ...; // input year if (year > 0 && year <= 9999) { // Valid year } else { System.out.println("Invalid year"); } Basic 24 c o d e r s n o t e . c o m
- 26. Step 2: Checking for Leap Year Inside the valid year condition, we check if the year is a leap year. if (year > 0 && year <= 9999) { if (year % 400 == 0) { System.out.println("Leap year"); } else if (year % 100 == 0) { System.out.println("Not a leap year"); } else if (year % 4 == 0) { System.out.println("Leap year"); } else { System.out.println("Not a leap year"); } } else { System.out.println("Invalid year"); } Example Code Here is the complete code with all conditions checked and properly ordered: import java.util.Scanner; public class LeapYearChecker { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.print("Enter a year: "); int year = scanner.nextInt(); if (year > 0 && year <= 9999) { // Primary condition: valid year if (year % 400 == 0) { // Century year divisible by 400 System.out.println("Leap year"); } else if (year % 100 == 0) { // Century year not divisible by 400 System.out.println("Not a leap year"); } else if (year % 4 == 0) { // Normal year divisible by 4 Basic 25 c o d e r s n o t e . c o m
- 27. System.out.println("Leap year"); } else { // Not divisible by 4 System.out.println("Not a leap year"); } } else { // Invalid year System.out.println("Invalid year"); } } } Testing the Code Test Cases Valid Leap Year (Normal): 2012 -> "Leap year" Valid Non-Leap Year (Normal): 2013 -> "Not a leap year" Valid Leap Year (Century): 2000 -> "Leap year" Valid Non-Leap Year (Century): 1900 -> "Not a leap year" Invalid Year: -2021 -> "Invalid year" Additional Exercise Create a program that validates a given date in the format DD/MM/YYYY. Conditions to check: 1. Primary Conditions: Date should be from 1 to 31. Month should be from 1 to 12. Year should be a valid year (e.g., 0 to 9999). 2. Secondary Conditions: Months with 31 days: January, March, May, July, August, October, December. Months with 30 days: April, June, September, November. Basic 26 c o d e r s n o t e . c o m
- 28. February should have 28 or 29 days depending on whether it's a leap year or not. Example Input/Output: Input: 12/09/2021 -> Output: "Valid" Input: 31/04/2021 -> Output: "Invalid" Input: 29/02/2020 -> Output: "Valid" Input: 29/02/2021 -> Output: "Invalid" Conclusion Understanding and properly implementing if-else statements in Java is crucial for decision-making in your programs. Practice these examples and the additional exercise to strengthen your grasp on condition and statement precedence. In the next session, we will discuss conditional loops, which are fundamental for handling repetitive tasks based on certain conditions. Overview In this session, we will study conditional loops in Java, focusing on while loops, do-while loops, and for loops. We'll draw parallels with a child's routine to understand repetition and the termination of these loops. Loops and Their Usage Just as a child's daily routine involves repeating certain activities (like going to school) until a specific endpoint (like graduation), loops in programming repeat a block of code until a certain condition is met. Types of Loops in Java 1. While Loop 2. Do-While Loop 3. For Loop 1. While Loop Basic 27 c o d e r s n o t e . c o m
- 29. The while loop repeats a block of code as long as a specified condition is true. It is an entry-check loop, meaning the condition is checked before the loop's body is executed. Syntax: while (condition) { // code block to be executed } Example: int count = 1; // Initialization while (count <= 5) { // Condition System.out.println(count); // Executable statement count++; // Updation } Key Concepts: Initialization: Setting up the loop's initial state. Condition: The loop runs as long as this condition is true. Updation: Updating the loop's state to eventually terminate it. Execution Flow: 1. Initialization ( int count = 1 ) 2. Check the condition ( count <= 5 ) 3. If true, execute the code block ( System.out.println(count) ) 4. Update the loop variable ( count++ ) 5. Repeat steps 2-4 until the condition becomes false Basic 28 c o d e r s n o t e . c o m
- 30. Number Crunching with Loops Number Crunching involves various operations like counting digits, accessing digits, and reversing numbers. Counting Digits: Counting the number of digits in a given number. int a = 12345; int count = 0; while (a != 0) { a /= 10; count++; } System.out.println(count); // Output: 5 Accessing Digits: Accessing each digit of a number from right to left. int a = 12345; while (a != 0) { int digit = a % 10; System.out.println(digit); a /= 10; } // Output: 5 4 3 2 1 Reversing a Number: Reversing the digits of a number to form a new number. int a = 12345; int reverse = 0; Basic 29 c o d e r s n o t e . c o m
- 31. while (a != 0) { int digit = a % 10; reverse = reverse * 10 + digit; a /= 10; } System.out.println(reverse); // Output: 54321 Entry-Check Loop (While Loop) In a while loop, the condition is checked at the entry point. If the condition is false at the start, the loop body won't execute. Practical Exercises 1. Print Digits in Reverse Order: Write a program that prints digits of a number in reverse order. int a = 54321; while (a != 0) { int digit = a % 10; System.out.println(digit); a /= 10; } // Output: 1 2 3 4 5 2. Special Pattern Printing: Write a program that prints digits in a specific pattern where even-positioned digits remain the same, and odd-positioned digits are in reverse order. int a = 1234567; // Expected output: 7 2 5 4 3 6 1 Summary Basic 30 c o d e r s n o t e . c o m
- 32. Loops are essential for performing repetitive tasks in programming. Understanding their initialization, condition, and updation helps in effectively using them. Practice the exercises to strengthen your grasp of loops in Java. We'll cover do-while loops and for loops in the next session. Basic 31 c o d e r s n o t e . c o m
- 33. Intermediat Overview In this session, we covered: 1. Understanding number-based problems. 2. Using loops to solve number-based problems. 3. Writing efficient code to handle these problems. 4. Analyzing the concept of perfect numbers. 5. Practicing the identification of prime numbers. Key Concepts 1. Data Types and Loops Review Understanding basic data types (int, float, etc.). Utilizing loops (for, while) to iterate through values. 2. For Loop with Semicolon A for loop with a semicolon ( ; ) at the end runs separately without taking the statements inside the loop. Example: for (int i = 0; i < 10; i++); will not execute any internal code block. 3. Integer Range Integer ranges from 2147483648 to 2147483647 . Incrementing beyond the maximum integer value results in wrap-around to the negative range. Perfect Number Concept Definition Intermediat 1 c o d e r s n o t e . c o m
- 34. A perfect number is a positive integer that is equal to the sum of its proper divisors (excluding itself). Example: 6 is a perfect number because its divisors (1, 2, 3) sum to 6. Steps to Determine a Perfect Number 1. Input Handling Use Scanner to read an integer input. Example: Scanner scanner = new Scanner(System.in); int num = scanner.nextInt(); 2. Finding Factors Loop from 1 to num/2 (half of the number). Check if each number is a divisor using modulus operation ( % ). Sum the divisors. 3. Check and Output Result Compare the sum of divisors to the original number. Use ternary operator to print the result. Code Implementation Basic Structure 1. Input Section Scanner scanner = new Scanner(System.in); int num = scanner.nextInt(); 2. Operation Section Intermediat 2 c o d e r s n o t e . c o m
- 35. int sum = 0; for (int i = 1; i <= num / 2; i++) { if (num % i == 0) { sum += i; } } 3. Output Section String result = (num == sum) ? "Perfect number" : "Not a perfect number"; System.out.println(result); Complete Code import java.util.Scanner; public class PerfectNumber { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int num = scanner.nextInt(); int sum = 0; for (int i = 1; i <= num / 2; i++) { if (num % i == 0) { sum += i; } } String result = (num == sum) ? "Perfect number" : "Not a perfect numbe r"; System.out.println(result); } } Intermediat 3 c o d e r s n o t e . c o m
- 36. Efficiency Improvement Instead of iterating up to num-1 , iterate only up to num/2 . Example: For num = 100 , factors are within 1 to 50 . Prime Number Exercise Task: Determine if a number is prime. 1. Input a number. 2. Check if it has any divisors other than 1 and itself. 3. Output "Prime number" or "Not a prime number". Code Outline import java.util.Scanner; public class PrimeNumber { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int num = scanner.nextInt(); boolean isPrime = true; for (int i = 2; i <= num / 2; i++) { if (num % i == 0) { isPrime = false; break; } } String result = isPrime ? "Prime number" : "Not a prime number"; System.out.println(result); } } Conclusion Intermediat 4 c o d e r s n o t e . c o m
- 37. Practice number-based problems to enhance problem-solving skills. Focus on writing efficient code. Understand and implement perfect and prime number identification. Next Steps: Practice more number-based problems. Experiment with different inputs to understand edge cases. Move on to more complex number-crunching problems in future sessions. Introduction In this tutorial, we will delve into prime numbers, understand how to check if a number is prime, and extend this concept to identify all prime numbers within a given range. This guide will break down the concepts and code step-by-step, making it easy to follow and implement. Key Concepts 1. Prime Numbers: A prime number is a natural number greater than 1 that has no positive divisors other than 1 and itself. 2. Flag Concept: Used to track if a condition has been met within a loop. 3. Efficiency in Algorithms: Techniques to optimize code for better performance. Prime Number Check Understanding the Problem To determine if a number is prime: 1. Scan the number. 2. Check divisibility by all numbers from 2 to ( n-1 ) (where ( n ) is the given number). 3. If any number divides ( n ) without a remainder, ( n ) is not a prime. Code Explanation Intermediat 5 c o d e r s n o t e . c o m
- 38. public class PrimeNumber { public static void main(String[] args) { Scanner ss = new Scanner(System.in); int num = ss.nextInt(); boolean isPrime = true; for (int i = 2; i <= num / 2; i++) { if (num % i == 0) { isPrime = false; break; } } if (isPrime) { System.out.println(num + " is a prime number"); } else { System.out.println(num + " is not a prime number"); } } } Detailed Steps 1. Input Handling: Scan the number using Scanner . 2. Flag Initialization: Initialize a boolean flag isPrime to true . 3. Loop for Divisibility Check: Iterate from 2 to ( n/2 ) (since a larger factor would have a corresponding smaller factor). If ( n % i == 0 ), set isPrime to false and break the loop. 4. Output Result: After the loop, check the flag: If isPrime is true , print that ( n ) is a prime number. Intermediat 6 c o d e r s n o t e . c o m
- 39. Otherwise, print that ( n ) is not a prime number. Prime Numbers in a Given Range Problem Extension To list all prime numbers within a given range (e.g., 1 to 50): 1. Iterate through each number in the range. 2. Use the prime number check logic for each number. Code Explanation public class PrimeNumberRange { public static void main(String[] args) { Scanner ss = new Scanner(System.in); int range = ss.nextInt(); for (int num = 2; num <= range; num++) { boolean isPrime = true; for (int i = 2; i <= num / 2; i++) { if (num % i == 0) { isPrime = false; break; } } if (isPrime) { System.out.print(num + " "); } } } } Detailed Steps Intermediat 7 c o d e r s n o t e . c o m
- 40. 1. Input Handling: Scan the upper limit of the range. 2. Outer Loop for Range: Iterate through each number from 2 to the given range. 3. Prime Check for Each Number: Initialize a boolean flag isPrime to true for each number. Iterate from 2 to ( num/2 ) to check for divisibility. If a divisor is found, set isPrime to false and break the loop. 4. Output Prime Numbers: If isPrime remains true after the inner loop, print the number. Optimizations and Best Practices Reducing Iterations Instead of checking up to ( n-1 ), check up to ( sqrt{n} ) for efficiency. Using a Boolean Array for Multiple Queries For handling multiple prime checks efficiently, especially in a range, use the Sieve of Eratosthenes algorithm. Example: Sieve of Eratosthenes Code Explanation public class SieveOfEratosthenes { public static void main(String[] args) { int range = 50; // Example range boolean[] isPrime = new boolean[range + 1]; // Initialize all entries as true Arrays.fill(isPrime, true); isPrime[0] = false; isPrime[1] = false; for (int p = 2; p * p <= range; p++) { Intermediat 8 c o d e r s n o t e . c o m
- 41. if (isPrime[p]) { for (int i = p * p; i <= range; i += p) { isPrime[i] = false; } } } for (int i = 2; i <= range; i++) { if (isPrime[i]) { System.out.print(i + " "); } } } } Detailed Steps 1. Initialize Array: Create a boolean array isPrime initialized to true . 2. Mark Non-Primes: For each prime p , mark its multiples as false . 3. Output Primes: Print all indices that remain true . Conclusion Understanding prime numbers and implementing efficient algorithms to check for primes and list them within a range are fundamental concepts in programming and number theory. Practice these concepts with different ranges and further optimize the code for better performance. Overview This study guide will cover the following key concepts and coding techniques for understanding and implementing Armstrong numbers and number crunching in Java. We'll break down the process, code, and logic in a detailed and easy-to- understand manner. Intermediat 9 c o d e r s n o t e . c o m
- 42. Key Concepts 1. Number Crunching 2. Armstrong Numbers 3. For Loops and While Loops 4. Flag Concept and Reset Importance 5. Efficient Coding Practices Detailed Notes Number Crunching Number crunching refers to performing a series of calculations on numerical data. It's a fundamental skill in programming that involves iterating over numbers, performing mathematical operations, and efficiently managing data. Armstrong Numbers An Armstrong number (also known as a Narcissistic number) is a number that is equal to the sum of its own digits each raised to the power of the number of digits. Example: For a 3-digit number like 153: [ 1^3 + 5^3 + 3^3 = 153 ] Thus, 153 is an Armstrong number. Steps to Determine an Armstrong Number 1. Scan the Input Number: Read the number provided by the user. 2. Count the Digits: Determine the number of digits in the input number. 3. Access Each Digit: Extract each digit from the number. 4. Raise to Power: Raise each digit to the power of the total number of digits. 5. Sum the Values: Sum all the powered values. 6. Compare the Sum: Check if the sum is equal to the original number. Intermediat 10 c o d e r s n o t e . c o m
- 43. Coding Implementation Here is a step-by-step breakdown of the code used to determine if a number is an Armstrong number in Java: Step 1: Read the Input Number import java.util.Scanner; public class ArmstrongNumber { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.print("Enter a number: "); int num = scanner.nextInt(); scanner.close(); if (isArmstrong(num)) { System.out.println(num + " is an Armstrong number"); } else { System.out.println(num + " is not an Armstrong number"); } } // Function to check if a number is an Armstrong number public static boolean isArmstrong(int num) { int count = countDigits(num); int sum = calculateSumOfPowers(num, count); return sum == num; } // Function to count the number of digits public static int countDigits(int num) { int count = 0; while (num != 0) { num /= 10; count++; Intermediat 11 c o d e r s n o t e . c o m
- 44. } return count; } // Function to calculate the sum of digits each raised to the power of the co unt public static int calculateSumOfPowers(int num, int count) { int sum = 0; int temp = num; while (temp != 0) { int digit = temp % 10; sum += Math.pow(digit, count); temp /= 10; } return sum; } } Explanation 1. Read the Input Number: Use a Scanner to read the user input. Store the input number in a variable. 2. Count the Digits: Create a function countDigits to determine the number of digits in the input number. Use a while loop to count the digits. 3. Extract Each Digit and Compute the Power: Create a function calculateSumOfPowers to extract each digit and compute the power of each digit raised to the total number of digits. Use another while loop to extract each digit, raise it to the power of the count of digits, and sum these values. Intermediat 12 c o d e r s n o t e . c o m
- 45. 4. Compare the Sum with the Original Number: In the main function isArmstrong , check if the computed sum is equal to the original number. Exercise To practice and understand the concept better, try writing a program to find all Armstrong numbers in a given range (e.g., 1 to 10,000). import java.util.ArrayList; import java.util.List; public class ArmstrongNumberRange { public static void main(String[] args) { int start = 1; int end = 10000; List<Integer> armstrongNumbers = findArmstrongNumbersInRange(start, end); System.out.println("Armstrong numbers between " + start + " and " + end + ": " + armstrongNumbers); } public static List<Integer> findArmstrongNumbersInRange(int start, int end) { List<Integer> armstrongNumbers = new ArrayList<>(); for (int num = start; num <= end; num++) { if (isArmstrong(num)) { armstrongNumbers.add(num); } } return armstrongNumbers; } public static boolean isArmstrong(int num) { int count = countDigits(num); int sum = calculateSumOfPowers(num, count); Intermediat 13 c o d e r s n o t e . c o m
- 46. return sum == num; } public static int countDigits(int num) { int count = 0; while (num != 0) { num /= 10; count++; } return count; } public static int calculateSumOfPowers(int num, int count) { int sum = 0; int temp = num; while (temp != 0) { int digit = temp % 10; sum += Math.pow(digit, count); temp /= 10; } return sum; } } Conclusion By following these steps and practicing the exercises, you should gain a solid understanding of how to work with Armstrong numbers and perform number crunching in Java. This guide provides a comprehensive approach to mastering these concepts with detailed explanations and coding examples. Introduction to Patterns in Java Patterns in Java involve printing symbols or characters in a specific order, creating visually recognizable structures. These exercises are commonly used in coding Intermediat 14 c o d e r s n o t e . c o m
- 47. interviews to assess logical thinking and coding skills. Importance of Learning Patterns: Enhances coding and logical thinking skills. Frequently asked in technical interviews, especially for high-paying and product-based companies. Basics of Pattern Printing A pattern is created by nesting loops, typically using for loops. Each loop controls either the rows or columns of the pattern. Simple Pattern Example: To print a single row of stars: System.out.print("*"); To print multiple stars based on user input: Scanner scanner = new Scanner(System.in); int n = scanner.nextInt(); // User input for number of stars for (int i = 1; i <= n; i++) { System.out.print("*"); } Nested Loops for Patterns To print a square of stars (n x n): for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) { System.out.print("* "); } Intermediat 15 c o d e r s n o t e . c o m
- 48. System.out.println(); // Move to the next line after each row } Detailed Example: Hollow Box Pattern Objective: Print a hollow square pattern of stars. Steps: 1. Identify the rows and columns: Rows and columns are the same (n x n). 2. Frame the condition to print stars: Print stars at the borders (first row, last row, first column, last column). Code: for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) { if (i == 1 || i == n || j == 1 || j == n) { System.out.print("* "); } else { System.out.print(" "); // Space inside the box } } System.out.println(); // Move to the next line after each row } Explanation: Outer for loop runs for each row. Inner for loop runs for each column within a row. Condition checks if the current position is at the border and prints a star. Otherwise, it prints a space. Intermediat 16 c o d e r s n o t e . c o m
- 49. Another Example: Right-Angled Triangle Pattern Objective: Print a right-angled triangle pattern of stars. Steps: 1. Identify the pattern: Number of stars in each row equals the row number. 2. Frame the condition: Print stars in each row up to the current row number. Code: for (int i = 1; i <= n; i++) { for (int j = 1; j <= i; j++) { System.out.print("* "); } System.out.println(); // Move to the next line after each row } Explanation: Outer for loop runs for each row. Inner for loop runs up to the current row number, printing stars. Rules for Pattern Printing 1. Check row and column count: If rows and columns are the same, the outer and inner loop conditions will be similar. 2. Find the relationship between i, j, and n: i denotes the row. Intermediat 17 c o d e r s n o t e . c o m
- 50. j denotes the column. n is the total number of rows/columns or a user input value. 3. Determine the first occurring character: The initial pattern character (often a star) should guide the first condition in your loop. Advanced Patterns Future sessions will cover: Number-based patterns: Printing numbers instead of stars. String-based patterns: Printing characters or strings instead of stars. By practicing these patterns, you'll improve your problem-solving skills and be better prepared for coding interviews. Conclusion Understanding and practicing pattern printing is crucial for enhancing your coding skills and performing well in interviews. Start with basic patterns and gradually move to more complex ones to build a strong foundation. These notes summarize the key concepts and code examples from the tutorial video, providing a hands-on guide for students to practice and understand pattern printing in Java. Welcome to the next session on advanced pattern programming. Building on the basics we've covered, we'll now dive into more complex patterns, including number-based and string-based patterns. These patterns are crucial for enhancing problem-solving skills and are often featured in technical interviews. Advanced Pattern Programming Objective: Move beyond basic patterns to tackle more complex shapes and structures using different conditions and loops. Intermediat 18 c o d e r s n o t e . c o m
- 51. Understanding the Pattern Example Pattern: * *** ***** ******* ********* Rows: 5 Columns: 9 (though it might not be immediately obvious) Steps to Approach: 1. Identify Rows and Columns: Rows: 5 Columns: 9 (derived from the width of the pattern) 2. Sketch the Pattern: Visualizing the pattern helps understand the distribution of stars and spaces. General Steps for Pattern Programming 1. Determine the Number of Rows and Columns: Rows are often straightforward. Columns may require a closer look to understand the spacing and alignment. 2. Identify Patterns in Rows and Columns: Understand how stars and spaces are distributed. Look for symmetry and repetition. 3. Frame Conditions: Conditions help determine where to print stars ( ) and spaces ( ). Intermediat 19 c o d e r s n o t e . c o m
- 52. Detailed Walkthrough: Example Pattern Step-by-Step Explanation: 1. Rows and Columns: The pattern consists of 5 rows and 9 columns. 2. Conditions for Spaces and Stars: First Condition: Space is printed when j < num - i For Row 1 ( i=1 ), j < 5 - 1 = 4 (print spaces until j=4 ) For Row 2 ( i=2 ), j < 5 - 2 = 3 (print spaces until j=3 ) Continue similarly for other rows. Second Condition: Print stars after the spaces. Code Implementation: import java.util.Scanner; public class Pattern { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int n = scanner.nextInt(); // User input for (int i = 1; i <= n; i++) { for (int j = 1; j <= 2 * n - 1; j++) { if (j < n - i + 1 || j > n + i - 1) { System.out.print(" "); } else { System.out.print("*"); } } System.out.println(); // Move to the next line after each row } } } Explanation: Intermediat 20 c o d e r s n o t e . c o m
- 53. 1. Input: Number of rows n . 2. Outer Loop: Iterates through each row from 1 to n . 3. Inner Loop: Iterates through each column from 1 to 2 * n - 1 . Condition for Spaces: j < n - i + 1 || j > n + i - 1 Print Stars: In positions not covered by the space condition. 4. Newline: Move to the next line after printing each row. Output: Input: 5 Output: * *** ***** ******* ********* Exercise: Try This Pattern Objective: Create a similar pattern with a different shape. Pattern: **** * * * * * * **** Rows: 5 Columns: 4 Code Implementation: Intermediat 21 c o d e r s n o t e . c o m
- 54. import java.util.Scanner; public class HollowSquarePattern { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int n = scanner.nextInt(); // User input for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) { if (i == 1 || i == n || j == 1 || j == n) { System.out.print("* "); } else { System.out.print(" "); } } System.out.println(); // Move to the next line after each row } } } Explanation: 1. Outer Loop: Runs from 1 to n for rows. 2. Inner Loop: Runs from 1 to n for columns. 3. Conditions: Print stars at the borders ( i == 1 , i == n , j == 1 , j == n ). Print spaces for inner cells. Output: Input: 5 Output: * * * * * * * * * Intermediat 22 c o d e r s n o t e . c o m
- 55. * * * * * * * Conclusion By following these detailed steps and practicing different patterns, students can improve their problem-solving skills and prepare effectively for coding interviews. In the next session, we'll delve into more complex number-based and string- based patterns. Introduction to Pattern Coding In pattern coding, the goal is to print shapes or designs using loops in programming. This guide will walk through creating pattern programs where rows and columns are not equal and will delve into how to handle various conditions and constraints. Understanding the Problem Rows and Columns Inequality: When the number of rows and columns are different, additional conditions must be added to handle the pattern correctly. General Strategy: Identify the rules for rows ( i loop) and columns ( j loop) separately, ensuring they work for both even and odd inputs. Step-by-Step Solution 1. Identifying Row and Column Conditions: Example: For an input of 5, the pattern should have 5 rows and 9 columns. For an input of 4, it should have 4 rows and 7 columns. Key insight: Number of columns can be calculated as 2 * num - 1 . 2. Loop Structure: Outer loop for rows ( i ): for (int i = 1; i <= num; i++) Inner loop for columns ( j ): for (int j = 1; j <= 2 * num - 1; j++) Intermediat 23 c o d e r s n o t e . c o m
- 56. Implementing the Solution 1. Printing a Rectangle Box Pattern: Basic structure to print stars ( ) in a rectangle box: for (int i = 1; i <= num; i++) { for (int j = 1; j <= 2 * num - 1; j++) { System.out.print("*"); } System.out.println(); } 2. Adding Spaces and Stars: Determine where to print spaces and stars based on the position. Use conditions to control the printing: Spaces before stars: if (j <= num - i) System.out.print(" "); Stars after spaces: else System.out.print("*"); 3. Pattern with Number Decreasing and Increasing: Determine the positions for spaces and stars, ensuring correct placement: if (j <= num - i) { System.out.print(" "); } else if (j <= num + i - 1) { System.out.print("*"); } Example Code: Diamond Shape public class PatternExample { public static void main(String[] args) { int num = 5; // Example input for (int i = 1; i <= num; i++) { Intermediat 24 c o d e r s n o t e . c o m
- 57. for (int j = 1; j <= 2 * num - 1; j++) { if (j <= num - i) { System.out.print(" "); } else if (j <= num + i - 1) { System.out.print("*"); } } System.out.println(); } for (int i = num - 1; i >= 1; i--) { for (int j = 1; j <= 2 * num - 1; j++) { if (j <= num - i) { System.out.print(" "); } else if (j <= num + i - 1) { System.out.print("*"); } } System.out.println(); } } } Advanced Pattern: Handling Strings 1. String-based Patterns: Instead of stars, print characters of a string in a specific pattern. Example: Diagonal string pattern. 2. Steps to Implement: Scan the input string. Calculate the length of the string. Print characters based on their positions. Intermediat 25 c o d e r s n o t e . c o m
- 58. Example Code: Diagonal String Pattern import java.util.Scanner; public class StringPatternExample { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); String input = scanner.nextLine(); int num = input.length(); for (int i = 1; i <= num; i++) { for (int j = 1; j <= 2 * num - 1; j++) { if (j == i || j == (2 * num - i)) { System.out.print(input.charAt(i - 1)); } else { System.out.print(" "); } } System.out.println(); } } } Summary Pattern Coding involves understanding the structure and applying loops and conditions. Handling Inequality in rows and columns requires careful condition management. Advanced Patterns can include characters and strings, adding complexity but following similar logical rules. By breaking down the problem, identifying patterns, and applying correct conditions, various intricate patterns can be created effectively using basic loops and conditions in Java. Intermediat 26 c o d e r s n o t e . c o m
- 59. Definition: An array is a data structure that stores a collection of elements of the same data type. Purpose: It allows efficient management of multiple data items under a single name, reducing the need for multiple variables. Array Creation Declaration: Arrays are declared with a specific data type and size in Java. int[] a = new int[5]; int[] denotes an array of integers. new int[5] allocates memory for 5 integer elements. Memory Allocation: When an array is declared, memory is allocated in the RAM: Each element in the array occupies a contiguous memory location. Indexing starts from 0 up to length-1 . Accessing Array Elements Indexing: Elements in an array are accessed using their index: a[0] = 748; // Assigning value to the first element int value = a[0]; // Accessing value from the first element Indexing starts at 0 ( a[0] refers to the first element). Inputting and Outputting Array Elements Inputting Values: Using Scanner for user input: Scanner sc = new Scanner(System.in); for (int i = 0; i < a.length; i++) { Intermediat 27 c o d e r s n o t e . c o m
- 60. a[i] = sc.nextInt(); } Reads input values and assigns them to array elements. Outputting Values: Printing array elements: for (int i = 0; i < a.length; i++) { System.out.println("Element at index " + i + ": " + a[i]); } Outputs each element along with its index. Efficiency with Loops For Loops: Using loops for efficient operations: // Initialization, Condition, Increment for (int i = 0; i < a.length; i++) { // Perform operations with array elements } Simplifies repetitive tasks such as assigning values or printing elements. Important Concepts Array Size: Determined at declaration ( new int[5] allocates space for 5 integers). Indexing: Starts from 0 to length-1 . Looping through Arrays: Enhances efficiency in tasks like input, output, and manipulation. Conclusion Arrays are fundamental in programming, crucial for both product-based and service-based companies. Practice is essential for mastering array operations such as creation, insertion, searching, deletion, and sorting. Intermediat 28 c o d e r s n o t e . c o m
- 61. Next Steps Explore advanced array operations such as insertion, searching, deletion, and sorting in upcoming sessions. Practice solving array-based problems to strengthen understanding and proficiency. Introduction to Array Insertion Understanding Array Limits An array in Java is a fixed-size data structure where each element is indexed sequentially from 0 to size-1. Attempting to access or insert elements beyond the array's declared size leads to ArrayIndexOutOfBoundsException . Efficient Insertion Concept Efficient code is characterized by minimal time and space complexity. For arrays, efficient insertion involves shifting elements to accommodate new entries. Insertion Process Step-by-Step Insertion Methodology 1. Array Declaration and Initialization Start by declaring an array of a predetermined size or dynamically based on input. int[] a = new int[10]; // Example array of size 10 2. Prompt for Array Size Ask the user for the actual number of elements they intend to insert into the array ( size ). Intermediat 29 c o d e r s n o t e . c o m
- 62. System.out.println("Enter the number of elements:"); int size = scanner.nextInt(); // Assuming 'scanner' is initialized for input 3. Populating the Array Use a loop to populate the array with values up to the specified size. System.out.println("Enter " + size + " elements:"); for (int i = 0; i < size; i++) { a[i] = scanner.nextInt(); // Read and store each element in the array } 4. Insertion Function Define a function/method to insert a new element at a specified position ( pos ) in the array. public static void insertElement(int[] a, int size, int element, int pos) { // Shift elements to the right to make space for the new element for (int i = size - 1; i >= pos; i--) { a[i + 1] = a[i]; } // Insert the new element at the specified position a[pos] = element; // Increment the size of the array size++; } 5. Implementation of Insertion Call the insertElement method after populating the array to add a new element ( element ) at a specific position ( pos ). insertElement(a, size, 26, 3); // Example: Inserting 26 at position 3 6. Output the Updated Array Intermediat 30 c o d e r s n o t e . c o m
- 63. Display the updated array to verify the insertion operation. System.out.println("Array after insertion:"); for (int i = 0; i < size; i++) { System.out.println("Index " + i + ": " + a[i]); } Summary Key Points: Array size is fixed once declared. Insertion requires shifting existing elements to accommodate new entries. Efficient insertion minimizes both time and space complexities. Implementation Tips: Always handle edge cases, such as inserting at the beginning or end of the array. Use a backward traversal loop for shifting elements during insertion to avoid overwriting values prematurely. Conclusion Understanding array insertion in Java involves grasping the concepts of array limits, efficient coding practices, and the step-by-step methodology for safely inserting elements. By mastering this process, programmers can effectively manage data within fixed-size arrays, ensuring optimal performance and reliability in their applications. Overview Array deletion involves removing an element from a specific index in an array and shifting subsequent elements to fill the gap. This operation is essential for managing dynamic arrays and efficiently using memory space. Detailed Steps and Explanation Intermediat 31 c o d e r s n o t e . c o m
- 64. 1. Initialization and Setup Start with an array a and initialize its size ( size ) and capacity ( capacity ). Ensure size tracks the number of elements actually stored in the array, while capacity indicates the maximum number of elements it can hold without resizing. 2. Deleting an Element To delete an element at index pos : Adjust Size: Decrease the size by one ( size-- ) to reflect the removal of one element. Shift Elements: Traverse the array from pos to size-1 and shift each element one position to the left. for (int i = pos; i < size - 1; i++) { a[i] = a[i + 1]; } After the loop completes, the last position ( size-1 ) will contain a duplicate of the previous last element, which is now redundant. 3. Update Size Ensure to update the size after shifting elements: size--; 4. Edge Cases Bounds Checking: Always ensure that the index pos is within the valid range ( 0 to size-1 ) to avoid accessing out-of-bound memory. Memory Management: If the array reaches its capacity ( capacity ), consider resizing operations to accommodate more elements efficiently. 5. Example Implementation Intermediat 32 c o d e r s n o t e . c o m
- 65. public class ArrayDeletionExample { private int[] a; private int size; private int capacity; public ArrayDeletionExample(int capacity) { this.a = new int[capacity]; this.size = 0; this.capacity = capacity; } public void deleteElement(int pos) { if (pos < 0 || pos >= size) { System.out.println("Invalid position to delete."); return; } // Shift elements for (int i = pos; i < size - 1; i++) { a[i] = a[i + 1]; } // Update size size--; } } Practical Application Scenario: Suppose we have an array representing student scores. Deleting a score at a specific index ( pos ) allows us to manage and update the array dynamically as scores change or new scores are added. Implementation: By following the steps above, we ensure that our array remains consistent and efficient, managing memory effectively without unnecessary gaps or duplicates. Intermediat 33 c o d e r s n o t e . c o m
- 66. Conclusion Understanding array deletion is crucial for anyone working with data structures and algorithms. It forms the basis for more complex operations like sorting and searching, enabling efficient manipulation of data stored in arrays. Introduction In this tutorial session, we'll delve into the fundamental concepts of searching and sorting arrays in Java. These operations are essential for organizing and retrieving data efficiently in programming. Searching Arrays 1. Searching by Value: To search for a specific value in an array, traverse through each element and compare it with the target value ( element ). System.out.println("Enter the array size:"); int size = sc.nextInt(); int[] a = new int[size]; // Input array elements for (int i = 0; i < size; i++) { a[i] = sc.nextInt(); } System.out.println("Enter the value to search:"); int element = sc.nextInt(); // Search for element in the array for (int i = 0; i < size; i++) { if (a[i] == element) { System.out.println("Element found at index: " + i); break; Intermediat 34 c o d e r s n o t e . c o m
- 67. } } 2. Searching by Index: If you know the index ( position ) and want to retrieve the element directly: System.out.println("Enter the position to search:"); int position = sc.nextInt(); System.out.println("Element at position " + position + ": " + a[position]); Sorting Arrays 1. Bubble Sort: Bubble sort is a straightforward sorting algorithm where adjacent elements are compared and swapped if necessary to arrange elements in ascending or descending order. // Bubble Sort implementation for (int i = 0; i < a.length - 1; i++) { for (int j = 0; j < a.length - i - 1; j++) { if (a[j] > a[j + 1]) { // Swap elements int temp = a[j]; a[j] = a[j + 1]; a[j + 1] = temp; } } } 2. Selection Sort: Selection sort works by repeatedly finding the minimum element from the unsorted part of the array and swapping it with the first unsorted element. Intermediat 35 c o d e r s n o t e . c o m
- 68. // Selection Sort implementation for (int i = 0; i < a.length - 1; i++) { int minIndex = i; for (int j = i + 1; j < a.length; j++) { if (a[j] < a[minIndex]) { minIndex = j; } } // Swap elements int temp = a[minIndex]; a[minIndex] = a[i]; a[i] = temp; } Practical Application Searching Use Case: Finding a specific student record by ID in a student database stored as an array. Sorting Use Case: Organizing a list of scores in ascending order to determine top performers. Conclusion Understanding these fundamental operations—searching and sorting—is crucial for efficient data manipulation in programming. Mastery of these concepts forms the basis for tackling more complex algorithms and data structures. Intermediat 36 c o d e r s n o t e . c o m
- 69. Advanced Introduction In this session, we will learn how to find the smallest and second smallest elements in an array efficiently. This problem is crucial for coding interviews and exams, where time complexity constraints are common. We will discuss: 1. Basic concept and naive solution. 2. Efficient solution with time complexity considerations. Concepts Covered Array Basics: Understanding how to manipulate arrays. Time Complexity: Importance of optimizing code to run within permissible limits. Finding Smallest and Second Smallest Elements: Using single and nested loops. Finding the Smallest Element To find the smallest element in an array, follow these steps: 1. Initialize a variable min to store the minimum value. 2. Iterate through the array and update min whenever a smaller element is found. int min = array[0]; // Assume the first element is the smallest for (int i = 1; i < array.length; i++) { if (array[i] < min) { min = array[i]; // Update min if a smaller element is found } } System.out.println("The smallest element is: " + min); Advanced 1 c o d e r s n o t e . c o m
- 70. Finding the Second Smallest Element (Naive Approach) The naive approach involves sorting the array and picking the first two elements. This method, however, has a time complexity of O(n log n) due to sorting. Arrays.sort(array); int smallest = array[0]; int secondSmallest = array[1]; System.out.println("The smallest element is: " + smallest); System.out.println("The second smallest element is: " + secondSmallest); Efficient Approach with O(n) Time Complexity To find the second smallest element efficiently: 1. Initialize two variables min and secondMin to store the smallest and second smallest elements, respectively. 2. Iterate through the array to find these elements in a single pass. Step-by-Step Implementation: 1. Initialize min and secondMin : int min = Integer.MAX_VALUE; int secondMin = Integer.MAX_VALUE; 2. Iterate through the array: for (int i = 0; i < array.length; i++) { if (array[i] < min) { // Update secondMin before changing min secondMin = min; min = array[i]; } else if (array[i] < secondMin && array[i] != min) { // Update secondMin if current element is not equal to min secondMin = array[i]; Advanced 2 c o d e r s n o t e . c o m
- 71. } } 3. Handle Edge Cases: Ensure the array has at least two distinct elements. Code Example public class SecondSmallest { public static void main(String[] args) { int[] array = {2, 4, 1, 3, 5, -2, -4}; if (array.length < 2) { System.out.println("Array must have at least two elements."); return; } int min = Integer.MAX_VALUE; int secondMin = Integer.MAX_VALUE; for (int i = 0; i < array.length; i++) { if (array[i] < min) { secondMin = min; min = array[i]; } else if (array[i] < secondMin && array[i] != min) { secondMin = array[i]; } } if (secondMin == Integer.MAX_VALUE) { System.out.println("No second smallest element found."); } else { System.out.println("The smallest element is: " + min); System.out.println("The second smallest element is: " + secondMin); } Advanced 3 c o d e r s n o t e . c o m
- 72. } } Explanation of the Efficient Approach Initialization: We start with min and secondMin set to Integer.MAX_VALUE to ensure any element in the array will be smaller initially. Single Pass: We iterate through the array once. The first condition ( array[i] < min ) ensures that we always have the smallest element in min . The second condition ( array[i] < secondMin && array[i] != min ) ensures that secondMin is the smallest element greater than min . Edge Cases: If the array has fewer than two distinct elements, we handle it by checking the length and final values of min and secondMin . Summary Understanding Array Manipulation: Finding specific elements using loops. Importance of Time Complexity: Reducing nested loops to optimize performance. Hands-On Coding: Implementing both naive and efficient solutions. By following these steps and understanding the code, you can efficiently find the smallest and second smallest elements in an array, a crucial skill for technical interviews and exams. Introduction The sliding window technique is a powerful method used to solve various array- related problems. It involves creating a "window" that slides over the array to evaluate a subset of elements at a time. This tutorial focuses on finding the maximum value within each subset (window) of a fixed size. Problem Explanation Given an array of integers and a window size ( k ), the goal is to find the maximum value within each window as it slides from the start to the end of the Advanced 4 c o d e r s n o t e . c o m
- 73. array. For example, if the array is [3, 5, 4, 8, 6, 7, 2, 9] and the window size is 3, the task is to find the maximum values for each subset of 3 consecutive elements. Steps to Solve the Problem 1. Understanding the Inputs and Outputs: Input: An array of integers and a window size ( k ). Output: An array of maximum values from each sliding window. 2. Initialize Variables: An array to store the input values. Variables to hold the size of the array and the window size ( k ). A variable to track the maximum value in the current window. 3. Sliding Window Mechanism: Use nested loops to iterate through the array. The outer loop defines the starting point of the window. The inner loop iterates through the elements within the window to find the maximum value. Update the maximum value as needed while iterating through the window. Example Consider the array [3, 5, 4, 8, 6, 7, 2, 9] with a window size ( k = 3 ): 1. The first window is [3, 5, 4]. The maximum value is 5. 2. The second window is [5, 4, 8]. The maximum value is 8. 3. The third window is [4, 8, 6]. The maximum value is 8. 4. The fourth window is [8, 6, 7]. The maximum value is 8. 5. The fifth window is [6, 7, 2]. The maximum value is 7. 6. The sixth window is [7, 2, 9]. The maximum value is 9. The output array of maximum values is [5, 8, 8, 8, 7, 9]. Advanced 5 c o d e r s n o t e . c o m
- 74. Implementation in Java import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); // Input size of the array System.out.println("Enter the size of the array:"); int n = scanner.nextInt(); // Create the array and take input values int[] array = new int[n]; System.out.println("Enter the elements of the array:"); for (int i = 0; i < n; i++) { array[i] = scanner.nextInt(); } // Input the window size System.out.println("Enter the window size:"); int k = scanner.nextInt(); // Implement the sliding window algorithm for (int i = 0; i <= n - k; i++) { int max = array[i]; for (int j = i; j < i + k; j++) { if (array[j] > max) { max = array[j]; } } System.out.print(max + " "); } } } Advanced 6 c o d e r s n o t e . c o m
- 75. Detailed Explanation of Code 1. Input Handling: The size of the array ( n ) and the elements of the array are taken as input. The window size ( k ) is also taken as input. 2. Outer Loop: Iterates from the start of the array to ( n - k ). This ensures the window does not exceed the array boundaries. 3. Inner Loop: For each position of the outer loop, the inner loop iterates from the current index ( i ) to ( i + k - 1 ). It compares each element within the window to find the maximum value. 4. Output: The maximum value of each window is printed. Debugging and Optimization Tips 1. Initialization: Ensure the max variable is initialized at the start of each new window. 2. Edge Cases: Consider edge cases such as when ( k ) is larger than the array size. 3. Efficiency: The given approach has a time complexity of ( O(n times k) ). For larger arrays and window sizes, consider using more efficient methods like Deque to achieve ( O(n) ) complexity. Conclusion The sliding window technique is essential for solving problems that require analysis of contiguous subarrays. Practicing this technique with various problems will improve your understanding and ability to implement it efficiently. Advanced 7 c o d e r s n o t e . c o m
- 76. Introduction In this session, we delve into solving an array rotation problem frequently encountered in product-based company interviews. The goal is to rotate an array to the right by a given number of positions. We'll explore a detailed step-by-step approach to understand the problem, develop a solution, and optimize the code. Problem Explanation Given an array and a number k , rotate the array to the right by k positions. For example, rotating the array [1, 2, 3, 4, 5] to the right by 2 positions results in [4, 5, 1, 2, 3] . Steps to Approach the Problem 1. Understand the Input and Output: Input: Array [1, 2, 3, 4, 5] , Rotation count k = 2 Output: Array [4, 5, 1, 2, 3] 2. Identify Key Concepts: Rotation: Shifting elements of the array to the right. Modulo Operation: Helps in wrapping around the array indices. Visualizing the Rotation Consider an array: [1, 2, 3, 4, 5] Rotate by 1: [5, 1, 2, 3, 4] Rotate by 2: [4, 5, 1, 2, 3] Explanation: Each element is shifted right by one position. The last element wraps around to the beginning. Advanced 8 c o d e r s n o t e . c o m
- 77. Detailed Solution Initial Approach 1. Manual Rotation: Take the last element and insert it at the beginning. Repeat this k times. Code Implementation (Initial Approach) import java.util.Scanner; public class ArrayRotation { public static void main(String[] args) { Scanner ss = new Scanner(System.in); int n = ss.nextInt(); int[] array = new int[n]; for (int i = 0; i < n; i++) { array[i] = ss.nextInt(); } int rotate = ss.nextInt(); for (int k = 1; k <= rotate; k++) { int temp = array[n - 1]; for (int i = n - 2; i >= 0; i--) { array[i + 1] = array[i]; } array[0] = temp; } for (int i = 0; i < n; i++) { System.out.print(array[i] + " "); } } } Advanced 9 c o d e r s n o t e . c o m
- 78. Explanation: Outer Loop: Runs rotate times. Inner Loop: Shifts elements to the right. Temp Variable: Holds the last element to place it at the beginning. Optimized Approach 1. Modulo Operation: Avoid unnecessary rotations by reducing k using k = k % n . Create a new array b to hold rotated values. Code Implementation (Optimized Approach) import java.util.Scanner; public class ArrayRotation { public static void main(String[] args) { Scanner ss = new Scanner(System.in); int n = ss.nextInt(); int[] array = new int[n]; for (int i = 0; i < n; i++) { array[i] = ss.nextInt(); } int rotate = ss.nextInt(); rotate = rotate % n; // Optimized rotation count int[] b = new int[n]; for (int i = 0; i < n; i++) { b[(i + rotate) % n] = array[i]; } for (int i = 0; i < n; i++) { System.out.print(b[i] + " "); } Advanced 10 c o d e r s n o t e . c o m
- 79. } } Explanation: Modulo Operation: (i + rotate) % n ensures proper wrapping of indices. New Array b : Directly places elements in their rotated positions. Additional Concepts Time Complexity: O(n), as each element is processed once. Space Complexity: O(n), due to the additional array used for the result. Exercises 1. Left Rotation: Modify the code to rotate the array to the left by k positions. 2. In-place Rotation: Implement the rotation in place to reduce space complexity. 3. Practice with Different Inputs: Try rotating arrays of various sizes and different values of k to strengthen understanding. Conclusion Understanding array rotations involves both logical reasoning and efficient coding practices. By breaking down the problem, visualizing the steps, and using optimized solutions, we can effectively tackle array rotation questions in technical interviews. Overview In this tutorial, we'll cover the problem of finding the minimum number of swaps required to rearrange an array such that all elements on the left of a given key Advanced 11 c o d e r s n o t e . c o m
- 80. element are less than the key and all elements on the right are greater than the key. This problem is useful for understanding array manipulation and optimizing operations within constraints. Key Concepts 1. Array Basics: Understanding basic operations on arrays, such as iteration and element comparison. 2. Two-Pointer Technique: Using two pointers to traverse the array from both ends. 3. Conditional Logic: Applying conditions to determine when to perform swaps. 4. Optimization: Minimizing the number of operations needed to achieve the desired arrangement. Problem Statement Given an array and a key value, rearrange the array so that all elements less than the key are on the left, and all elements greater than the key are on the right. Determine the minimum number of swaps required to achieve this arrangement. Example Array: [2, 5, 3, 6, 7, 1] Key: 3 Desired Output: Minimum number of swaps to rearrange the array. Steps to Solve the Problem 1. Initialize Variables: I : Pointer starting from the left (index 0). J : Pointer starting from the right (index n-1). count : To keep track of the number of swaps. 2. Iterate Until Pointers Meet: Loop until I is less than J . Advanced 12 c o d e r s n o t e . c o m
- 81. 3. Left Pointer Condition: If array[I] is less than or equal to the key, increment I . Otherwise, pause at the current position. 4. Right Pointer Condition: If array[J] is greater than or equal to the key, decrement J . Otherwise, pause at the current position. 5. Swap Elements: If the current element at I is greater than the key and the current element at J is less than the key, swap them. Increment the count of swaps. Move I and J to the next positions. 6. Edge Cases: Ensure that the algorithm handles cases where elements are already in the correct position. Handle duplicate values gracefully. Example Walkthrough Consider the array [2, 5, 3, 6, 7, 1] and key 3 . 1. Initialization: I = 0 , J = 5 , count = 0 2. Iteration: First iteration: I = 0 , J = 5 array[I] = 2 (less than key) -> I++ array[J] = 1 (less than key) -> Pause J Second iteration: I = 1 , J = 5 array[I] = 5 (greater than key) -> Pause I array[J] = 1 (less than key) -> Swap array[I] and array[J] Advanced 13 c o d e r s n o t e . c o m
- 82. count++ , I++ , J-- Continue this process until I meets or exceeds J . Implementation in Java import java.util.Scanner; public class MinimumSwaps { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int n = scanner.nextInt(); // Array size int[] array = new int[n]; // Reading array elements for (int i = 0; i < n; i++) { array[i] = scanner.nextInt(); } int key = scanner.nextInt(); // Key value int count = 0; // Swap count int i = 0, j = n - 1; // Pointers while (i < j) { while (i < j && array[i] <= key) { i++; } while (i < j && array[j] > key) { j--; } if (i < j) { // Swap elements int temp = array[i]; array[i] = array[j]; array[j] = temp; Advanced 14 c o d e r s n o t e . c o m
- 83. count++; i++; j--; } } System.out.println("Minimum number of swaps: " + count); scanner.close(); } } Conclusion By using the two-pointer technique and conditionally swapping elements, we can efficiently solve the minimum swaps problem. This approach minimizes the number of operations and helps in understanding how to manipulate arrays effectively. Practice similar problems to strengthen your understanding of array manipulation and optimization techniques. Additional Exercises 1. Modify the code to handle left rotations. 2. Extend the code to support multidimensional arrays. 3. Implement a function to handle different key values dynamically. By practicing these variations, you will gain a deeper understanding of array operations and become more proficient in solving related problems. Overview In this session, we will learn about multi-dimensional arrays. A multi-dimensional array can be visualized as arrays within arrays, where a one-dimensional array is a simple list, a two-dimensional array can be seen as a grid or a matrix, and higher-dimensional arrays extend this concept further. Advanced 15 c o d e r s n o t e . c o m
- 84. Definitions One-Dimensional Array: A list of elements, each identified by a single index. Two-Dimensional Array: A grid or matrix where each element is identified by two indices, representing rows and columns. Three-Dimensional Array: Conceptually a cube of data, identified by three indices (row, column, and depth). Syntax and Initialization One-Dimensional Array int[] a = new int[5]; This creates an array a of size 5. Two-Dimensional Array int[][] a = new int[5][5]; This creates a 5x5 matrix, an array of arrays. Visualization Consider a 2D array: [ [0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4] ] Each element in this array can be accessed using two indices. For example, a[2][3] accesses the element at the 3rd column of the 2nd row. Advanced 16 c o d e r s n o t e . c o m
- 85. Implementation Steps Declaring and Initializing a 2D Array int n = scanner.nextInt(); // User-defined size int[][] a = new int[n][n]; Scanning Values into a 2D Array for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { a[i][j] = scanner.nextInt(); } } Printing a 2D Array for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { System.out.print(a[i][j] + " "); } System.out.println(); } Using printf for Better Formatting for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { System.out.printf("%2d ", a[i][j]); } System.out.println(); } Advanced 17 c o d e r s n o t e . c o m
- 86. Using printf with %2d ensures that each number occupies at least two spaces, making the output more readable. Example Code Here is a complete example code that demonstrates the initialization, input, and output of a 2D array: import java.util.Scanner; public class MultiDimensionalArray { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.println("Enter the size of the array:"); int n = scanner.nextInt(); // Reading the size of the array int[][] a = new int[n][n]; // Declaring a 2D array // Scanning values into the array System.out.println("Enter the elements of the array:"); for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { a[i][j] = scanner.nextInt(); } } // Printing the array System.out.println("The 2D array is:"); for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { System.out.printf("%2d ", a[i][j]); } System.out.println(); } Advanced 18 c o d e r s n o t e . c o m
- 87. } } Manually Initializing a 2D Array Instead of taking input from the user, you can directly initialize a 2D array with predefined values: int[][] a = { {1, 2, 3, 4, 5}, {6, 7, 8, 9, 10}, {11, 12, 13, 14, 15}, {16, 17, 18, 19, 20}, {21, 22, 23, 24, 25} }; This creates a 5x5 matrix with specified values. Summary 1D Array: Simple list, single index. 2D Array: Matrix or grid, two indices. 3D Array: Cube-like structure, three indices. Syntax and Initialization: Use square brackets to denote dimensions. Indexing: Access elements using indices corresponding to the dimensions. Printing and Formatting: Use nested loops and printf for structured output. In the next session, we will solve a practical problem using 2D arrays and move on to working with strings. Practice initializing and manipulating arrays to get a solid understanding before proceeding. Introduction Advanced 19 c o d e r s n o t e . c o m
- 88. Overview In coding interviews, one common type of problem involves multi-dimensional arrays, particularly the spiral matrix problem. Understanding how to navigate and manipulate these arrays is crucial. This guide will help you understand how to approach and solve spiral matrix problems, a skill that will serve you well in technical interviews. Key Concepts Multi-dimensional arrays Matrix traversal Spiral order Spiral Matrix Problem Problem Definition Given a matrix, the task is to print the elements in a spiral order. This involves starting from the top-left corner of the matrix and traversing it in a spiral manner until all elements are covered. Example Consider the following 5x5 matrix: 1 2 3 4 5 16 17 18 19 6 15 24 25 20 7 14 23 22 21 8 13 12 11 10 9 The spiral order traversal of this matrix is: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25 Approach Advanced 20 c o d e r s n o t e . c o m
- 89. Step-by-Step Strategy 1. Initialization: Define four variables to keep track of the boundaries of the matrix: row_start , row_end , col_start , and col_end . Initialize them to the respective starting and ending indices of the matrix. 2. Traversal: Use a while loop to traverse the matrix until the boundaries overlap. Inside the loop, use four nested for loops to traverse: From left to right across the top row. From top to bottom down the right column. From right to left across the bottom row. From bottom to top up the left column. Adjust the boundaries after each traversal to move inward. 3. Edge Case: Ensure to handle the case where the matrix center needs to be printed separately if the boundaries converge at a single point. Implementation def spiral_order(matrix): result = [] if not matrix: return result row_start, row_end = 0, len(matrix) - 1 col_start, col_end = 0, len(matrix[0]) - 1 while row_start <= row_end and col_start <= col_end: # Traverse from left to right for col in range(col_start, col_end + 1): Advanced 21 c o d e r s n o t e . c o m
- 90. result.append(matrix[row_start][col]) row_start += 1 # Traverse from top to bottom for row in range(row_start, row_end + 1): result.append(matrix[row][col_end]) col_end -= 1 # Traverse from right to left if row_start <= row_end: for col in range(col_end, col_start - 1, -1): result.append(matrix[row_end][col]) row_end -= 1 # Traverse from bottom to top if col_start <= col_end: for row in range(row_end, row_start - 1, -1): result.append(matrix[row][col_start]) col_start += 1 return result # Example usage matrix = [ [1, 2, 3, 4, 5], [16, 17, 18, 19, 6], [15, 24, 25, 20, 7], [14, 23, 22, 21, 8], [13, 12, 11, 10, 9] ] print(spiral_order(matrix)) Explanation of Code Initialization: Advanced 22 c o d e r s n o t e . c o m
- 91. result list is used to store the elements in spiral order. row_start , row_end , col_start , and col_end are initialized to the boundaries of the matrix. Traversal: The while loop continues until row_start exceeds row_end or col_start exceeds col_end . The first for loop traverses from col_start to col_end along the row_start row. The second for loop traverses from row_start to row_end down the col_end column. The third for loop traverses from col_end to col_start along the row_end row. The fourth for loop traverses from row_end to row_start up the col_start column. After each traversal, the respective boundary is adjusted. Edge Case Handling: Conditions ensure that the matrix is only traversed within valid boundaries, preventing out-of-bound errors. Practice Problems To solidify your understanding, try solving these variations: 1. Rotate Matrix: Rotate the given matrix by 90 degrees clockwise. 2. Matrix Diagonal Traversal: Print the elements of the matrix in a diagonal order. Conclusion Understanding how to navigate and manipulate multi-dimensional arrays is a crucial skill for coding interviews. The spiral matrix problem is a classic example that tests your ability to handle complex traversals. Practice this approach, and try implementing similar problems to gain confidence. Advanced 23 c o d e r s n o t e . c o m
- 92. Introduction to Mutable and Immutable Strings Immutable Strings: Once created, the content of an immutable string cannot be changed. Mutable Strings: The content can be modified after creation, using classes like StringBuilder and StringBuffer . Immutable Strings Memory Uniqueness: Each unique string value occupies a single memory location. String Pool: Java uses a string pool to manage memory for strings. Identical string literals share the same memory location. Example: Both s1 and s2 point to the same memory location since the string content is identical and no explicit instantiation is done. String s1 = "hello"; String s2 = "hello"; String Instantiation New Keyword: Using new String() creates a new memory location. Example: Here, s1 and s2 do not share the same memory location because s2 is explicitly instantiated. String s1 = "hello"; String s2 = new String("hello"); Advanced 24 c o d e r s n o t e . c o m
- 93. Mutable Strings with StringBuilder and StringBuffer Mutable Classes: StringBuilder and StringBuffer allow string modification. Usage: The content of sb can be modified, and the changes are made in the same memory location. StringBuilder sb = new StringBuilder("hello"); sb.append(" world"); Practical Examples and Code Snippets Immutable Strings 1. String Creation: String s1 = "hello"; String s2 = "hello"; // s1 and s2 share the same memory location. 2. Instantiation: String s1 = "hello"; String s2 = new String("hello"); // s1 and s2 do not share the same memory location. 3. Concatenation: String s1 = "hello"; String s2 = s1 + " world"; // s2 is a new string, s1 remains unchanged. Mutable Strings 1. Using StringBuilder: Advanced 25 c o d e r s n o t e . c o m
- 94. StringBuilder sb = new StringBuilder("hello"); sb.append(" world"); // sb now contains "hello world". 2. Using StringBuffer: StringBuffer sb = new StringBuffer("hello"); sb.append(" world"); // sb now contains "hello world". Memory Management and Efficiency Memory Sharing: Immutable strings can share memory locations to save space. Memory Instantiation: Creating new instances of strings consumes more memory. Mutable Strings: Efficient for frequent modifications without creating new objects. String Equality Reference Equality ( == ): Checks if two references point to the same memory location. String s1 = "hello"; String s2 = "hello"; boolean result = (s1 == s2); // true Value Equality ( .equals() ): Checks if two strings have the same content. String s1 = new String("hello"); String s2 = new String("hello"); boolean result = s1.equals(s2); // true Advanced 26 c o d e r s n o t e . c o m
- 95. Conclusion Understanding the differences between mutable and immutable strings is crucial for efficient memory management and performance optimization in Java. Use immutable strings for fixed values and mutable strings when frequent modifications are needed. Summary Immutable Strings: Fixed memory location, shared if content is identical, no modifications allowed. Mutable Strings: Flexible memory location, allow modifications, suitable for dynamic content. Additional Tips Prefer immutable strings for constant values. Use StringBuilder or StringBuffer for strings that change frequently. Understand the implications of string instantiation on memory usage. Introduction to Strings In Java, strings are a fundamental data type used to represent text. They are objects of the String class and are immutable, meaning once created, their values cannot be changed. However, Java provides several methods and classes to manipulate strings efficiently. Basic String Operations Creating a String A string in Java can be created simply by assigning a sequence of characters to a variable: String s = "learn to code"; Advanced 27 c o d e r s n o t e . c o m
- 96. Printing a String To print a string, you can use the System.out.println method: System.out.println(s); // Output: learn to code Accessing Characters in a String You cannot directly access characters in a string using square brackets as you do with arrays. Instead, use the charAt method: char c = s.charAt(2); // Output: 'a' Converting String to Character Array You can convert a string to a character array using the toCharArray method: char[] charArray = s.toCharArray(); System.out.println(charArray[2]); // Output: 'a' String Manipulation Methods Length of a String To find the length of a string, use the length method: int length = s.length(); // Output: 13 Changing Case To convert a string to uppercase or lowercase, use the toUpperCase and toLowerCase methods: String upper = s.toUpperCase(); // Output: LEARN TO CODE String lower = s.toLowerCase(); // Output: learn to code Advanced 28 c o d e r s n o t e . c o m
- 97. Searching within a String Use indexOf to find the first occurrence and lastIndexOf to find the last occurrence of a character or substring: int index = s.indexOf('e'); // Output: 1 int lastIndex = s.lastIndexOf('e'); // Output: 9 Replacing Characters To replace characters or substrings, use the replace , replaceFirst , and replaceAll methods: String replaced = s.replace('e', 'i'); // Output: liarn to codi String replacedFirst = s.replaceFirst("e", "i"); // Output: liarn to code String replacedAll = s.replaceAll("e", "i"); // Output: liarn to codi Checking Content Use contains , startsWith , and endsWith methods to check for specific content within a string: boolean contains = s.contains("learn"); // Output: true boolean startsWith = s.startsWith("learn"); // Output: true boolean endsWith = s.endsWith("code"); // Output: true String Buffer for Mutability Unlike String , StringBuffer is mutable, meaning its contents can be changed after creation. It is used for creating modifiable strings. Creating a StringBuffer StringBuffer sb = new StringBuffer("learn to code"); System.out.println(sb); // Output: learn to code Advanced 29 c o d e r s n o t e . c o m
- 98. Appending to StringBuffer Use the append method to add text: sb.append(" with Java"); System.out.println(sb); // Output: learn to code with Java Deleting from StringBuffer Use the delete method to remove a portion of the text: sb.delete(10, 14); // Removes "code" System.out.println(sb); // Output: learn to with Java Inserting into StringBuffer Use the insert method to add text at a specific position: sb.insert(10, "program "); // Inserts "program " System.out.println(sb); // Output: learn to program with Java Reversing a StringBuffer Use the reverse method to reverse the contents: sb.reverse(); System.out.println(sb); // Output: avaJ htiw margorp ot nrael Advanced String Manipulation: StringTokenizer StringTokenizer is used to split a string into tokens based on specified delimiters. Using StringTokenizer StringTokenizer st = new StringTokenizer(s, " "); while (st.hasMoreTokens()) { System.out.println(st.nextToken()); Advanced 30 c o d e r s n o t e . c o m
- 99. } // Output: // learn // to // code Summary String manipulation is an essential part of Java programming. Understanding and mastering the various methods and classes available for string operations can greatly enhance your coding efficiency and capability. Practice these methods to become proficient in handling strings in Java. Key Points to Remember 1. Strings in Java are immutable. 2. Use charAt for accessing characters and toCharArray for converting to a character array. 3. Utilize StringBuffer for mutable string operations. 4. StringTokenizer helps in splitting strings into tokens. Practice Problems 1. Write a program to count the number of vowels in a given string. 2. Create a function that reverses each word in a given string. 3. Implement a method to find the longest substring without repeating characters. By understanding and using these string manipulation techniques, you'll be well- equipped to handle a wide range of programming challenges in Java. Introduction to String Tokenizer In the previous sessions, we covered strings and string buffers. Now, we will delve into string tokenizer, a feature that adds functionality not available in both strings Advanced 31 c o d e r s n o t e . c o m
- 100. and string buffers. What is a String Tokenizer? A string tokenizer in Java is used to split a string into tokens based on specified delimiters. It is a part of the java.util package. Syntax import java.util.StringTokenizer; StringTokenizer st = new StringTokenizer(String str, String delim); Example of String Tokenizer Let's explore how to use a string tokenizer through an example. Initial Setup String s = "learn to code"; s = s + " with kapila"; System.out.println(s); // Output: learn to code with kapila Creating a String Tokenizer StringTokenizer st = new StringTokenizer(s, " "); In this example, the delimiter is a space (" "), which means the string will be split by spaces. Printing Tokens To print each token, we can use the following methods: hasMoreTokens() : Checks if there are more tokens available. nextToken() : Retrieves the next token. Advanced 32 c o d e r s n o t e . c o m
- 101. Code: while (st.hasMoreTokens()) { System.out.println(st.nextToken()); } Output: learn to code with kapila Understanding String Tokenizer Methods hasMoreTokens() : Returns true if there are more tokens available, otherwise false . nextToken() : Returns the next token from the string. Example with Different Delimiters You can use different delimiters to split the string. For instance, if you use 'a' as the delimiter: StringTokenizer st = new StringTokenizer(s, "a"); while (st.hasMoreTokens()) { System.out.println(st.nextToken()); } Output: le rn to code with k Advanced 33 c o d e r s n o t e . c o m
- 102. p m String Tokenizer vs. String Buffer String to String Tokenizer Conversion StringTokenizer st = new StringTokenizer(s, " "); String Tokenizer to String Conversion String token = st.nextToken(); String to String Buffer Conversion StringBuffer sb = new StringBuffer(s); String Buffer to String Conversion String str = sb.toString(); Example with String Buffer StringBuffer sb = new StringBuffer(s); sb.append(" with explanations"); String str = sb.toString(); System.out.println(str); Output: learn to code with kapila with explanations Advanced 34 c o d e r s n o t e . c o m
- 103. Practicing Questions While built-in functions like toUpperCase() , reverse() , etc., simplify tasks, companies like Zoho often require writing raw code without using these functions due to time constraints. It's essential to understand the underlying logic and be able to write raw code for these operations. Practice Task Try converting the string to uppercase without using the built-in toUpperCase() function. Hint: Iterate through each character of the string, check if it's a lowercase letter, and convert it to the corresponding uppercase letter using ASCII values. String s = "learn to code with kapam"; StringBuffer sb = new StringBuffer(); for (int i = 0; i < s.length(); i++) { char c = s.charAt(i); if (c >= 'a' && c <= 'z') { sb.append((char)(c - 'a' + 'A')); } else { sb.append(c); } } System.out.println(sb.toString()); Output: LEARN TO CODE WITH KAPILA Conclusion Understanding string tokenizers and their functions is crucial for manipulating strings efficiently. Practice converting between strings, string buffers, and string Advanced 35 c o d e r s n o t e . c o m
- 104. tokenizers to strengthen your understanding. In the next session, we will solve more questions, focusing on both built-in functions and raw code implementations. Advanced 36 c o d e r s n o t e . c o m
- 105. Expert Introduction In this session, we'll cover how to handle word-based string questions in Java. Previously, we dealt with character-based manipulations where we alternated between uppercase and lowercase characters. This time, we’ll focus on reversing words in a string and alternately converting them to uppercase and lowercase. Problem Statement Given an input string, we need to reverse each word in the string and alternately convert the first word to lowercase, the second to uppercase, the third to lowercase, and so on. Example: Input: "think twice code once" Output: "kniht TWICE edoc ONCE" Steps to Solve the Problem 1. Identify the Type of String Question: Determine if the question is character-based, word-based, or number- based. In this case, it's word-based. 2. String Tokenizer: Use StringTokenizer to split the input string into individual words based on spaces. 3. String Buffer for Reversing: Use StringBuffer to reverse each word since it has a built-in reverse() method. 4. Alternate Case Conversion: Convert words to uppercase or lowercase based on their position (odd or even). Detailed Explanation and Code Expert 1 c o d e r s n o t e . c o m
- 106. 1. Input and Scanner Initialization: import java.util.Scanner; import java.util.StringTokenizer; import java.util.StringBuffer; public class Main { public static void main(String[] args) { Scanner sh = new Scanner(System.in); String s = sh.nextLine(); // Read entire line as input 2. String Tokenizer: StringTokenizer st = new StringTokenizer(s, " "); // Tokenize based on space 3. Loop Through Tokens: int count = 0; // To keep track of word position while (st.hasMoreTokens()) { String word = st.nextToken(); // Get next word StringBuffer sb = new StringBuffer(word); // Convert word to String Buffer word = sb.reverse().toString(); // Reverse the word count++; // Increment word count 4. Alternate Case Conversion and Printing: if (count % 2 != 0) { // Odd word position System.out.print(word.toLowerCase() + " "); } else { // Even word position System.out.print(word.toUpperCase() + " "); } } sh.close(); // Close the scanner Expert 2 c o d e r s n o t e . c o m
- 107. } } Concepts Covered String Handling: Scanner for input. StringTokenizer for splitting the string into words. StringBuffer for reversing words. Control Structures: while loop to iterate through tokens. if-else to determine case conversion based on word position. Additional Notes Import Statements: Ensure to import necessary classes: import java.util.StringTokenizer; import java.util.StringBuffer; import java.util.Scanner; Character Handling: We extensively used StringBuffer for its reverse() method. Conversion between String and StringBuffer is essential for utilizing various methods. Efficiency: Using StringTokenizer and StringBuffer helps in managing the string efficiently without manually parsing and reversing. Practice Problems To reinforce learning, try solving the following problems: Expert 3 c o d e r s n o t e . c o m
- 108. 1. Reverse each word in a sentence without changing the word order. 2. Convert each word to uppercase if it contains more than 3 characters, otherwise to lowercase. 3. Find and replace all vowels in each word with a specific character (e.g., '*'). By understanding and practicing these concepts, you will be well-prepared to handle various string manipulation problems in Java. Introduction This session covers the concept of number-based strings, where characters and numbers are intertwined in a single string. The goal is to extract and manipulate these components separately. Concept Explanation 1. Number-Based Strings: A string like "A10B12C3D4" contains characters followed by numbers. Each character should be printed a number of times corresponding to the number that follows it. Example: "A10" means A should be printed 10 times, "B12" means B should be printed 12 times, etc. 2. ASCII Values: Characters and numbers in a string have ASCII values. For example, ASCII value of 1 is 49 , 0 is 48 , and A is 65 . Step-by-Step Solution 1. Input Handling: Read the input string from the user. Example input: "A10B12C3D4" . 2. Segregate Characters and Numbers: Iterate through the string and separate characters from numbers. Expert 4 c o d e r s n o t e . c o m
- 109. Use conditions to check if a character is an alphabet or a digit. 3. Convert Characters to Numbers: Convert the sequence of digits into an integer using ASCII arithmetic. Formula: num = num * 10 + (int_of_char - 48) 4. Implementation: Write code to read the string, segregate characters and numbers, convert the numbers, and then print the characters the specified number of times. Detailed Code Explanation import java.util.Scanner; public class NumberBasedStrings { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); // Read input string System.out.println("Enter the string:"); String input = scanner.next(); // Convert string to character array char[] arr = input.toCharArray(); int num = 0; // To store the number part char ch = ' '; // To store the character part for (int i = 0; i < arr.length; i++) { if (arr[i] >= '0' && arr[i] <= '9') { // Check if it's a digit num = num * 10 + (arr[i] - '0'); // Convert char digit to integer } else { // It's a character // Print the previous character the specified number of times if (i > 0) { for (int j = 0; j < num; j++) { System.out.print(ch); } Expert 5 c o d e r s n o t e . c o m
- 110. } // Reset num and update the character num = 0; ch = arr[i]; } } // Print the last character the specified number of times for (int j = 0; j < num; j++) { System.out.print(ch); } } } Key Points 1. Initialization: num is initialized to 0 to hold the numeric value. ch is initialized to a space or a placeholder character. 2. Iteration: The loop iterates through each character in the input string. If the character is a digit, it updates num . If the character is an alphabet, it prints the previous character num times and updates ch to the current character. 3. Printing: After exiting the loop, it prints the last character the specified number of times. Practical Usage Example: Input: "A10B12C3D4" Expert 6 c o d e r s n o t e . c o m
- 111. Output: AAAAAAAAAABBBBBBBBBBBCCCCDDDD This approach is useful for problems involving encoded messages or data compression where a format like A10 is used to represent AAAAAAAAAA . Common Mistakes and Tips 1. Index Handling: Ensure the loop handles the last character and number correctly by printing after the loop ends. 2. Resetting Values: Reset num after printing to avoid incorrect accumulations. 3. Boundary Conditions: Handle cases where the input might not follow the expected pattern strictly. Conclusion By understanding the separation of characters and digits, converting characters to integers using ASCII arithmetic, and iterating through the string efficiently, you can handle number-based string manipulation in Java effectively. Practice this pattern to solidify your understanding and improve your coding skills. What is OOP? OOP (Object-Oriented Programming): A programming paradigm based on the concept of "objects," which are instances of classes. Objects: User-defined data types that contain both data (attributes) and methods (functions). Basic Data Types in Java Numerical Values: int , float , double Character Values: char Strings: A collection of characters, e.g., "Learn to code" Expert 7 c o d e r s n o t e . c o m
- 112. Defining Custom Data Types (Classes) Classes are templates for creating objects. For example, to define a Dog class, you consider attributes like breed, name, and age, and behaviors like barking and eating. class Dog { String breed; String name; int age; void bark() { System.out.println("Bark!"); } void eat() { System.out.println("Eating..."); } } Attributes vs. Methods Attributes (States): Describe the characteristics of an object (e.g., breed , name , age ). Methods (Behaviors): Describe the actions that an object can perform (e.g., bark() , eat() ). Example: Defining and Using a Dog Class public class Main { public static void main(String[] args) { Dog myDog = new Dog(); myDog.breed = "Husky"; myDog.name = "Max"; myDog.age = 3; Expert 8 c o d e r s n o t e . c o m
- 113. System.out.println("Breed: " + myDog.breed); System.out.println("Name: " + myDog.name); System.out.println("Age: " + myDog.age); myDog.bark(); myDog.eat(); } } In this example, myDog is an object of the Dog class. We set its attributes ( breed , name , age ) and call its methods ( bark() , eat() ). Key OOP Concepts 1. Class: Blueprint for creating objects. 2. Object: Instance of a class. 3. Method: Function defined inside a class that describes the behaviors of the objects. 4. Attribute: Variable defined inside a class that describes the characteristics of the objects. Understanding Classes and Methods A class is defined using the class keyword followed by the class name and curly braces. Methods are defined inside the class and describe the actions the objects can perform. Methods typically contain a return type, name, parentheses for parameters, and curly braces for the method body. Main Method in Java The main method is the entry point of a Java program. It must be defined as public static void main(String[] args) . Expert 9 c o d e r s n o t e . c o m
- 114. public class Demo { public static void main(String[] args) { System.out.println("Main function"); } } Naming Conventions and File Structure The name of the class should match the name of the file. The Java compiler searches for a class with the same name as the file and a main method to start execution. Public, Static, and Void Keywords Public: Indicates the method is accessible from any other class. Static: Indicates the method belongs to the class rather than any instance of the class. Void: Indicates the method does not return any value. Practical Example: Understanding Main Method Execution When you run a Java program, the compiler looks for a class with the same name as the file and a main method. If the file is named Main.java , the class should be named Main . The main method should be defined as public static void main(String[] args) . public class Main { public static void main(String[] args) { System.out.println("Main function"); } } Running the Code Save the file as Main.java . Expert 10 c o d e r s n o t e . c o m
- 115. Compile the file using javac Main.java . Run the compiled bytecode using java Main . Next Steps In the next session, we will learn how to convert attributes and behaviors of objects (like Dog ) into actual working processes in Java. We will dive deeper into understanding static and void in the context of OOP. Summary OOP in Java involves creating classes that define the attributes and behaviors of objects. Understanding the main method and file structure is crucial for running Java programs. Attributes represent the state of an object, while methods represent its behaviors. The next step will focus on applying these concepts to create more complex and functional Java programs. Session Overview In this session, we will explore two fundamental concepts in Java: Constructors and Encapsulation. These concepts are crucial for creating robust and maintainable code in Java. Constructors What is a Constructor? A constructor in Java is a special method used to initialize objects. The constructor is called when an object of a class is created. It can be used to set initial values for object attributes. Key Points About Constructors 1. No Return Type: Constructors do not have a return type, not even void. Expert 11 c o d e r s n o t e . c o m
- 116. 2. Same Name as Class: The name of the constructor must match the class name. 3. Initialization: Constructors are primarily used to initialize the object with specific values or to perform certain actions when the object is created. Example of a Simple Constructor public class Dog { String name; int age; // Constructor public Dog(String name, int age) { this.name = name; this.age = age; System.out.println("Dog object created with name: " + name + " and age: " + age); } public static void main(String[] args) { Dog dog1 = new Dog("Husky", 2); Dog dog2 = new Dog("Beagle", 1); } } How Constructors Work When Dog dog1 = new Dog("Husky", 2); is executed, the Dog constructor is called. It initializes the name and age attributes with the values provided and prints the message. Using this Keyword in Constructors The this keyword refers to the current object. It is used to differentiate between class attributes and parameters with the same name. Expert 12 c o d e r s n o t e . c o m
- 117. public Dog(String name, int age) { this.name = name; // 'this.name' refers to the class attribute, 'name' refers t o the parameter this.age = age; } Encapsulation What is Encapsulation? Encapsulation is a principle of wrapping the data (variables) and the code acting on the data (methods) together as a single unit. It restricts direct access to some of the object's components and can prevent the accidental modification of data. Key Points About Encapsulation 1. Private Variables: Variables are declared private to restrict direct access. 2. Public Getter and Setter Methods: Public methods are provided to access and update the value of private variables. Example of Encapsulation public class Login { private String username; private String password; // Getter for username public String getUsername() { return username; } // Setter for username public void setUsername(String username) { this.username = username; } Expert 13 c o d e r s n o t e . c o m
- 118. // Getter for password public String getPassword() { return password; } // Setter for password public void setPassword(String password) { this.password = password; } } public class Main { public static void main(String[] args) { Login login = new Login(); login.setUsername("user123"); login.setPassword("pass123"); System.out.println("Username: " + login.getUsername()); System.out.println("Password: " + login.getPassword()); } } How Encapsulation Works The Login class has private variables username and password . Public methods ( getUsername , setUsername , getPassword , setPassword ) are provided to access and modify these private variables. This ensures that direct access to the sensitive data (username and password) is restricted and can only be accessed through these methods. Hands-On Exercise 1. Create a Constructor for a Class Expert 14 c o d e r s n o t e . c o m
- 119. Define a class Book with attributes title and author . Create a constructor that initializes these attributes and prints a message. public class Book { String title; String author; // Constructor public Book(String title, String author) { this.title = title; this.author = author; System.out.println("Book created: " + title + " by " + author); } public static void main(String[] args) { Book book1 = new Book("1984", "George Orwell"); Book book2 = new Book("To Kill a Mockingbird", "Harper Lee"); } } 2. Implement Encapsulation Modify the Book class to encapsulate its attributes. Provide getter and setter methods for title and author . public class Book { private String title; private String author; // Constructor public Book(String title, String author) { this.title = title; this.author = author; System.out.println("Book created: " + title + " by " + author); Expert 15 c o d e r s n o t e . c o m
- 120. } // Getter for title public String getTitle() { return title; } // Setter for title public void setTitle(String title) { this.title = title; } // Getter for author public String getAuthor() { return author; } // Setter for author public void setAuthor(String author) { this.author = author; } public static void main(String[] args) { Book book1 = new Book("1984", "George Orwell"); book1.setTitle("Animal Farm"); System.out.println("Updated title: " + book1.getTitle()); Book book2 = new Book("To Kill a Mockingbird", "Harper Lee"); System.out.println("Author: " + book2.getAuthor()); } } Summary Expert 16 c o d e r s n o t e . c o m
- 121. Constructors are special methods used to initialize objects. They do not have a return type and must have the same name as the class. Encapsulation restricts direct access to an object's data and allows modification through public methods. This helps protect the integrity of the data within an object. Next Steps In the next session, we will explore Polymorphism and dive deeper into methods and their nuances. This will build on the foundation of constructors and encapsulation, enabling you to write more dynamic and flexible code. 1. Introduction to Inheritance Inheritance is a fundamental concept in object-oriented programming (OOP) that allows one class to inherit fields and methods from another class. This promotes code reusability and establishes a hierarchical relationship between classes. Key Terms: Superclass (Parent Class): The class being inherited from. Subclass (Child Class): The class that inherits from the superclass. extends Keyword: Used to establish inheritance. 2. Types of Inheritance in Java Java supports three main types of inheritance: 1. Single Inheritance 2. Multi-level Inheritance 3. Hierarchical Inheritance Java does not support: Multiple Inheritance Hybrid Inheritance Note: Multiple inheritance is supported in languages like Python but not in Java. Expert 17 c o d e r s n o t e . c o m
- 122. 3. Single Inheritance Example: class A { public void displayA() { System.out.println("Class A"); } } class B extends A { public void displayB() { System.out.println("Class B"); } } public class Main { public static void main(String[] args) { B obj = new B(); obj.displayA(); // Accessing method of superclass obj.displayB(); // Accessing method of subclass } } In single inheritance, class B inherits from class A. The object of class B can access methods of both class A and class B. 4. Multi-level Inheritance Example: class A { public void displayA() { System.out.println("Class A"); } } Expert 18 c o d e r s n o t e . c o m
- 123. class B extends A { public void displayB() { System.out.println("Class B"); } } class C extends B { public void displayC() { System.out.println("Class C"); } } public class Main { public static void main(String[] args) { C obj = new C(); obj.displayA(); // Accessing method of superclass A obj.displayB(); // Accessing method of superclass B obj.displayC(); // Accessing method of subclass C } } In multi-level inheritance, class C inherits from class B, which in turn inherits from class A. The object of class C can access methods of all three classes. 5. Hierarchical Inheritance Example: class A { public void displayA() { System.out.println("Class A"); } } class B extends A { public void displayB() { Expert 19 c o d e r s n o t e . c o m
- 124. System.out.println("Class B"); } } class C extends A { public void displayC() { System.out.println("Class C"); } } public class Main { public static void main(String[] args) { B objB = new B(); objB.displayA(); // Accessing method of superclass A objB.displayB(); // Accessing method of subclass B C objC = new C(); objC.displayA(); // Accessing method of superclass A objC.displayC(); // Accessing method of subclass C } } In hierarchical inheritance, multiple classes inherit from a single superclass. Class B and class C both inherit from class A. 6. Method Overriding Method overriding occurs when a subclass provides a specific implementation for a method that is already defined in its superclass. The method in the subclass should have the same name, return type, and parameters as the method in the superclass. Example: class A { public void display() { System.out.println("Display from Class A"); Expert 20 c o d e r s n o t e . c o m
- 125. } } class B extends A { @Override public void display() { System.out.println("Display from Class B"); } } public class Main { public static void main(String[] args) { A objA = new A(); objA.display(); // Outputs: Display from Class A B objB = new B(); objB.display(); // Outputs: Display from Class B A objAB = new B(); objAB.display(); // Outputs: Display from Class B } } In method overriding, the method in the subclass overrides the method in the superclass. 7. Polymorphism Polymorphism allows methods to perform different tasks based on the object that is calling them. Method overriding is an example of polymorphism in Java. Example: class A { public void display() { System.out.println("Display from Class A"); } Expert 21 c o d e r s n o t e . c o m
- 126. } class B extends A { @Override public void display() { System.out.println("Display from Class B"); } } public class Main { public static void main(String[] args) { A obj; // Reference of superclass obj = new A(); obj.display(); // Outputs: Display from Class A obj = new B(); obj.display(); // Outputs: Display from Class B } } Here, the same method display() behaves differently based on the object that calls it. 8. Summary and Key Points Inheritance promotes code reuse and establishes a relationship between classes. Method overriding allows a subclass to provide a specific implementation of a method already defined in its superclass. Polymorphism in Java is achieved through method overriding. Java supports single, multi-level, and hierarchical inheritance but does not support multiple and hybrid inheritance. The extends keyword is used to establish inheritance. Expert 22 c o d e r s n o t e . c o m
- 127. These notes provide a comprehensive understanding of inheritance and method overriding in Java, highlighting key concepts and providing practical examples for better understanding. 1. Introduction to Abstract Classes and Interfaces Abstract classes and interfaces in Java are crucial tools for achieving abstraction. They help in hiding the complexity of implementation from the user and only expose the necessary functionality. This is analogous to submitting an assignment done by a friend under your name; the work is done by someone else, but the credit is attributed to you. 2. What is an Abstract Class? Definition: An abstract class in Java is a class that cannot be instantiated on its own and may contain abstract methods that do not have a body. Abstract classes are meant to be subclassed, and they serve as a blueprint for other classes. Syntax: abstract class ClassName { // abstract methods abstract void methodName(); // non-abstract methods void regularMethod() { // method body } } Example: abstract class Animal { abstract void sound(); Expert 23 c o d e r s n o t e . c o m
- 128. void sleep() { System.out.println("Sleeping..."); } } class Dog extends Animal { @Override void sound() { System.out.println("Bark"); } } In the above example, Animal is an abstract class with an abstract method sound() and a non-abstract method sleep() . The Dog class extends Animal and provides an implementation for the sound() method. 3. Creating and Using Abstract Classes Step-by-Step Example: 1. Creating an Abstract Class: abstract class Proxy { abstract void bark(); abstract void eat(); abstract void sleep(); } 2. Creating a Concrete Class: class Dog extends Proxy { @Override void bark() { System.out.println("Bark"); } Expert 24 c o d e r s n o t e . c o m
- 129. @Override void eat() { System.out.println("Eat"); } @Override void sleep() { System.out.println("Sleep"); } } 3. Instantiating the Concrete Class: public class Main { public static void main(String[] args) { Proxy dog = new Dog(); dog.bark(); // Outputs: Bark dog.eat(); // Outputs: Eat dog.sleep(); // Outputs: Sleep } } In this example, Proxy is an abstract class with abstract methods bark() , eat() , and sleep() . Dog extends Proxy and provides concrete implementations for these methods. In the Main class, an object of type Proxy is instantiated as a Dog , and the methods are called. 4. What is an Interface? Definition: An interface in Java is a reference type, similar to a class, that can contain only constants, method signatures, default methods, static methods, and nested types. Interfaces cannot contain instance fields or constructors. Syntax: Expert 25 c o d e r s n o t e . c o m
- 130. interface InterfaceName { // abstract methods void methodName(); } Example: interface Animal { void sound(); } class Dog implements Animal { @Override public void sound() { System.out.println("Bark"); } } In the above example, Animal is an interface with a single method sound() . The Dog class implements Animal and provides an implementation for the sound() method. 5. Creating and Using Interfaces Step-by-Step Example: 1. Creating an Interface: interface Proxy { void bark(); void eat(); void sleep(); } 2. Creating a Concrete Class: Expert 26 c o d e r s n o t e . c o m
- 131. class Dog implements Proxy { @Override public void bark() { System.out.println("Bark"); } @Override public void eat() { System.out.println("Eat"); } @Override public void sleep() { System.out.println("Sleep"); } } 3. Instantiating the Concrete Class: public class Main { public static void main(String[] args) { Proxy dog = new Dog(); dog.bark(); // Outputs: Bark dog.eat(); // Outputs: Eat dog.sleep(); // Outputs: Sleep } } In this example, Proxy is an interface with methods bark() , eat() , and sleep() . Dog implements Proxy and provides concrete implementations for these methods. In the Main class, an object of type Proxy is instantiated as a Dog , and the methods are called. 6. Differences Between Abstract Classes and Interfaces Expert 27 c o d e r s n o t e . c o m
- 132. Abstract Class Interface Can have abstract and non- abstract methods. Can have only abstract methods (until Java 8, now can have default and static methods). Can have instance variables. Cannot have instance variables. Can have constructors. Cannot have constructors. A class can extend only one abstract class. A class can implement multiple interfaces. Uses the extends keyword. Uses the implements keyword. 7. Practical Example Using Abstract Class: abstract class Proxy { abstract void bark(); abstract void eat(); abstract void sleep(); void start() { bark(); eat(); sleep(); } } class Dog extends Proxy { @Override void bark() { System.out.println("Bark"); } @Override void eat() { System.out.println("Eat"); } Expert 28 c o d e r s n o t e . c o m
- 133. @Override void sleep() { System.out.println("Sleep"); } } public class Main { public static void main(String[] args) { Proxy dog = new Dog(); dog.start(); // Outputs: Bark Eat Sleep } } Using Interface: interface Proxy { void bark(); void eat(); void sleep(); } class Dog implements Proxy { @Override public void bark() { System.out.println("Bark"); } @Override public void eat() { System.out.println("Eat"); } @Override public void sleep() { System.out.println("Sleep"); Expert 29 c o d e r s n o t e . c o m
- 134. } } public class Main { public static void main(String[] args) { Proxy dog = new Dog(); dog.bark(); // Outputs: Bark dog.eat(); // Outputs: Eat dog.sleep(); // Outputs: Sleep } } 8. Summary and Key Points Abstract Classes: Used to define base classes with partial implementation. Can have both abstract and concrete methods. Ideal when there is a clear hierarchical relationship. Interfaces: Used to define a contract for classes to implement. Cannot have instance fields or constructors. Useful for achieving multiple inheritance. Practical Use: Abstract classes and interfaces are essential for hiding implementation details and exposing only necessary functionality. They help in reducing code duplication and increase maintainability. Introduction to Exception Handling Exception handling in Java is a crucial aspect of robust software development. It enables the program to handle runtime errors gracefully and maintain normal application flow. This session will cover the basics of exception handling, the Expert 30 c o d e r s n o t e . c o m
- 135. difference between errors and exceptions, and the mechanisms provided by Java to manage them. Errors vs. Exceptions Errors Definition: Errors are serious issues that a reasonable application should not try to catch. These are typically external to the application and represent serious problems that cannot be easily recovered. Example: Trying to instantiate an interface (e.g., MyInterface obj = new MyInterface(); ) will result in a java.lang.Error . This is a critical issue that the program cannot proceed with. Exceptions Definition: Exceptions are conditions that an application might want to catch. These are typically caused by flaws in the code or input data. Example: Dividing a number by zero (e.g., int a = 12 / 0; ) will throw a java.lang.ArithmeticException . This is an issue that can potentially be handled and recovered from. Why Exception Handling? Exception handling is necessary for: 1. Graceful Degradation: To ensure that an application can handle errors gracefully and continue running or shut down cleanly. 2. Debugging and Maintenance: To identify and fix issues quickly without crashing the entire application. 3. User Experience: To provide meaningful error messages to users instead of abrupt program termination. Mechanisms for Exception Handling Java provides several constructs for handling exceptions: 1. try-catch Block: Expert 31 c o d e r s n o t e . c o m
- 136. try: Contains code that might throw an exception. catch: Catches and handles the exception. try { int a = 12 / 0; } catch (ArithmeticException e) { System.out.println("Cannot divide by zero: " + e.getMessage()); } 2. finally Block: Always executed after try-catch, regardless of whether an exception was thrown or not. Used for cleanup activities. try { // Code that may throw an exception } catch (Exception e) { // Handling code } finally { // Cleanup code } 3. throw Statement: Used to explicitly throw an exception. if (input == null) { throw new NullPointerException("Input cannot be null"); } 4. throws Keyword: Indicates that a method can throw exceptions. It is part of the method signature. Expert 32 c o d e r s n o t e . c o m
- 137. public void myMethod() throws IOException { // Method code } Practical Example Consider a web application where users enter their email addresses. If the input doesn't include @gmail.com , we can throw a custom exception to prompt the user for a correct email format. Implementation: public class EmailValidator { public static void main(String[] args) { try { validateEmail("username"); } catch (InvalidEmailException e) { System.out.println(e.getMessage()); } } public static void validateEmail(String email) throws InvalidEmailException { if (!email.contains("@gmail.com")) { throw new InvalidEmailException("Email must contain '@gmail.com'"); } } } class InvalidEmailException extends Exception { public InvalidEmailException(String message) { super(message); } } Expert 33 c o d e r s n o t e . c o m
- 138. Conclusion Exception handling is a vital part of Java programming that helps in maintaining the stability and reliability of applications. By understanding and utilizing the try , catch , finally , throw , and throws constructs, developers can ensure their applications handle errors gracefully and provide a better user experience. Further sessions will delve deeper into each of these constructs with more detailed examples and best practices. Overview Exception handling is a mechanism to handle runtime errors so that the normal flow of the application can be maintained. Java provides a robust and flexible framework to handle exceptions and errors gracefully. Errors vs. Exceptions Errors Definition: Serious issues that a reasonable application should not try to catch. They typically indicate problems with the environment. Examples: StackOverflowError : When a stack overflows due to excessive recursive method calls. OutOfMemoryError : When the JVM runs out of memory. Exceptions Definition: Conditions that a reasonable application might want to catch. Examples: ArithmeticException : Dividing by zero. NullPointerException : Accessing a method or property of a null object. Basic Syntax for Exception Handling Expert 34 c o d e r s n o t e . c o m
- 139. Java provides the try , catch , finally , throw , and throws keywords to handle exceptions. try-catch Block try { // Code that might throw an exception } catch (ExceptionType e) { // Code to handle the exception } finally Block The finally block is always executed after the try and catch blocks, regardless of whether an exception was thrown or not. try { // Code that might throw an exception } catch (ExceptionType e) { // Code to handle the exception } finally { // Code to execute regardless of whether an exception was thrown or not } throw Statement Used to explicitly throw an exception. throw new ExceptionType("Error message"); throws Keyword Used in method signatures to indicate that the method might throw certain exceptions. Expert 35 c o d e r s n o t e . c o m
- 140. public void myMethod() throws ExceptionType { // Method code } Detailed Examples ArrayIndexOutOfBoundsException This exception occurs when trying to access an array index that is out of bounds. public class Main { public static void main(String[] args) { int[] array = new int[5]; try { array[5] = 10; // This will throw ArrayIndexOutOfBoundsException } catch (ArrayIndexOutOfBoundsException e) { System.out.println("Exception: " + e); } } } ArithmeticException This exception occurs when an illegal arithmetic operation is performed, such as dividing by zero. public class Main { public static void main(String[] args) { try { int result = 10 / 0; // This will throw ArithmeticException } catch (ArithmeticException e) { System.out.println("Exception: " + e); } Expert 36 c o d e r s n o t e . c o m
- 141. } } Practical Scenarios Handling Multiple Exceptions Multiple exceptions can be handled using multiple catch blocks. public class Main { public static void main(String[] args) { try { int result = 10 / 0; int[] array = new int[5]; array[5] = 10; } catch (ArithmeticException e) { System.out.println("ArithmeticException: " + e); } catch (ArrayIndexOutOfBoundsException e) { System.out.println("ArrayIndexOutOfBoundsException: " + e); } catch (Exception e) { System.out.println("General Exception: " + e); } } } Using finally The finally block can be used to execute code that must run regardless of whether an exception was thrown. public class Main { public static void main(String[] args) { try { int result = 10 / 0; } catch (ArithmeticException e) { System.out.println("Exception: " + e); Expert 37 c o d e r s n o t e . c o m
- 142. } finally { System.out.println("This will always be executed"); } } } Custom Exceptions Custom exceptions can be created by extending the Exception class. class AgeException extends Exception { public AgeException(String message) { super(message); } } public class Main { public static void validateAge(int age) throws AgeException { if (age < 18) { throw new AgeException("Age must be above 18"); } } public static void main(String[] args) { try { validateAge(15); } catch (AgeException e) { System.out.println("Exception: " + e); } } } Types of Exceptions Checked Exceptions Expert 38 c o d e r s n o t e . c o m
- 143. These are exceptions that are checked at compile time. Examples: IOException , SQLException Handling Checked Exceptions: public void readFile() throws IOException { FileReader file = new FileReader("file.txt"); BufferedReader fileInput = new BufferedReader(file); fileInput.close(); } Unchecked Exceptions These are exceptions that are not checked at compile time. Examples: ArithmeticException , NullPointerException Handling Unchecked Exceptions: public class Main { public static void main(String[] args) { try { int result = 10 / 0; } catch (ArithmeticException e) { System.out.println("Exception: " + e); } } } Best Practices 1. Always Catch Specific Exceptions: Catch the most specific exception first. 2. Use finally for Cleanup: Use the finally block for resource cleanup (e.g., closing file streams). 3. Don't Use Exceptions for Control Flow: Avoid using exceptions for regular control flow. Expert 39 c o d e r s n o t e . c o m
- 144. 4. Document Exceptions: Use the throws keyword to document the exceptions a method might throw. Summary Exception handling in Java allows for a more resilient and fault-tolerant application. By understanding and utilizing try , catch , finally , throw , and throws , developers can manage and respond to runtime anomalies effectively. Expert 40 c o d e r s n o t e . c o m