diff --git a/core-java-8/src/main/java/com/baeldung/reducingIfElse/AddCommand.java b/core-java-8/src/main/java/com/baeldung/reducingIfElse/AddCommand.java
new file mode 100644
index 0000000000..279a3b2c55
--- /dev/null
+++ b/core-java-8/src/main/java/com/baeldung/reducingIfElse/AddCommand.java
@@ -0,0 +1,17 @@
+package com.baeldung.reducingIfElse;
+
+public class AddCommand implements Command {
+
+    private int a;
+    private int b;
+
+    public AddCommand(int a, int b) {
+        this.a = a;
+        this.b = b;
+    }
+
+    @Override
+    public Integer execute() {
+        return a + b;
+    }
+}
diff --git a/core-java-8/src/main/java/com/baeldung/reducingIfElse/AddRule.java b/core-java-8/src/main/java/com/baeldung/reducingIfElse/AddRule.java
new file mode 100644
index 0000000000..f24c973ead
--- /dev/null
+++ b/core-java-8/src/main/java/com/baeldung/reducingIfElse/AddRule.java
@@ -0,0 +1,21 @@
+package com.baeldung.reducingIfElse;
+
+public class AddRule implements Rule {
+
+    private int result;
+
+    @Override
+    public boolean evaluate(Expression expression) {
+        boolean evalResult = false;
+        if (expression.getOperator() == Operator.ADD) {
+            this.result = expression.getX() + expression.getY();
+            evalResult = true;
+        }
+        return evalResult;
+    }
+
+    @Override
+    public Result getResult() {
+        return new Result(result);
+    }
+}
diff --git a/core-java-8/src/main/java/com/baeldung/reducingIfElse/Addition.java b/core-java-8/src/main/java/com/baeldung/reducingIfElse/Addition.java
new file mode 100644
index 0000000000..3174ea558c
--- /dev/null
+++ b/core-java-8/src/main/java/com/baeldung/reducingIfElse/Addition.java
@@ -0,0 +1,8 @@
+package com.baeldung.reducingIfElse;
+
+public class Addition implements Operation {
+    @Override
+    public int apply(int a, int b) {
+        return a + b;
+    }
+}
diff --git a/core-java-8/src/main/java/com/baeldung/reducingIfElse/Calculator.java b/core-java-8/src/main/java/com/baeldung/reducingIfElse/Calculator.java
new file mode 100644
index 0000000000..550d92e183
--- /dev/null
+++ b/core-java-8/src/main/java/com/baeldung/reducingIfElse/Calculator.java
@@ -0,0 +1,83 @@
+package com.baeldung.reducingIfElse;
+
+public class Calculator {
+
+    public int calculate(int a, int b, String operator) {
+        int result = Integer.MIN_VALUE;
+
+        if ("add".equals(operator)) {
+            result = a + b;
+        } else if ("multiply".equals(operator)) {
+            result = a * b;
+        } else if ("divide".equals(operator)) {
+            result = a / b;
+        } else if ("subtract".equals(operator)) {
+            result = a - b;
+        } else if ("modulo".equals(operator)) {
+            result = a % b;
+        }
+        return result;
+    }
+
+    public int calculateUsingSwitch(int a, int b, String operator) {
+        int result = 0;
+        switch (operator) {
+        case "add":
+            result = a + b;
+            break;
+        case "multiply":
+            result = a * b;
+            break;
+        case "divide":
+            result = a / b;
+            break;
+        case "subtract":
+            result = a - b;
+            break;
+        case "modulo":
+            result = a % b;
+            break;
+        default:
+            result = Integer.MIN_VALUE;
+        }
+        return result;
+    }
+
+    public int calculateUsingSwitch(int a, int b, Operator operator) {
+        int result = 0;
+        switch (operator) {
+        case ADD:
+            result = a + b;
+            break;
+        case MULTIPLY:
+            result = a * b;
+            break;
+        case DIVIDE:
+            result = a / b;
+            break;
+        case SUBTRACT:
+            result = a - b;
+            break;
+        case MODULO:
+            result = a % b;
+            break;
+        default:
+            result = Integer.MIN_VALUE;
+        }
+        return result;
+    }
+
+    public int calculate(int a, int b, Operator operator) {
+        return operator.apply(a, b);
+    }
+
+    public int calculateUsingFactory(int a, int b, String operation) {
+        Operation targetOperation = OperatorFactory.getOperation(operation)
+            .orElseThrow(() -> new IllegalArgumentException("Invalid Operator"));
+        return targetOperation.apply(a, b);
+    }
+
+    public int calculate(Command command) {
+        return command.execute();
+    }
+}
diff --git a/core-java-8/src/main/java/com/baeldung/reducingIfElse/Command.java b/core-java-8/src/main/java/com/baeldung/reducingIfElse/Command.java
new file mode 100644
index 0000000000..c084fcc6a0
--- /dev/null
+++ b/core-java-8/src/main/java/com/baeldung/reducingIfElse/Command.java
@@ -0,0 +1,5 @@
+package com.baeldung.reducingIfElse;
+
+public interface Command {
+    Integer execute();
+}
\ No newline at end of file
diff --git a/core-java-8/src/main/java/com/baeldung/reducingIfElse/Division.java b/core-java-8/src/main/java/com/baeldung/reducingIfElse/Division.java
new file mode 100644
index 0000000000..75b1297655
--- /dev/null
+++ b/core-java-8/src/main/java/com/baeldung/reducingIfElse/Division.java
@@ -0,0 +1,7 @@
+package com.baeldung.reducingIfElse;
+
+public class Division implements Operation {
+        @Override public int apply(int a, int b) {
+                return a / b;
+        }
+}
diff --git a/core-java-8/src/main/java/com/baeldung/reducingIfElse/Expression.java b/core-java-8/src/main/java/com/baeldung/reducingIfElse/Expression.java
new file mode 100644
index 0000000000..4d3fe1b824
--- /dev/null
+++ b/core-java-8/src/main/java/com/baeldung/reducingIfElse/Expression.java
@@ -0,0 +1,26 @@
+package com.baeldung.reducingIfElse;
+
+public class Expression {
+
+        private Integer x;
+        private Integer y;
+        private Operator operator;
+
+        public Expression(Integer x, Integer y, Operator operator) {
+                this.x = x;
+                this.y = y;
+                this.operator = operator;
+        }
+
+        public Integer getX() {
+                return x;
+        }
+
+        public Integer getY() {
+                return y;
+        }
+
+        public Operator getOperator() {
+                return operator;
+        }
+}
diff --git a/core-java-8/src/main/java/com/baeldung/reducingIfElse/Modulo.java b/core-java-8/src/main/java/com/baeldung/reducingIfElse/Modulo.java
new file mode 100644
index 0000000000..a7a081704c
--- /dev/null
+++ b/core-java-8/src/main/java/com/baeldung/reducingIfElse/Modulo.java
@@ -0,0 +1,7 @@
+package com.baeldung.reducingIfElse;
+
+public class Modulo implements Operation {
+        @Override public int apply(int a, int b) {
+                return a % b;
+        }
+}
diff --git a/core-java-8/src/main/java/com/baeldung/reducingIfElse/Multiplication.java b/core-java-8/src/main/java/com/baeldung/reducingIfElse/Multiplication.java
new file mode 100644
index 0000000000..e1a39b33c4
--- /dev/null
+++ b/core-java-8/src/main/java/com/baeldung/reducingIfElse/Multiplication.java
@@ -0,0 +1,7 @@
+package com.baeldung.reducingIfElse;
+
+public class Multiplication implements Operation {
+        @Override public int apply(int a, int b) {
+                return 0;
+        }
+}
diff --git a/core-java-8/src/main/java/com/baeldung/reducingIfElse/Operation.java b/core-java-8/src/main/java/com/baeldung/reducingIfElse/Operation.java
new file mode 100644
index 0000000000..41241fa810
--- /dev/null
+++ b/core-java-8/src/main/java/com/baeldung/reducingIfElse/Operation.java
@@ -0,0 +1,5 @@
+package com.baeldung.reducingIfElse;
+
+public interface Operation {
+    int apply(int a, int b);
+}
diff --git a/core-java-8/src/main/java/com/baeldung/reducingIfElse/Operator.java b/core-java-8/src/main/java/com/baeldung/reducingIfElse/Operator.java
new file mode 100644
index 0000000000..831b8fa146
--- /dev/null
+++ b/core-java-8/src/main/java/com/baeldung/reducingIfElse/Operator.java
@@ -0,0 +1,41 @@
+package com.baeldung.reducingIfElse;
+
+public enum Operator {
+
+    ADD {
+        @Override
+        public int apply(int a, int b) {
+            return a + b;
+        }
+    },
+
+    MULTIPLY {
+        @Override
+        public int apply(int a, int b) {
+            return a * b;
+        }
+    },
+
+    SUBTRACT {
+        @Override
+        public int apply(int a, int b) {
+            return a - b;
+        }
+    },
+
+    DIVIDE {
+        @Override
+        public int apply(int a, int b) {
+            return a / b;
+        }
+    },
+
+    MODULO {
+        @Override
+        public int apply(int a, int b) {
+            return a % b;
+        }
+    };
+
+    public abstract int apply(int a, int b);
+}
diff --git a/core-java-8/src/main/java/com/baeldung/reducingIfElse/OperatorFactory.java b/core-java-8/src/main/java/com/baeldung/reducingIfElse/OperatorFactory.java
new file mode 100644
index 0000000000..18ed63adbd
--- /dev/null
+++ b/core-java-8/src/main/java/com/baeldung/reducingIfElse/OperatorFactory.java
@@ -0,0 +1,21 @@
+package com.baeldung.reducingIfElse;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+
+public class OperatorFactory {
+
+    static Map<String, Operation> operationMap = new HashMap<>();
+    static {
+        operationMap.put("add", new Addition());
+        operationMap.put("divide", new Division());
+        operationMap.put("multiply", new Multiplication());
+        operationMap.put("subtract", new Subtraction());
+        operationMap.put("modulo", new Modulo());
+    }
+
+    public static Optional<Operation> getOperation(String operation) {
+        return Optional.ofNullable(operationMap.get(operation));
+    }
+}
diff --git a/core-java-8/src/main/java/com/baeldung/reducingIfElse/Result.java b/core-java-8/src/main/java/com/baeldung/reducingIfElse/Result.java
new file mode 100644
index 0000000000..d5ed12202e
--- /dev/null
+++ b/core-java-8/src/main/java/com/baeldung/reducingIfElse/Result.java
@@ -0,0 +1,13 @@
+package com.baeldung.reducingIfElse;
+
+public class Result {
+    int value;
+
+    public Result(int value) {
+        this.value = value;
+    }
+
+    public int getValue() {
+        return value;
+    }
+}
diff --git a/core-java-8/src/main/java/com/baeldung/reducingIfElse/Rule.java b/core-java-8/src/main/java/com/baeldung/reducingIfElse/Rule.java
new file mode 100644
index 0000000000..5a6c84b0f9
--- /dev/null
+++ b/core-java-8/src/main/java/com/baeldung/reducingIfElse/Rule.java
@@ -0,0 +1,8 @@
+package com.baeldung.reducingIfElse;
+
+public interface Rule {
+
+    boolean evaluate(Expression expression);
+
+    Result getResult();
+}
diff --git a/core-java-8/src/main/java/com/baeldung/reducingIfElse/RuleEngine.java b/core-java-8/src/main/java/com/baeldung/reducingIfElse/RuleEngine.java
new file mode 100644
index 0000000000..ac56915dee
--- /dev/null
+++ b/core-java-8/src/main/java/com/baeldung/reducingIfElse/RuleEngine.java
@@ -0,0 +1,24 @@
+package com.baeldung.reducingIfElse;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+public class RuleEngine {
+
+    private static List<Rule> rules = new ArrayList<>();
+
+    static {
+        rules.add(new AddRule());
+    }
+
+    public Result process(Expression expression) {
+
+        Rule rule = rules.stream()
+            .filter(r -> r.evaluate(expression))
+            .findFirst()
+            .orElseThrow(() -> new IllegalArgumentException("Expression does not matches any Rule"));
+        return rule.getResult();
+    }
+}
diff --git a/core-java-8/src/main/java/com/baeldung/reducingIfElse/Subtraction.java b/core-java-8/src/main/java/com/baeldung/reducingIfElse/Subtraction.java
new file mode 100644
index 0000000000..948998810e
--- /dev/null
+++ b/core-java-8/src/main/java/com/baeldung/reducingIfElse/Subtraction.java
@@ -0,0 +1,7 @@
+package com.baeldung.reducingIfElse;
+
+public class Subtraction implements Operation {
+        @Override public int apply(int a, int b) {
+                return a - b;
+        }
+}
diff --git a/core-java-8/src/test/java/com/baeldung/reduceIfelse/CalculatorUnitTest.java b/core-java-8/src/test/java/com/baeldung/reduceIfelse/CalculatorUnitTest.java
new file mode 100644
index 0000000000..fa351930d8
--- /dev/null
+++ b/core-java-8/src/test/java/com/baeldung/reduceIfelse/CalculatorUnitTest.java
@@ -0,0 +1,32 @@
+package com.baeldung.reduceIfelse;
+
+import com.baeldung.reducingIfElse.AddCommand;
+import com.baeldung.reducingIfElse.Calculator;
+import com.baeldung.reducingIfElse.Operator;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class CalculatorUnitTest {
+
+    @Test
+    public void whenCalculateUsingStringOperator_thenReturnCorrectResult() {
+        Calculator calculator = new Calculator();
+        int result = calculator.calculate(3, 4, "add");
+        assertEquals(7, result);
+    }
+
+    @Test
+    public void whenCalculateUsingEnumOperator_thenReturnCorrectResult() {
+        Calculator calculator = new Calculator();
+        int result = calculator.calculate(3, 4, Operator.valueOf("ADD"));
+        assertEquals(7, result);
+    }
+
+    @Test
+    public void whenCalculateUsingCommand_thenReturnCorrectResult() {
+        Calculator calculator = new Calculator();
+        int result = calculator.calculate(new AddCommand(3, 7));
+        assertEquals(10, result);
+    }
+}
diff --git a/core-java-8/src/test/java/com/baeldung/reduceIfelse/RuleEngineUnitTest.java b/core-java-8/src/test/java/com/baeldung/reduceIfelse/RuleEngineUnitTest.java
new file mode 100644
index 0000000000..4a30b3efac
--- /dev/null
+++ b/core-java-8/src/test/java/com/baeldung/reduceIfelse/RuleEngineUnitTest.java
@@ -0,0 +1,23 @@
+package com.baeldung.reduceIfelse;
+
+import com.baeldung.reducingIfElse.Expression;
+import com.baeldung.reducingIfElse.Operator;
+import com.baeldung.reducingIfElse.Result;
+import com.baeldung.reducingIfElse.RuleEngine;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+public class RuleEngineUnitTest {
+
+    @Test
+    public void whenNumbersGivenToRuleEngine_thenReturnCorrectResult() {
+        Expression expression = new Expression(5, 5, Operator.ADD);
+        RuleEngine engine = new RuleEngine();
+        Result result = engine.process(expression);
+
+        assertNotNull(result);
+        assertEquals(10, result.getValue());
+    }
+}