code i created so far from beginning to prediate

Author: noahwie

.gitignore

@@ -0,0 +1,38 @@
+target/
+!.mvn/wrapper/maven-wrapper.jar
+!**/src/main/**/target/
+!**/src/test/**/target/
+
+### IntelliJ IDEA ###
+.idea/modules.xml
+.idea/jarRepositories.xml
+.idea/compiler.xml
+.idea/libraries/
+*.iws
+*.iml
+*.ipr
+
+### Eclipse ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+build/
+!**/src/main/**/build/
+!**/src/test/**/build/
+
+### VS Code ###
+.vscode/
+
+### Mac OS ###
+.DS_Store

.idea/.gitignore

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>com.noah</groupId>
+    <artifactId>javafunctional</artifactId>
+    <version>1.0-SNAPSHOT</version>
+
+    <properties>
+        <maven.compiler.source>23</maven.compiler.source>
+        <maven.compiler.target>23</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+
+</project>

.idea/encodings.xml

@@ -0,0 +1,48 @@
+package functionalinterface;
+
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+
+public class _Consumer {
+    public static void main(String[] args) {
+        //creating customer
+        Customer maria = new Customer("Maria", "99999");
+        System.out.println("//Imperative normal Java Function");
+        //Imperative
+        greetCustomer(maria);
+
+        System.out.println("//Declarative");
+        System.out.println("//Consumer functional Interface");
+        //Consumer accepts single input and returns no result
+        greetCustomer.accept(maria);
+
+        System.out.println("//BiConsumer functional Interface takes 2 inputs");
+        //BiConsumer functional Interface takes 2 inputs
+        System.out.println("//greetCustomerV2 true");
+        greetCustomerV2.accept(maria, true);
+        System.out.println("//greetCustomerV2 false");
+        greetCustomerV2.accept(maria, false);
+    }
+
+    //Declarative
+    static Consumer<Customer> greetCustomer = customer ->
+            System.out.println("hello " + customer.customerName + " thanks for registering phonenumber " + customer.customerPhoneNumber);
+
+    static BiConsumer<Customer, Boolean> greetCustomerV2 = (customer, showPhonenumber) ->
+            System.out.println("hello " + customer.customerName + " thanks for registering phonenumber " + (showPhonenumber ? customer.customerPhoneNumber : "*******") );
+
+    //Imperative
+    static void greetCustomer(Customer customer) {
+        System.out.println("hello " + customer.customerName + " thanks for registering phonenumber " + customer.customerPhoneNumber);
+    }
+
+    static class Customer {
+        private String customerName;
+        private String customerPhoneNumber;
+
+        public Customer(String customerName, String customerPhoneNumber) {
+            this.customerName = customerName;
+            this.customerPhoneNumber = customerPhoneNumber;
+        }
+    }
+}

.idea/misc.xml

@@ -0,0 +1,56 @@
+package functionalinterface;
+
+import java.util.function.BiFunction;
+import java.util.function.Function;
+
+public class _Function {
+    public static void main (String[] args) {
+        System.out.println("//Imperative");
+        //Imperative
+        int increment = incrementByOne(0);
+        System.out.println(increment);
+
+        System.out.println(incrementByOneAndMultiply(1, 10));
+
+        System.out.println("//Declarative");
+        System.out.println("//Function takes 1 argument and returns result");
+        //Declarative
+        //Function takes 1 argument and returns result
+        int increment2 = incrementByOneFunction.apply(1);
+        System.out.println(increment2);
+
+        System.out.println("//Chain two functions together with andThen");
+        //Use two functions together with andThen
+        Function<Integer, Integer> addBy1AndThenMultiplyBy10 =
+                incrementByOneFunction.andThen(multiplyBy10Function);
+        System.out.println(addBy1AndThenMultiplyBy10.apply(2));
+
+        System.out.println("//BiFunction takes two inputs and returns 1 output");
+        //BiFunction takes two inputs and returns 1 output
+        System.out.println(incrementByOneAndMultiplyBiFunction.apply(4, 100));
+
+
+
+
+    }
+
+    //Declarative Functions
+    static Function<Integer, Integer> incrementByOneFunction =
+            number -> number + 1;
+
+    static Function<Integer, Integer> multiplyBy10Function = number -> number * 10;
+
+    static BiFunction<Integer, Integer, Integer> incrementByOneAndMultiplyBiFunction =
+            (numberToIncrementByOne, numberToMultiplyBy) -> (numberToIncrementByOne + 1) * numberToMultiplyBy;
+
+    //Imperative
+    static int incrementByOne(int number){
+
+        return number + 1;
+    }
+
+    static int incrementByOneAndMultiply(int number, int numToMultiplyBy){
+
+        return (number + 1) * numToMultiplyBy;
+    }
+}

.idea/uiDesigner.xml

@@ -0,0 +1,45 @@
+package functionalinterface;
+
+import javax.swing.*;
+import java.util.function.BiPredicate;
+import java.util.function.Predicate;
+
+public class _Predicate {
+    public static void main(String[] args) {
+        System.out.println("//Imperative normal Java Function");
+        //Imperative
+        System.out.println(isPhoneNumberValid("07000000000"));
+        System.out.println(isPhoneNumberValid("08000000000"));
+
+        System.out.println("//Declarative");
+        System.out.println("//Predicate functional Interface");
+        //Predicate represents a boolean valued function of one argument
+        System.out.println("is phonenumber valid = " + isPhonenumberValidPredicate.test("07000000000"));
+        System.out.println("is phonenumber valid = " + isPhonenumberValidPredicate.test("08000000000"));
+
+        System.out.println("//Multiple Predicates");
+        //Multiple Predicates
+        System.out.println("is phonenumber valid and contains number 3 = " + isPhonenumberValidPredicate.and(containsNumber3).test("07300000000"));
+        System.out.println("is phonenumber valid and contains number 3 = " + isPhonenumberValidPredicate.and(containsNumber3).test("08400000000"));
+
+        System.out.println("//BiPredicates take two inputs return one boolean");
+        //BiPredicates take two inputs return one boolean
+        System.out.println("phonenumber 1 matches phonenumber 2 = " + phonenumberEqualsSecondPhonenumber.test("0784039365", "0784039354"));
+        System.out.println("phonenumber 1 matches phonenumber 2 = " + phonenumberEqualsSecondPhonenumber.test("0784039365", "0784039365"));
+    }
+
+    //Declarative
+    static Predicate<String> isPhonenumberValidPredicate = phoneNumber ->
+            phoneNumber.startsWith("07") && phoneNumber.length() == 11;
+
+    static Predicate<String> containsNumber3 = phoneNumber ->
+            phoneNumber.contains("3");
+
+    static BiPredicate<String, String> phonenumberEqualsSecondPhonenumber = (phoneNumber1, phoneNumber2) ->
+            phoneNumber1.equals(phoneNumber2);
+
+    //Imperative
+    static boolean isPhoneNumberValid(String phoneNumber){
+        return phoneNumber.startsWith("07") && phoneNumber.length() == 11;
+    }
+}