java-programs/java-programs/

├── src/main/java/                    # Standard Maven source structure├── fundamentals/              # Core Java concepts

│   ├── fundamentals/                 # Core Java concepts│   ├── variables-datatypes/   # Variables, data types, and type conversion

│   │   ├── arrays/                   # Array operations and algorithms│   ├── operators/            # Arithmetic, comparison, logical operators

│   │   ├── control-structures/       # Conditionals, loops, modern switch expressions│   ├── control-structures/   # Conditionals, loops, and control flow

│   │   ├── methods/                  # Method declarations, overloading, recursion│   ├── methods/             # Method declarations, overloading, parameters

│   │   └── variables-datatypes/      # Variables, data types, type conversion│   └── arrays/              # Array manipulation and multidimensional arrays

│   ├── object-oriented/              # Object-Oriented Programming├── object-oriented/          # Object-Oriented Programming

│   │   ├── classes-objects/          # Classes, objects, constructors, composition│   ├── classes-objects/     # Classes, objects, constructors

│   │   ├── inheritance/              # Inheritance, polymorphism, abstract classes│   ├── inheritance/         # Inheritance and super keyword

│   │   ├── encapsulation/            # Access modifiers and data hiding│   ├── polymorphism/        # Method overriding and runtime polymorphism

│   │   └── polymorphism/             # Method overriding and runtime polymorphism│   └── encapsulation/       # Access modifiers and data hiding

│   ├── intermediate/                 # Intermediate Java topics├── intermediate/             # Intermediate Java topics

│   │   ├── collections/              # Collections Framework (List, Set, Map)│   ├── collections/         # ArrayList, HashMap, Set, Queue

│   │   ├── ExceptionHandlingDemo.java # Exception handling and custom exceptions│   ├── exception-handling/  # Try-catch, custom exceptions

│   │   ├── FileIODemo.java           # File I/O, NIO.2, serialization│   ├── file-io/            # File reading/writing, serialization

│   │   └── MultithreadingDemo.java   # Threads, synchronization, concurrency│   └── multithreading/     # Threads, synchronization, concurrency

│   ├── advanced/                     # Advanced Java features├── advanced/                # Advanced Java features

│   │   ├── generics/                 # Generic classes and methods│   ├── generics/           # Generic classes and methods

│   │   ├── lambda-expressions/       # Functional programming│   ├── lambda-expressions/ # Lambda expressions and functional interfaces

│   │   ├── streams/                  # Stream API and pipelines│   ├── streams/            # Stream API and functional programming

│   │   └── design-patterns/          # Common design patterns│   └── design-patterns/    # Common design patterns in Java

│   ├── projects/                     # Practical Java projects├── projects/               # Practical Java projects

│   │   ├── calculator/               # Scientific calculator application│   ├── calculator/         # Console-based calculator

│   │   ├── student-management/       # Student record management system│   ├── student-management/ # Student record management system

│   │   ├── banking-system/           # Banking application with transactions│   ├── banking-system/     # Simple banking application

│   │   └── inventory-system/         # Inventory management system│   └── inventory-system/   # Inventory management application

│   └── environment-setup/            # Development environment validation├── environment-setup/      # Development environment configuration

│       ├── EnvironmentValidator.java # Comprehensive environment checker│   ├── jdk-setup/         # JDK installation and configuration

│       ├── CompilationTest.java      # Simple compilation verification│   ├── ide-configuration/ # IDE setup guides (Eclipse, IntelliJ, VS Code)

│       └── Java21-Setup-Guide.md    # Installation and setup instructions│   └── build-tools/       # Maven, Gradle configuration

├── pom.xml                          # Maven configuration for Java 21└── README.md              # This file

├── .gitignore                       # Git ignore patterns```

└── README.md                        # This file

```## 🛠️ Environment Requirements



## 🛠️ Environment Requirements### Java Development Kit (JDK)

- **JDK**: Java 21 LTS (Latest Long Term Support release)

### Java Development Kit (JDK)- **IDE**: IntelliJ IDEA, Eclipse, VS Code with Java extensions

- **JDK 21 LTS**: Latest Long Term Support release (Oracle or OpenJDK)- **Build Tools**: Maven 3.9+ or Gradle 8.0+ (configured for Java 21)

- **Maven 3.9+**: Build automation and dependency management

- **IDE**: IntelliJ IDEA, Eclipse, or VS Code with Java Extension Pack### System Requirements

- **Operating System**: Windows 10+, macOS 10.14+, or Linux

### System Requirements- **Memory**: 4GB RAM minimum (8GB recommended)

- **Operating System**: Windows 10+, macOS 10.14+, or Linux- **Storage**: 2GB free space for JDK and IDE

- **Memory**: 4GB RAM minimum (8GB recommended for development)

- **Storage**: 2GB free space for JDK, IDE, and dependencies## 🎯 Learning Path



## 🎯 Learning Path### 1. Fundamentals (Start Here)

- Variables and Data Types

### 1. **Environment Setup** (Start Here)- Operators and Expressions

```bash- Control Structures

