Introduction: Genesis and Evolution of Java Language

 Genesis:
o Developed by Sun Microsystems in the early 1990s, primarily by James Gosling.
o Initially called Oak, later renamed Java.
o Designed to be simple, object-oriented, and platform-independent.
 Evolution:
o Java 1.0 (1995): WORA (Write Once, Run Anywhere) capability introduced.
o Java 2 (1998): Introduced Swing, collections framework, and JIT compiler.
o Continued evolution through versions, with the current versions supporting
features like lambdas, streams, modules, etc.

Internet & Java

 Java was designed with networking in mind, making it ideal for the web.
 Features like applet support, servlets, and JSP (Java Server Pages) emphasize Java’s
integration with the Internet.
 Popular for building dynamic web applications due to its robust libraries and frameworks.

Bytecode and its Features

 Bytecode: Intermediate code generated by the Java Compiler.

o Stored in .class files.
o Platform-independent and executed by the Java Virtual Machine (JVM).
 Features:
o Ensures portability.
o Facilitates security as it runs in a sandbox environment.
o Enables optimization through Just-In-Time (JIT) compilation.

Java Program Structure and Class Library

 Structure:
java
Copy code
public class ClassName {
public static void main(String[] args) {
// Program logic here
}
}

 Java Class Library:

o Rich set of pre-written classes and methods.
o Includes packages like java.lang, java.util, java.io, etc.
Data Types, Variables, and Operators

 Data Types:
o Primitive Types: int, float, double, char, boolean, etc.
o Reference Types: Arrays, Classes, Interfaces.
 Variables:
o Must be declared before use.
o Example: int num = 10;
 Operators:
o Arithmetic: +, -, *, /, %
o Relational: >, <, >=, <=, ==, !=
o Logical: &&, ||, !

Operator Precedence

 Determines the order of execution in complex expressions.

 Example: * and / have higher precedence than + and -.

Control Statements

 Selection Statements:
o if, if-else, switch.
 Scope of Variables:
o Local Scope: Declared inside methods or blocks.
o Class Scope: Declared at the class level (instance/static variables).
 Iterative Statements:
o for, while, do-while.

Defining Classes and Methods

 Defining a Class:
class MyClass {
int num;
void display() {
System.out.println("Number: " + num);
}
}
MyClass obj = new MyClass();
obj.num = 10;
obj.display();

 Garbage Collection:
 o Automatic memory management in Java.
o JVM's Garbage Collector removes unreferenced objects.

Arrays and Strings

Arrays

 Collection of elements of the same data type.

o Example:
java
Copy code
int[] numbers = {1, 2, 3, 4};

Arrays of Characters:
char[] chars = {'J', 'a', 'v', 'a'};

String Handling

 String Class: Immutable sequences of characters.

o Example:
java
Copy code
String str = "Hello, Java!";

 Common String Methods:

o length(), substring(), concat(), replace(), toUpperCase(), etc.

. Arrays

 Definition:
Arrays are collections of data items of the same type stored in contiguous memory
locations.
 Declaration and Initialization:
Single-Dimensional Arrays
int[] numbers = {10, 20, 30, 40};
Multi-Dimensional Arrays
int[][] matrix = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};

Key Operations:

 Accessing Elements
System.out.println(numbers[0]); // Output: 10
Traversing
for (int num : numbers) {
System.out.println(num);
}

. Arrays of Characters

 An array of characters can represent a sequence of characters or a string-like structure.

 Example:
char[] chars = {'J', 'a', 'v', 'a'};
System.out.println(chars); // Output: Java
Conversion to String
String str = new String(chars);
System.out.println(str); // Output: Java

3. String Handling Using the String Class

 Definition:
The String class in Java is used to create immutable (unchangeable) sequences of
characters.

 Declaration and Initialization:

String str1 = "Hello";
String str2 = new String("World");

Common Operations:

 Concatenation:
String result = str1 + " " + str2;
System.out.println(result); // Output: Hello World
OR
String result = str1.concat(" ").concat(str2);
Length:
System.out.println(str1.length()); // Output: 5
Character Access:
System.out.println(str1.charAt(0)); // Output: H

Substring:
java
Copy code
String sub = str1.substring(1, 4);
System.out.println(sub); // Output: ell
Replace:
String replaced = str1.replace('l', 'p');
System.out.println(replaced); // Output: Heppo
Case Conversion:
System.out.println(str1.toUpperCase()); // Output: HELLO
System.out.println(str1.toLowerCase()); // Output: hello
Trim:
String str = " Java ";
System.out.println(str.trim()); // Output: Java
Comparison:
System.out.println(str1.equals(str2)); // Output: false

4. StringBuffer Class

 Definition:
The StringBuffer class is used to create mutable (modifiable) sequences of characters.
It is preferred when multiple modifications to a string are needed.

 Declaration and Initialization:

java
Copy code
StringBuffer sb = new StringBuffer("Hello");

Key Operations:

 Append:
sb.append(" World");
System.out.println(sb); // Output: Hello World
Insert:
sb.insert(6, "Java ");
System.out.println(sb); // Output: Hello Java World
Replace:
sb.replace(6, 10, "C++");
System.out.println(sb); // Output: Hello C++ World
Delete:
sb.delete(6, 9);
System.out.println(sb); // Output: Hello World
Reverse:
sb.reverse();
System.out.println(sb); // Output: dlroW olleH
Capacity:
System.out.println(sb.capacity()); // Default is 16 + length of the string
Set Length:
sb.setLength(5);
System.out.println(sb); // Output: Hello

Comparison: String vs StringBuffer

Feature String StringBuffer
Mutability Immutable Mutable
Performance Slower for modifications Faster for modifications
Thread-Safety Not thread-safe Thread-safe