DecodeJava

📋 Table of Contents

🔍 Overview

✨ Features

📁 Project Structure

DecodeJava/
├── src/
│ ├── Main.java # Entry point
│ ├── compare/ # Comparison demonstrations
│ │ ├── comparable/ # Comparable interface examples
│ │ │ ├── ComparableDemo.java
│ │ │ └── Employee.java
│ │ └── comparator/ # Comparator interface examples
│ │ ├── ComparatorDemo.java
│ │ ├── Employee.java
│ │ ├── IdComparator.java
│ │ └── SalaryComparator.java
│ ├── exceptionHandling/ # Exception handling examples
│ │ ├── TryCatch.java # Basic try-catch blocks
│ │ ├── TryCatchFinally.java # Finally block usage
│ │ ├── TryWithResource.java # Try-with-resources
│ │ ├── MultipleCatch.java # Multiple exception handling
│ │ ├── ThrowAndThrows.java # Throw and throws keywords
│ │ ├── CustomException.java # Creating custom exceptions
│ │ ├── MyCustomException.java # Custom exception class
│ │ └── hierarchy.md # Exception hierarchy diagram
│ ├── lambda/ # Lambda expression demonstrations
│ │ ├── FuncInter.java
│ │ ├── FuncInterImp.java
│ │ ├── LambdaDemo.java
│ │ ├── SumInter.java
│ │ ├── ThreadCreationLambdaDemo.java
│ │ └── functionalInterfaces/ # Built-in functional interfaces
│ │ ├── ConsumerInterface.java # Consumer examples
│ │ ├── FunctionInterface.java # Function examples
│ │ ├── PredicateInterface.java # Predicate examples
│ │ └── SupplierInterface.java # Supplier examples
│ ├── multithreading/ # Multithreading demonstrations
│ │ ├── MyThreadByClass.java # Thread creation by extending Thread
│ │ ├── MyThreadByInterface.java # Thread creation using Runnable
│ │ ├── MyThreadDemo.java # Thread usage examples
│ │ ├── ThreadByLambda.java # Creating threads with lambda
│ │ ├── LifeCycleOfThread.java # Thread lifecycle states
│ │ ├── ThreadPriorityMethod.java # Thread priority management
│ │ ├── JoinBetweenThreads.java # Thread joining
│ │ ├── DaemonThread.java # Daemon thread examples
│ │ ├── ThreadCommunication.java # Inter-thread communication
│ │ ├── VolatileDemo.java # Volatile keyword usage
│ │ ├── AtomicDemo.java # Atomic variables
│ │ ├── executors/ # Executor framework
│ │ │ ├── ThreadPoolDemo.java # Thread pool basics
│ │ │ ├── FixedCachedThreadPool.java # Fixed and cached pools
│ │ │ ├── RunnableNCallable.java # Runnable vs Callable
│ │ │ ├── FutureDemo.java # Future interface
│ │ │ ├── CallableWithInvokeAll.java # InvokeAll method
│ │ │ ├── ScheduledExecutorServiceDemo.java
│ │ │ └── ScheduledExecutorServiceDemoFixed.java
│ │ ├── locks/ # Locking mechanisms
│ │ │ ├── LockDemo.java # Basic lock usage
│ │ │ ├── ReentrantLockDemo.java # ReentrantLock examples
│ │ │ ├── ReadWriteCounter.java # ReadWriteLock
│ │ │ └── BankAccount.java # Thread-safe bank account
│ │ └── producerConsumer/ # Producer-Consumer pattern
│ │ ├── Demo.java # Main demo
│ │ ├── Company.java # Shared resource
│ │ ├── Producer.java # Producer thread
│ │ └── Consumer.java # Consumer thread
│ ├── optional/ # Optional class usage
│ │ └── OptionalDemo.java
│ ├── ref/ # Method references
│ │ ├── RefDemo.java
│ │ ├── Task.java
│ │ ├── TaskInter.java
│ │ └── constructor/ # Constructor references
│ │ ├── ConsMain.java
│ │ ├── OptionalClass.java
│ │ ├── Streams.java
│ │ ├── Student.java
│ │ └── StudentInter.java
│ └── streams/ # Stream API examples
│ ├── StreamMethods.java
│ └── StreamsDemo.java
└── README.md

🚀 Getting Started

Prerequisites

How to Run

📚 Topics Covered

1. Lambda Expressions (lambda/)

2. Functional Interfaces (lambda/functionalInterfaces/)

3. Stream API (streams/)

4. Optional Class (optional/)

5. Method References (ref/)

6. Comparisons (compare/)

7. Exception Handling (exceptionHandling/)

8. Multithreading (multithreading/)

Basic Threading

Thread Communication & Synchronization

Executor Framework (multithreading/executors/)

Locks (multithreading/locks/)

💡 Examples

Lambda Expression Example

// Traditional approach
FuncInter funcInter = new FuncInterImp();
funcInter.sayHello();
// Lambda expression
FuncInter funcInter2 = () -> System.out.println("Hello from Lambda Expression");
funcInter2.sayHello();

Stream API Example

List<Integer> numbers = List.of(1,2,3,4,5,6,7,8,9,10);
List<Integer> evenNumbers = numbers.stream()
 .filter(num -> num % 2 == 0)
 .collect(Collectors.toList());

Predicate Example

Predicate<Integer> isEven = num -> num % 2 == 0;
Predicate<Integer> isPositive = n -> n > 0;
System.out.println(isEven.and(isPositive).test(2)); // true

Exception Handling Example

// Try-with-resources
try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
 String line = br.readLine();
} catch (IOException e) {
 e.printStackTrace();
}
// Custom exception
throw new MyCustomException("Custom error message");

Multithreading Example

// Creating thread with lambda
Thread t = new Thread(() -> {
 System.out.println("Thread running: " + Thread.currentThread().getName());
});
t.start();
// Using ExecutorService
ExecutorService executor = Executors.newFixedThreadPool(5);
executor.submit(() -> System.out.println("Task executed"));
executor.shutdown();
// Using ReentrantLock
ReentrantLock lock = new ReentrantLock();
lock.lock();
try {
 // Critical section
} finally {
 lock.unlock();
}

🤝 Contributing

📄 License

📞 Contact