# Validate your Java environment- Methods and Parameters

java -cp src/main/java EnvironmentValidator- Arrays and Array Manipulation



# Run simple compilation test### 2. Object-Oriented Programming

java -cp src/main/java CompilationTest- Classes and Objects

```- Inheritance and Super

- Polymorphism and Overriding

### 2. **Fundamentals** → **Object-Oriented** → **Intermediate** → **Advanced** → **Projects**- Encapsulation and Access Modifiers



Each level builds upon previous concepts with practical examples and real-world applications.### 3. Intermediate Concepts

- Collections Framework

## 🚀 Getting Started- Exception Handling

- File Input/Output

### Quick Start- Multithreading Basics

```bash

# Clone the repository### 4. Advanced Topics

git clone https://github.com/bishalgoutam/java-programs.git- Generics and Type Safety

cd java-programs- Lambda Expressions

- Stream API

# Verify Java 21 installation- Design Patterns

java --version  # Should show 21.x.x

### 5. Practical Projects

# Build with Maven- Build real-world applications

mvn clean compile- Apply learned concepts

- Portfolio development

# Run environment validation

java -cp target/classes EnvironmentValidator## 📝 Code Examples



# Run a simple demoEach directory contains:

java -cp target/classes CompilationTest- **Source Code**: Well-commented Java files (.java)

```- **README.md**: Concept explanations and usage instructions

- **Examples**: Practical demonstrations

### Running Individual Examples- **Exercises**: Practice problems and solutions

```bash

# Navigate to specific examples## 🚀 Getting Started

cd src/main/java/fundamentals/arrays

1. **Clone the repository:**

# Compile and run   ```bash

javac ArraysDemo.java   git clone https://github.com/bishalgoutam/java-programs.git

java ArraysDemo   cd java-programs

   ```

# Or use Maven from project root

mvn compile exec:java -Dexec.mainClass="ArraysDemo"2. **Verify Java 21 installation:**

```   ```bash

   # Check Java version (should show 21.x.x)

## 📚 Key Java Concepts Covered   java --version

   javac --version

### ✅ **Core Language Features (Java 21 LTS)**   

- Variables, data types, and operators   # Run environment validation

- Control structures with modern switch expressions   cd environment-setup

- Methods, overloading, and recursion   java -cp ../target/classes com.bishalgoutam.environment.Java21EnvironmentValidator

- Arrays and multidimensional arrays   ```

- Pattern matching and record patterns

3. **Compile and run examples:**

### ✅ **Object-Oriented Programming**   ```bash

- Classes, objects, and constructors   # Build with Maven (recommended)

- Inheritance and method overriding   mvn clean compile

- Polymorphism and abstract classes   

- Encapsulation and access modifiers   # Run Java 21 features demo

- Interfaces and composition patterns   java -cp target/classes com.bishalgoutam.features.PatternMatchingExamples

   

### ✅ **Intermediate Concepts**   # Or navigate to specific examples

- Collections Framework (comprehensive examples)   cd fundamentals/variables-datatypes

- Exception handling with custom exceptions   

- File I/O operations and NIO.2 API   # Compile Java program

- Multithreading and concurrent programming   javac VariablesDemo.java

- Serialization and data persistence   

   # Run the program

### ✅ **Advanced Features**   java VariablesDemo

- Generics and type safety   ```

- Lambda expressions and functional interfaces

- Stream API and parallel processing4. **Using an IDE:**

- Design patterns implementation   - Import the project into your preferred IDE

- Modern Java features (Text blocks, Records, Sealed classes)   - Set up the project structure

   - Run programs directly from the IDE

### ✅ **Real-World Projects**

- Scientific calculator with full functionality## 📚 Key Java Concepts Covered

- Student management system with CRUD operations

- Banking system with transaction handling### Core Language Features

- Inventory management with data persistence- ✅ Variables and Data Types (primitives, objects)

- ✅ Operators and Expressions

## 🧪 Testing Your Environment- ✅ Control Flow and Loops

- ✅ Methods and Method Overloading

Run the comprehensive environment validator:- ✅ Arrays and Multidimensional Arrays

```bash- ✅ Strings and String Manipulation

