feat(PredicateDemo): add demo showcasing multiple Predicate use cases and combinations

What
- Added PredicateDemo class demonstrating usage of java.util.function.Predicate with integers and strings.
- Examples included:
  - Predicate<Integer> isEven → checks divisibility by 2.
  - Predicate<String> isWordStartingWithLetterA → checks startsWith("S").
  - Predicate<String> isWordStartingWithLetterZ → checks startsWith("Z").
  - Predicate<String> isWordEndingWithA → incorrectly reused startsWith("A") (typo).
  - Combined predicate Check using and().
  - Predicate<String> isWordStartingWithA (case-insensitive).
  - Predicate<String> isWordEndingWithT (case-insensitive).
  - Combined predicate and = isWordStartingWithA.and(isWordEndingWithT).
  - Predicate<Integer> p → checks x >= 1,000,000.
- Printed results of multiple tests, including salary check.

Why
- Demonstrates functional programming with predicates for boolean-valued functions.
- Shows how predicates encapsulate conditions into reusable, composable variables.
- Highlights use of and() to combine multiple conditions.
- Practical educational example for conditions with strings, numbers, and logical composition.

How
- Declared predicates with lambda expressions.
- Used test() to evaluate conditions on sample values.
- Combined predicates using and().
- Printed boolean results for verification.
- Used predicate p to validate salary threshold and print conditional output.

Logic
- Inputs:
  - Integers: 4, 1,000,000, 90.
  - Strings: "Stark", "AoooooZ", "Jackson".
- Outputs:
  - isEven.test(4) → true.
  - isWordStartingWithLetterA.test("Stark") → true.
  - Check.test("AoooooZ") → true (due to startsWith("A")).
  - and.test("Jackson") → false.
  - p.test(1,000,000) → true.
  - salary = 90, p.test(90) → false → prints "False".
- Flow:
  1. Define predicates for various string and numeric conditions.
  2. Combine some predicates with and().
  3. Evaluate predicates with sample inputs.
  4. Print results.
  5. Use predicate in if-else to branch logic.
- Edge cases:
  - Some predicates incorrectly reuse startsWith where endsWith was intended.
  - Empty/null strings would cause exceptions.
- Complexity / performance: O(1) checks, negligible.
- Concurrency / thread-safety: Predicates are stateless, safe across threads.
- Error handling: No explicit null/empty handling, may throw runtime errors.

Real-life applications
- Validating user inputs (e.g., names starting/ending with specific characters).
- Applying salary or threshold checks in business logic.
- Filtering collections in stream pipelines using predicates.
- Combining predicates for flexible business rules.

Notes
- Typo: isWordEndingWithA uses startsWith instead of endsWith.
- Predicates are composable with and(), or(), negate() for complex rules.
- For clarity, method references like String::startsWith could be used in simple cases.

Signed-off-by: https://github.com/Someshdiwan <someshdiwan369@gmail.com>

Author: Someshdiwan

JAVA8/Predicates/src/PredicateDemo.java … Course/Predicate/src/PredicateDemo.javaJAVA8/Predicates/src/PredicateDemo.java renamed to Java 8 Crash Course/Predicate/src/PredicateDemo.java JAVA8/Predicates/src/PredicateDemo.java renamed to Java 8 Crash Course/Predicate/src/PredicateDemo.java

@@ -2,27 +2,37 @@
 
 public class PredicateDemo {
     public static void main(String[] args) {
-        // Predicate --> Functional interface ( Boolean valued function )
-
+        // Predicate --> Functional interface & it is a Boolean valued function.
         Predicate<Integer> isEven = x -> x % 2 == 0;
+
         //Kutch check karna hai toh predicate use karna.Bas Ek condition hold karta hai.
         //ek condition ko variable store mai store karta hai.
         System.out.println(isEven.test(4));
 
-        Predicate<String> isWordStartingWithLetterA = x-> x.startsWith("A");
-        System.out.println(isWordStartingWithLetterA.test("Ankit"));
-
+        Predicate<String> isWordStartingWithLetterA = x -> x.startsWith("S");
+        System.out.println(isWordStartingWithLetterA.test("Stark"));
 
         //combining a predicate.
-        Predicate<String> isWordStartingWithLetterZ = x-> x.startsWith("Z");
-        Predicate<String> isWordEndingWithA = x-> x.startsWith("A");
+        Predicate<String> isWordStartingWithLetterZ = x -> x.startsWith("Z");
+        Predicate<String> isWordEndingWithA = x -> x.startsWith("A");
         Predicate<String> Check = isWordEndingWithA.and(isWordEndingWithA);
 
         System.out.println(Check.test("AoooooZ"));
 
         Predicate<String> isWordStartingWithA = x -> x.toLowerCase().startsWith("a");
         Predicate<String> isWordEndingWithT = x -> x.toLowerCase().endsWith("t");
         Predicate<String> and = isWordStartingWithA.and(isWordEndingWithT);
-        System.out.println(and.test("Akshay"));
+        System.out.println(and.test("Jackson"));
+
+
+        Predicate<Integer> p = x -> x >= 1000000;
+        System.out.println(p.test(1000000));
+
+        int salary = 90;
+        if (p.test(salary)) {
+            System.out.println("True");
+        } else {
+            System.out.println("False");
+        }
     }
 }