diff --git a/java8/PROBLEMS.md b/java8/PROBLEMS.md index 30935c8..36600ef 100644 --- a/java8/PROBLEMS.md +++ b/java8/PROBLEMS.md @@ -1,36 +1,113 @@ # Java 8 Problems & Concepts -## Completed Problems +## 📂 Module Structure -### ✅ Q001: Print All Numbers -**Location:** `java8/Q001_print_numbers/` +``` +java8/ +├── pom.xml # Module build configuration +├── README.md # Module overview and quick start +├── PROBLEMS.md # This file - problem statements and status +├── LEARNING_STRUCTURE.md # Complete learning guide +├── PROBLEM_TEMPLATE.md # Template for adding new problems +├── Troubleshoot.md # Common errors and solutions +├── src/ +│ └── main/ +│ └── java/ +│ └── com/modernjava/guide/ +│ ├── Main.java # Module entry point +│ └── java8/ +│ ├── Q001_print_numbers/ +│ │ ├── PrintNumbersComparison.java # ✅ Complete +│ │ ├── PrintNumbersStream.java # ✅ Complete +│ │ └── PrintNumbersTraditional.java # ✅ Complete +│ ├── Q002_print_evens/ +│ │ ├── PrintEvensComparison.java # ✅ Complete +│ │ ├── PrintEvensStream.java # ✅ Complete +│ │ └── PrintEvensTraditional.java # ✅ Complete +│ ├── Q003_square_nums/ +│ │ ├── SumOfSquareOfNumberComparison.java # ✅ Complete +│ │ ├── SumOfSquareOfNumberStream.java # ✅ Complete +│ │ └── SumOfSquareOfNumberTraditional.java # ✅ Complete +│ ├── Q004_max_min/ +│ │ ├── MaxMinNumberComparison.java # ✅ Complete +│ │ ├── MaxMinNumberStream.java # ✅ Complete +│ │ ├── MaxMinNumberTraditional.java # ✅ Complete +│ │ └── Pair.java # ✅ Helper class +│ └── util/ +│ └── ComparisonUtils.java # ✅ Shared utilities +└── target/ # Compiled output (not tracked in git) +``` + +--- + +## ✅ Completed Problems + +### Q001: Print All Numbers +**Location:** `com.modernjava.guide.java8.Q001_print_numbers` **Concepts:** Stream basics, forEach(), method references, lambda expressions -**Problem:** Print all numbers in a list +**Problem:** Print all numbers in an array **Input:** `[1, 2, 1, 3, 2, 4, 5, 6, 2, 2, 7, 8, 4, 9, 10]` **Traditional:** for-each loop -**Stream:** `numbers.stream().forEach(System.out::println)` +**Stream:** `Arrays.stream(numbers).forEach(System.out::println)` +**Comparison:** ✅ `PrintNumbersComparison.java` --- -## Partially Completed - -### ⚠ïļ Q002: Print Even numbers -**Location:** `java8/Q002_print_evens/` -**Concepts:** filter(), forEach(), method references, lambda expressions -**Problem:** Print all even numbers present within a list -**Input:** `[1, 2, 3, 4, 5]` → **Output:** `2,4` -**Traditional:** ✅ `PrintEvensTraditional.java` -**Stream:** ✅ `PrintEvensStream.java` +### Q002: Print Even Numbers +**Location:** `com.modernjava.guide.java8.Q002_print_evens` +**Concepts:** filter(), forEach(), predicates, lambda expressions +**Problem:** Print all even numbers present within an array +**Input:** `[1, 2, 3, 4, 5]` → **Output:** `2, 4` +**Traditional:** ✅ `PrintEvensTraditional.java` - for loop with modulo check +**Stream:** ✅ `PrintEvensStream.java` - `filter(n -> n % 2 == 0)` **Comparison:** ✅ `PrintEvensComparison.java` --- -## Core Concepts Covered +### Q003: Sum of Square of Numbers +**Location:** `com.modernjava.guide.java8.Q003_square_nums` +**Concepts:** map(), reduce(), sum(), transformations +**Problem:** Calculate sum of squares of all numbers in an array +**Input:** `[1, 2, 3, 4, 5]` → **Output:** `55` (1Âē + 2Âē + 3Âē + 4Âē + 5Âē) +**Traditional:** ✅ `SumOfSquareOfNumberTraditional.java` - for loop with accumulator +**Stream:** ✅ `SumOfSquareOfNumberStream.java` - `map(n -> n * n).sum()` +**Comparison:** ✅ `SumOfSquareOfNumberComparison.java` - includes performance benchmarks + +--- + +### Q004: Find Max and Min Numbers +**Location:** `com.modernjava.guide.java8.Q004_max_min` +**Concepts:** max(), min(), Comparator, Optional handling +**Problem:** Find both maximum and minimum values in an array +**Input:** `[45, 22, 89, 11, 67, 34, 90, 5, -121, 342, 0, 9999, -5000]` +**Output:** `Max = 9999, Min = -5000` +**Traditional:** ✅ `MaxMinNumberTraditional.java` - single pass with variables +**Stream:** ✅ `MaxMinNumberStream.java` - `max()` and `min()` terminal operations +**Comparison:** ✅ `MaxMinNumberComparison.java` - multiple test cases with varying sizes +**Helper:** ✅ `Pair.java` - simple class to hold max/min result + +--- + +## 🛠ïļ Utility Classes + +### ComparisonUtils +**Location:** `com.modernjava.guide.java8.util.ComparisonUtils` +**Purpose:** Shared helper methods for all comparison classes + +**Methods:** +- `repeat(String str, int count)` - Repeats string N times (Java 8 compatible alternative to String.repeat()) +- `formatTime(long nanos)` - Formats nanoseconds to human-readable format (ns, Ξs, ms) +- `printNumbers(int[] numbers)` - Prints array elements comma-separated +- `getArrayOfSpecifiedSize(int size)` - Generates random int array with positive, negative, and zero values (range: -100 to +100) + +--- + +## ðŸŽŊ Core Concepts Covered ### Stream Operations -- **Terminal Operations:** `forEach()`, `count()`, `sum()` +- **Terminal Operations:** `forEach()`, `count()`, `sum()`, `max()`, `min()` - **Intermediate Operations:** `filter()`, `map()` -- **Method References:** `System.out::println`, `Integer::intValue` +- **Method References:** `System.out::println`, `Integer::compare` - **Lambda Expressions:** `n -> n % 2 == 0`, `n -> n * n` ### Comparison Topics @@ -38,10 +115,28 @@ - Performance analysis with JIT warmup - Code readability and maintainability - When to use each approach +- Handling edge cases (empty arrays, single elements) + +### Java 8 Features Demonstrated +- ✅ Lambda expressions +- ✅ Method references +- ✅ Stream API basics +- ✅ Functional interfaces +- ✅ Optional (in max/min operations) + +--- + +## 📊 Performance Notes + +Based on benchmark results in comparison classes: +- **Small arrays (< 100 elements):** Traditional approach is faster due to Stream overhead +- **Large arrays (10,000+ elements):** Stream performance improves, gap narrows +- **Very large arrays (1,000,000+ elements):** Traditional still edges out for simple operations +- **Takeaway:** Use Streams for readability and composition, not raw speed in tight loops --- -## Planned Problems +## 🚧 Planned Problems ### Easy - Q003: Print even numbers only diff --git a/java8/README.md b/java8/README.md index 47f6672..e67499b 100644 --- a/java8/README.md +++ b/java8/README.md @@ -2,103 +2,191 @@ ## 📚 Documentation -- **[PROBLEMS.md](PROBLEMS.md)** - Problem statements and concepts covered +- **[PROBLEMS.md](PROBLEMS.md)** - Problem statements, concepts covered, and current status - **[LEARNING_STRUCTURE.md](LEARNING_STRUCTURE.md)** - Complete learning guide and project structure - **[PROBLEM_TEMPLATE.md](PROBLEM_TEMPLATE.md)** - Template for adding new problems - **[Troubleshoot.md](Troubleshoot.md)** - Common errors and solutions --- -## Quick Start +## 📂 Project Structure -This module targets Java 8 and uses the centralized compiler configuration from the root `pom.xml`. +``` +java8/ +├── pom.xml # Module build configuration (Java 8) +├── README.md # This file +├── PROBLEMS.md # Problem statements and status +├── LEARNING_STRUCTURE.md # Learning guide +├── PROBLEM_TEMPLATE.md # Template for new problems +├── Troubleshoot.md # Error solutions +├── src/ +│ └── main/ +│ └── java/ +│ └── com/modernjava/guide/ +│ ├── Main.java # Module entry point +│ └── java8/ +│ ├── Q001_print_numbers/ # ✅ Print all numbers +│ ├── Q002_print_evens/ # ✅ Filter even numbers +│ ├── Q003_square_nums/ # ✅ Sum of squares +│ ├── Q004_max_min/ # ✅ Find max & min +│ └── util/ +│ └── ComparisonUtils.java # ✅ Shared utilities +└── target/ # Compiled output (gitignored) +``` + +--- -If your IDE shows duplicate plugin entries (for example `maven-compiler-plugin[2]`) or stale Maven configuration, refresh the Maven project to force the IDE to re-read the effective POM. +## ðŸŽŊ Quick Start -Quick refresh steps +### Prerequisites +- **Java 8 JDK** must be installed +- Maven 3.6+ (or use included `mvnw` wrapper) -- Command line (sanity check): +### Build & Run ```bash -# build only this module and its dependencies -./mvnw -pl java8 -am -DskipTests verify +# Build only this module +mvn -pl java8 clean compile + +# Build with tests +mvn -pl java8 clean package + +# Run a specific problem comparison (example: Q001) +mvn -pl java8 exec:java -Dexec.mainClass="com.modernjava.guide.java8.Q001_print_numbers.PrintNumbersComparison" + +# Run Q002: Print Evens +mvn -pl java8 exec:java -Dexec.mainClass="com.modernjava.guide.java8.Q002_print_evens.PrintEvensComparison" + +# Run Q003: Sum of Squares +mvn -pl java8 exec:java -Dexec.mainClass="com.modernjava.guide.java8.Q003_square_nums.SumOfSquareOfNumberComparison" + +# Run Q004: Max & Min +mvn -pl java8 exec:java -Dexec.mainClass="com.modernjava.guide.java8.Q004_max_min.MaxMinNumberComparison" ``` -- IntelliJ IDEA: - 1. Open the Maven tool window (View → Tool Windows → Maven). - 2. Click the Refresh button (â†ŧ) to re-import the Maven project. - 3. If stale entries remain: File → Invalidate Caches / Restart → Invalidate and Restart, then re-import. +--- + +## 🔧 IDE Setup -- Eclipse / STS: - 1. Right-click the project → Maven → Update Project... - 2. Select the project(s), check "Force Update of Snapshots/Releases" and click OK. - 3. Optionally: Project → Clean... +### IntelliJ IDEA -- VS Code (with Maven extension): - 1. Open Command Palette (Cmd+Shift+P) → "Maven: Update All Projects". - 2. Or use the Maven sidebar and press the refresh button for the project. +1. **Download Java 8 JDK:** + - `File | Project Structure...` (⌘;) + - `Platform Settings → SDKs → +` → `Download JDK...` + - Select `Temurin 8` or `Corretto 8`, download -Inspect the effective POM +2. **Set Module SDK:** + - `File | Project Structure... → Modules` + - Select `java8` module → `Module SDK` → choose Java 8 -If you want to verify where the compiler plugin is defined and what `` value is used for this module, generate the effective POM and inspect pluginManagement: +3. **Run Configuration:** + - `Run | Edit Configurations...` + - Create new `Application` configuration + - Main class: e.g., `com.modernjava.guide.java8.Q001_print_numbers.PrintNumbersComparison` + - JRE: Select Java 8 + +4. **Refresh Maven:** + - Open Maven tool window (`View → Tool Windows → Maven`) + - Click refresh button (â†ŧ) + - If stale: `File → Invalidate Caches / Restart` + +### VS Code +```bash +# Install Maven extension +# Command Palette (⌘⇧P) → "Maven: Update All Projects" +``` +### Eclipse / STS ```bash -mvn -pl java8 help:effective-pom -Doutput=/tmp/effective-java8-pom.xml -sed -n '//,/<\/pluginManagement>/p' /tmp/effective-java8-pom.xml -# or search for the value -grep -n '' /tmp/effective-java8-pom.xml || true +# Right-click project → Maven → Update Project... +# Check "Force Update of Snapshots/Releases" ``` -If you want, I can add a short repo-level troubleshooting note or automate an IDE refresh script for common environments. +--- + +## 📊 Current Status -Appendix: Required JDK & toolchains +### Completed Problems (4/4) +- ✅ **Q001:** Print All Numbers - Stream basics, forEach(), method references +- ✅ **Q002:** Print Even Numbers - filter(), predicates +- ✅ **Q003:** Sum of Squares - map(), sum(), transformations +- ✅ **Q004:** Max & Min - max(), min(), Optional handling -- Required JDK: Java 8 -- Recommended: install Java 8 locally or configure `~/.m2/toolchains.xml` to point to a Java 8 JDK. +### Utility Classes +- ✅ **ComparisonUtils** - Shared helpers (repeat, formatTime, printNumbers, getArrayOfSpecifiedSize) -Examples: +See **[PROBLEMS.md](PROBLEMS.md)** for detailed problem statements and concepts covered. -```bash -# build only this module (command-line) -mvn -pl java8 -am -DskipTests clean package +--- -# build using the profile added to the parent POM -mvn -Pbuild-java8 clean package +## 🎓 Learning Approach -# preview generated toolchains.xml (macOS helper) -./scripts/generate-toolchains-macos.sh --dry-run +Each problem demonstrates: +1. **Traditional Approach** - Classic Java loops and conditionals +2. **Stream Approach** - Java 8 Stream API with lambdas +3. **Comparison** - Side-by-side execution with performance metrics -# create ~/.m2/toolchains.xml interactively (backs up existing file) -./scripts/generate-toolchains-macos.sh --apply -``` +### Key Concepts Covered +- Lambda expressions: `n -> n % 2 == 0` +- Method references: `System.out::println` +- Stream operations: `filter()`, `map()`, `forEach()`, `sum()`, `max()`, `min()` +- Performance analysis: nano-time benchmarks with multiple test cases +- Edge cases: empty arrays, single elements, large datasets --- -## 🚀 Quick Commands +## ⚠ïļ Troubleshooting + +### Common Error: `invalid flag: --release` +**Cause:** Maven compiler plugin using `--release` flag not supported by Java 8 toolchain + +**Solution:** +```xml + + + maven-compiler-plugin + + 1.8 + 1.8 + + + +``` -```bash -# Compile the module -mvn -pl java8 clean compile +### Common Error: `ExceptionInInitializerError` +**Cause:** Mismatch between compile and runtime JDK versions -# Run Q001: Print Numbers Comparison -mvn -pl java8 exec:java -Dexec.mainClass="com.modernjava.java8.problems.collections.Q001_print_numbers.PrintNumbersComparison" +**Solution:** +- Ensure both Maven and IntelliJ use the same Java 8 JDK +- Check: `mvn -version` should show Java 8 +- IntelliJ: Verify module SDK and run configuration JRE are both Java 8 -# Run Filter and Sum Comparison -mvn -pl java8 exec:java -Dexec.mainClass="com.modernjava.java8.comparisons.FilteringSolutionsComparison" -``` +See **[Troubleshoot.md](Troubleshoot.md)** for complete error reference. --- -## Project Structure +## 🚀 Next Steps -This module is organized to help you learn Stream API by comparing it with traditional approaches: +1. Run existing comparison classes to see traditional vs stream approaches +2. Experiment with different input sizes to observe performance characteristics +3. Add new problems using `PROBLEM_TEMPLATE.md` +4. Explore more Stream API operations (collect, flatMap, distinct, sorted, etc.) +--- -### Learning Approach +## 📝 Notes -**See [PROBLEMS.md](PROBLEMS.md) for complete list of problems and concepts covered.** +- This module uses `1.8` and `1.8` configuration +- All utility methods are Java 8 compatible (no String.repeat(), no var, etc.) +- Performance benchmarks include JIT warmup considerations +- Random array generation uses range -100 to +100 (positive, negative, zero values) -Each problem demonstrates: +--- + +**See also:** +- [Root README](../README.md) - Multi-module project overview +- [Git Best Practices](../docs/GIT_BEST_PRACTICES.md) - Contribution guidelines +- [Troubleshooting](../docs/TROUBLESHOOTING.md) - Global error reference 1. **Traditional Solution** - Pre-Java 8 imperative style with loops 2. **Stream Solution** - Java 8+ functional style with Stream API 3. **Comparison Runner** - Side-by-side execution with performance metrics diff --git a/java8/src/main/java/com/modernjava/guide/java8/Q003_square_nums/SumOfSquareOfNumber.java b/java8/src/main/java/com/modernjava/guide/java8/Q003_square_nums/SumOfSquareOfNumber.java deleted file mode 100644 index b25dd1c..0000000 --- a/java8/src/main/java/com/modernjava/guide/java8/Q003_square_nums/SumOfSquareOfNumber.java +++ /dev/null @@ -1,4 +0,0 @@ -package com.modernjava.guide.java8.Q003_square_nums; - -public class SumOfSquareOfNumber { -} diff --git a/java8/src/main/java/com/modernjava/guide/java8/Q003_square_nums/SumOfSquareOfNumberComparison.java b/java8/src/main/java/com/modernjava/guide/java8/Q003_square_nums/SumOfSquareOfNumberComparison.java new file mode 100644 index 0000000..ef9f2e0 --- /dev/null +++ b/java8/src/main/java/com/modernjava/guide/java8/Q003_square_nums/SumOfSquareOfNumberComparison.java @@ -0,0 +1,53 @@ +package com.modernjava.guide.java8.Q003_square_nums; + +import com.modernjava.guide.java8.util.ComparisonUtils; + +public class SumOfSquareOfNumberComparison { + public static void main(String[] args) { + int[] numbers = {1, 2, 3, 4, 5}; + + System.out.println("Q003: Sum of Square of Numbers Comparison"); + System.out.println("Input: "); + for (int number : numbers) { + System.out.print(number + " "); + } + System.out.println("\n"); + + // Traditional Approach + System.out.println("APPROACH 1: Traditional (For-Each Loop)"); + ComparisonUtils.repeat("-", 80); + System.out.println("Code:"); + System.out.println(" int sum = 0;"); + System.out.println(" for (int number : numbers) {"); + System.out.println(" sum += number * number;"); + System.out.println(" }"); + System.out.println(); + + long traditionalStart = System.nanoTime(); + int traditionalSum = SumOfSquareOfNumberTraditional.sumOfSquares(numbers); + long traditionalEnd = System.nanoTime(); + long traditionalTime = traditionalEnd - traditionalStart; + System.out.println("Output: Sum of squares = " + traditionalSum); + + System.out.println("Time: " + traditionalTime + " ns (" + ComparisonUtils.formatTime(traditionalTime) + ")"); + System.out.println(); + + + // Stream API Approach + System.out.println("APPROACH 2: Stream API"); + ComparisonUtils.repeat("-", 80); + System.out.println("Code:"); + System.out.println(" int sum = Arrays.stream(numbers)"); + System.out.println(" .map(n -> n * n)"); + System.out.println(" .sum();"); + System.out.println(); + long streamStart = System.nanoTime(); + int streamSum = SumOfSquareOfNumberStream.sumOfSquaresStream(numbers); + long streamEnd = System.nanoTime(); + long streamTime = streamEnd - streamStart; + System.out.println("Output: Sum of squares = " + streamSum); + System.out.println("Time: " + streamTime + " ns (" + ComparisonUtils.formatTime(streamTime) + ")"); + System.out.println(); + + } +} diff --git a/java8/src/main/java/com/modernjava/guide/java8/Q003_square_nums/SumOfSquareOfNumberStream.java b/java8/src/main/java/com/modernjava/guide/java8/Q003_square_nums/SumOfSquareOfNumberStream.java new file mode 100644 index 0000000..d8510d3 --- /dev/null +++ b/java8/src/main/java/com/modernjava/guide/java8/Q003_square_nums/SumOfSquareOfNumberStream.java @@ -0,0 +1,38 @@ +package com.modernjava.guide.java8.Q003_square_nums; + +public class SumOfSquareOfNumberStream { + public static void main(String[] args) { + int[] numbers = {1, 2, 3, 4, 5}; + + System.out.println("Q003: Sum of Square of Numbers using Stream API"); + System.out.println("Input: "); + for (int number : numbers) { + System.out.print(number + " "); + } + System.out.println("\n"); + + // Stream API Approach + System.out.println("APPROACH: Stream API"); + System.out.println("Code:"); + System.out.println(" int sum = Arrays.stream(numbers)"); + System.out.println(" .map(n -> n * n)"); + System.out.println(" .sum();"); + System.out.println(); + + int sum = sumOfSquaresStream(numbers); + System.out.println("Output: Sum of squares = " + sum); + } + + public static int sumOfSquaresStream(int[] numbers) { + /** + * Using Java 8 Stream API to calculate the sum of squares of the numbers. + * Steps: + * 1. Convert the array to a stream using Arrays.stream(). + * 2. Use the map() function to square each number. + * 3. Use the sum() function to calculate the total sum of the squared numbers. + */ + return java.util.Arrays.stream(numbers) + .map(n -> n * n) + .sum(); + } +} diff --git a/java8/src/main/java/com/modernjava/guide/java8/Q003_square_nums/SumOfSquareOfNumberTraditional.java b/java8/src/main/java/com/modernjava/guide/java8/Q003_square_nums/SumOfSquareOfNumberTraditional.java new file mode 100644 index 0000000..25c0100 --- /dev/null +++ b/java8/src/main/java/com/modernjava/guide/java8/Q003_square_nums/SumOfSquareOfNumberTraditional.java @@ -0,0 +1,36 @@ +package com.modernjava.guide.java8.Q003_square_nums; + +public class SumOfSquareOfNumberTraditional { + + public static void main(String[] args) { + int[] numbers = {1, 2, 3, 4, 5}; + + System.out.println("Q003: Sum of Square of Numbers"); + System.out.println("Input: "); + for (int number : numbers) { + System.out.print(number + " "); + } + System.out.println("\n"); + + // Traditional Approach + System.out.println("APPROACH: Traditional (For-Each Loop)"); + System.out.println("Code:"); + System.out.println(" int sum = 0;"); + System.out.println(" for (int number : numbers) {"); + System.out.println(" sum += number * number;"); + System.out.println(" }"); + System.out.println(); + + int sum = sumOfSquares(numbers); + System.out.println("Output: Sum of squares = " + sum); + } + + public static int sumOfSquares(int[] numbers) { + int sum = 0; + for (int number : numbers) { + sum += number * number; + } + return sum; + } + +} diff --git a/java8/src/main/java/com/modernjava/guide/java8/Q004_max_min/MaxMinNumberComparison.java b/java8/src/main/java/com/modernjava/guide/java8/Q004_max_min/MaxMinNumberComparison.java new file mode 100644 index 0000000..ef666ff --- /dev/null +++ b/java8/src/main/java/com/modernjava/guide/java8/Q004_max_min/MaxMinNumberComparison.java @@ -0,0 +1,64 @@ +package com.modernjava.guide.java8.Q004_max_min; + +import com.modernjava.guide.java8.util.ComparisonUtils; + +public class MaxMinNumberComparison { + public static void main(String[] args) { + int[] numbers = {45, 22, 89, 11, 67, 34, 90, 5,-121, 342, 0, 9999, -5000}; + + System.out.println("Q004: Find Max and Min Number using Both Approaches"); + ComparisonUtils.repeat("-",80); + + //size 13, small input, traditional 166.33 microseconds, stream 1.01 milliseconds + System.out.println(ComparisonUtils.repeat("-",30)+"Test Case 1: "+ComparisonUtils.repeat("-",30)); + System.out.print("Input: "); + ComparisonUtils.printNumbers(numbers); + compareApproaches(numbers); + + //size 10000, large input, traditional 105.54 microseconds ms, stream 615.42 microseconds + System.out.println("\n\n"+ComparisonUtils.repeat("-",50)+"Test Case 2: "+ComparisonUtils.repeat("-",50)); + System.out.print("Input: "); + numbers = ComparisonUtils.getArrayOfSpecifiedSize(10000); + ComparisonUtils.printNumbers(numbers); + compareApproaches(numbers); + + //size 100,000, large input, traditional 797.08 microseconds ms, stream 1.36 milliseconds + System.out.println("\n\n"+ComparisonUtils.repeat("-",50)+"Test Case 3: "+ComparisonUtils.repeat("-",50)); + System.out.print("Input: "); + numbers = ComparisonUtils.getArrayOfSpecifiedSize(100_000); + //ComparisonUtils.printNumbers(numbers);//not printing for large input + compareApproaches(numbers); + + //size 100,000, large input, traditional 2 milliseconds, stream 14 milliseconds + System.out.println("\n\n"+ComparisonUtils.repeat("-",50)+"Test Case 4: "+ComparisonUtils.repeat("-",50)); + System.out.print("Input: "); + numbers = ComparisonUtils.getArrayOfSpecifiedSize(10_00_000); + //ComparisonUtils.printNumbers(numbers);//not printing for large input + compareApproaches(numbers); + + } + + private static void compareApproaches(int[] numbers) { + // Traditional Approach + System.out.println("APPROACH: Traditional"); + ComparisonUtils.repeat("-",80); + long startTime = System.nanoTime(); + Pair traditionalResult = MaxMinNumberTraditional.findMaxMinTraditional(numbers); + long endTime = System.nanoTime(); + long traditionalTime = endTime - startTime; + System.out.println("Time: " + traditionalTime + " ns (" + ComparisonUtils.formatTime(traditionalTime) + ")"); + System.out.println("Output: Max = " + traditionalResult.getMaxElement() + ", Min = " + traditionalResult.getMinElement()); + + + // Stream API Approach + System.out.println("\nAPPROACH: Stream API"); + ComparisonUtils.repeat("-",80); + long streamStartTime = System.nanoTime(); + Pair streamResult = MaxMinNumberStream.findMaxMinStream(numbers); + long streamEndTime = System.nanoTime(); + long streamTime = streamEndTime - streamStartTime; + System.out.println("Time: " + streamTime + " ns (" + ComparisonUtils.formatTime(streamTime) + ")"); + System.out.println("Output: Max = " + streamResult.getMaxElement() + ", Min = " + streamResult.getMinElement()); + + } +} diff --git a/java8/src/main/java/com/modernjava/guide/java8/Q004_max_min/MaxMinNumberStream.java b/java8/src/main/java/com/modernjava/guide/java8/Q004_max_min/MaxMinNumberStream.java new file mode 100644 index 0000000..f5ace98 --- /dev/null +++ b/java8/src/main/java/com/modernjava/guide/java8/Q004_max_min/MaxMinNumberStream.java @@ -0,0 +1,40 @@ +package com.modernjava.guide.java8.Q004_max_min; + +import com.modernjava.guide.java8.util.ComparisonUtils; + +public class MaxMinNumberStream { + public static void main(String[] args) { + int[] numbers = {45, 22, 89, 11, 67, 34, 90, 5,-121, 342, 0, 9999, -5000}; + + System.out.println("Q004: Find Max and Min Number using Stream API"); + ComparisonUtils.repeat("-",80); + System.out.println("Input: "); + ComparisonUtils.printNumbers(numbers); + + // Stream API Approach + System.out.println("APPROACH: Stream API"); + System.out.println("Code:"); + System.out.println(" int max = Arrays.stream(numbers).max().orElse(0);"); + System.out.println(" int min = Arrays.stream(numbers).min().orElse(0);"); + System.out.println(); + + Pair result = findMaxMinStream(numbers); + System.out.println("Output: Max = " + result.getMaxElement() + ", Min = " + result.getMinElement()); + } + + public static Pair findMaxMinStream(int[] numbers) { + /** + * Using Java 8 Stream API to find the maximum and minimum numbers in an array. + * Steps: + * 1. Convert the array to a stream using Arrays.stream(). + * 2. Use the max() function to find the maximum number. + * 3. Use the min() function to find the minimum number. + * 4. Use orElse(0) to handle the case of an empty array. + * 5. Return both values encapsulated in a Pair object. + */ + int max = java.util.Arrays.stream(numbers).max().orElse(0); + int min = java.util.Arrays.stream(numbers).min().orElse(0); + + return new Pair(min, max); + } +} diff --git a/java8/src/main/java/com/modernjava/guide/java8/Q004_max_min/MaxMinNumberTraditional.java b/java8/src/main/java/com/modernjava/guide/java8/Q004_max_min/MaxMinNumberTraditional.java new file mode 100644 index 0000000..d7c92d0 --- /dev/null +++ b/java8/src/main/java/com/modernjava/guide/java8/Q004_max_min/MaxMinNumberTraditional.java @@ -0,0 +1,42 @@ +package com.modernjava.guide.java8.Q004_max_min; + +import com.modernjava.guide.java8.util.ComparisonUtils; + +public class MaxMinNumberTraditional { + public static void main(String[] args) { + int[] numbers = {45, 22, 89, 11, 67, 34, 90, 5}; + + System.out.println("Q004: Find Max and Min Number using Traditional Approach"); + System.out.println("Input: "); + ComparisonUtils.printNumbers(numbers); + + // Traditional Approach + System.out.println("APPROACH: Traditional"); + Pair result = findMaxMinTraditional(numbers); + System.out.println("Output: Max = " + result.getMaxElement() + ", Min = " + result.getMinElement()); + } + + public static Pair findMaxMinTraditional(int[] numbers) { + /** + * Traditional approach to find the maximum and minimum numbers in an array. + * Steps: + * 1. Initialize max and min with the first element of the array. + * 2. Iterate through the array starting from the second element. + * 3. Update max if the current element is greater than max. + * 4. Update min if the current element is less than min. + */ + int max = numbers[0]; + int min = numbers[0]; + + for (int i = 1; i < numbers.length; i++) { + if (numbers[i] > max) { + max = numbers[i]; + } + if (numbers[i] < min) { + min = numbers[i]; + } + } + + return new Pair(min, max); + } +} diff --git a/java8/src/main/java/com/modernjava/guide/java8/Q004_max_min/Pair.java b/java8/src/main/java/com/modernjava/guide/java8/Q004_max_min/Pair.java new file mode 100644 index 0000000..c0e44b5 --- /dev/null +++ b/java8/src/main/java/com/modernjava/guide/java8/Q004_max_min/Pair.java @@ -0,0 +1,29 @@ +package com.modernjava.guide.java8.Q004_max_min; + + +public class Pair { + private int minElement; + private int maxElement; + + public Pair(int minElement, int maxElement) { + this.minElement = minElement; + this.maxElement = maxElement; + } + + public int getMinElement() { + return minElement; + } + + public void setMinElement(int minElement) { + this.minElement = minElement; + } + + public int getMaxElement() { + return maxElement; + } + + public void setMaxElement(int maxElement) { + this.maxElement = maxElement; + } + +} diff --git a/java8/src/main/java/com/modernjava/guide/java8/util/ComparisonUtils.java b/java8/src/main/java/com/modernjava/guide/java8/util/ComparisonUtils.java index 332ff99..66d8e88 100644 --- a/java8/src/main/java/com/modernjava/guide/java8/util/ComparisonUtils.java +++ b/java8/src/main/java/com/modernjava/guide/java8/util/ComparisonUtils.java @@ -1,5 +1,7 @@ package com.modernjava.guide.java8.util; +import java.util.Random; + /** * Utility class for common methods used across comparison classes. * Provides helper methods for formatting and string operations. @@ -43,5 +45,34 @@ public static String formatTime(long nanos) { return String.format("%.2f ms", nanos / 1_000_000.0); } } + + /** + * Print the elements of an integer array. + * @param numbers + */ + public static void printNumbers(int[] numbers) { + for (Integer number : numbers) { + System.out.print(number+","); + } + System.out.println("\n"); + } + + /** + * method to generate an array of specified size with random integers. + * @param size + * @return + */ + public static int[] getArrayOfSpecifiedSize( int size) { + if (size <= 0) { + return new int[0]; + } + Random rand = new Random(); + final int MAX_ABS = 100; // range will be -MAX_ABS .. +MAX_ABS + int[] result = new int[size]; + for (int i = 0; i < size; i++) { + result[i] = rand.nextInt(MAX_ABS * 2 + 1) - MAX_ABS; + } + return result; + } }