java -cp src/main/java EnvironmentValidator

```### Object-Oriented Programming

- ✅ Classes and Objects

**Expected Results:**- ✅ Constructors and this keyword

- ✅ Java 21+ LTS detected- ✅ Inheritance and super keyword

- ✅ Memory and file system validation- ✅ Method Overriding and Polymorphism

- ✅ Modern Java features available- ✅ Abstract Classes and Interfaces

- ✅ Compilation capabilities confirmed- ✅ Encapsulation and Access Modifiers

- ✅ All development tools ready

### Advanced Features

## 🔧 Modern Java Features Demonstrated- ✅ Collections Framework (List, Set, Map)

- ✅ Exception Handling and Custom Exceptions

### **Java 21 LTS Features**- ✅ File I/O and Serialization

- **Switch Expressions**: Enhanced pattern matching- ✅ Multithreading and Synchronization

- **Text Blocks**: Multi-line string literals- ✅ Generics and Type Safety

- **Records**: Immutable data carriers- ✅ Lambda Expressions and Functional Interfaces

- **Pattern Matching**: instanceof improvements- ✅ Stream API and Functional Programming

- **Virtual Threads**: Lightweight concurrency (Project Loom)

- **Sealed Classes**: Restricted class hierarchies### Modern Java Features

- ✅ Pattern Matching for switch (Java 21)

### **Code Examples**- ✅ Record Patterns (Java 21)

```java- ✅ Text Blocks (Java 15+)

// Switch expressions- ✅ Records (Java 16+)

String result = switch (day) {- ✅ Sealed Classes (Java 17+)

    case MONDAY, FRIDAY -> "Start/End of work week";- ✅ Virtual Threads (Java 21)

    case SATURDAY, SUNDAY -> "Weekend";- ✅ String Templates (Java 21 Preview)

    default -> "Regular day";

};## 🔧 Development Tools



// Records### Recommended IDEs

public record Student(String name, int id, double gpa) {}- **IntelliJ IDEA**: Professional Java development

- **Eclipse**: Open-source Java IDE

// Text blocks- **VS Code**: Lightweight with Java extension pack

String json = """- **NetBeans**: Apache NetBeans IDE

    {

        "name": "Java",### Build Tools

        "version": "21",- **Maven**: Project object model and build automation (Java 21 configured)

        "features": ["Switch", "Records", "Virtual Threads"]- **Gradle**: Flexible build tool with Groovy/Kotlin DSL

    }- **Ant**: XML-based build tool (legacy projects)

    """;

```### Useful Tools

- **JUnit**: Unit testing framework

## 📁 Maven Project Structure- **Mockito**: Mocking framework for testing

- **Checkstyle**: Code style checking

This repository follows the standard Maven directory layout:- **SpotBugs**: Static analysis for bug detection

- `src/main/java/`: All Java source code

- `target/classes/`: Compiled bytecode (auto-generated)## 📁 Project Structure Guidelines

- `pom.xml`: Maven configuration with Java 21 settings

- Dependencies: JUnit 5, AssertJ, Mockito for testingEach Java program follows a consistent structure:

```

## 🤝 Contributingprogram-name/

├── src/

Contributions welcome! Please:│   └── main/

- Follow existing code style and documentation patterns│       └── java/

- Add comprehensive examples with comments│           └── ProgramName.java    # Main Java file

- Include practical use cases and real-world scenarios├── README.md                       # Program documentation

- Test with Java 21 LTS before submitting├── sample-output.txt              # Expected output

- Update documentation as needed└── pom.xml                        # Maven configuration (if applicable)

```

## 📞 Contact

## 🤝 Contributing

**Bishal Goutam**

- GitHub: [@bishalgoutam](https://github.com/bishalgoutam)Feel free to contribute by:

- Repository: [java-programs](https://github.com/bishalgoutam/java-programs)- Adding new examples and programs

- Improving documentation

## 📄 License- Fixing bugs and issues

- Suggesting enhancements

This project is open source and available under the [MIT License](LICENSE).- Adding more advanced topics



---## 📞 Contact



*Built with Java 21 LTS • Educational Programming Repository • Happy Coding! ☕***Bishal Goutam**
- GitHub: [@bishalgoutam](https://github.com/bishalgoutam)
- LinkedIn: [Bishal Goutam](https://www.linkedin.com/in/bishal-goutam-9139451a/)

## 📄 License

This project is open source and available under the [MIT License](LICENSE).

---

*Happy coding with Java! ☕*