iSharkFly-Docs
/
java-tutorials
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

BAEL-2303 Added sample code to demo how to replace multiple if statements in java.

This commit is contained in:
Sandip Singh 2018-11-02 20:41:50 +05:30
parent b94071b1af
commit e1b47c72a0
16 changed files with 315 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
core-java-8/src/main/java/com/baeldung/reducingIfElse/AddCommand.java Normal file
View File

@ -0,0 +1,19 @@
package com.baeldung.reducingIfElse;
public class AddCommand implements Command<Integer, Integer, Integer> {
private int a;
private int b;
@Override
public Integer execute() {
return a + b;
}
@Override
public Command<Integer, Integer, Integer> takeInput(Integer a, Integer b) {
this.a = a;
this.b = b;
return this;
}
}

21
core-java-8/src/main/java/com/baeldung/reducingIfElse/AddRule.java Normal file
View File

@ -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 int getResult() {
return result;
}
}

8
core-java-8/src/main/java/com/baeldung/reducingIfElse/Addition.java Normal file
View File

@ -0,0 +1,8 @@
package com.baeldung.reducingIfElse;
public class Addition implements Operation {
@Override
public int apply(int a, int b) {
return a + b;
}
}

84
core-java-8/src/main/java/com/baeldung/reducingIfElse/Calculator.java Normal file
View File

@ -0,0 +1,84 @@
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(int a, int b, Command<Integer, Integer, Integer> command) {
return command.takeInput(a, b)
.execute();
}
}

7
core-java-8/src/main/java/com/baeldung/reducingIfElse/Command.java Normal file
View File

@ -0,0 +1,7 @@
package com.baeldung.reducingIfElse;
public interface Command<A, B, R> {
R execute();
Command<A, B, R> takeInput(A a, B b);
}

7
core-java-8/src/main/java/com/baeldung/reducingIfElse/Division.java Normal file
View File

@ -0,0 +1,7 @@
package com.baeldung.reducingIfElse;
public class Division implements Operation {
@Override public int apply(int a, int b) {
return a / b;
}
}

26
core-java-8/src/main/java/com/baeldung/reducingIfElse/Expression.java Normal file
View File

@ -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;
}
}

7
core-java-8/src/main/java/com/baeldung/reducingIfElse/Modulo.java Normal file
View File

@ -0,0 +1,7 @@
package com.baeldung.reducingIfElse;
public class Modulo implements Operation {
@Override public int apply(int a, int b) {
return a % b;
}
}

7
core-java-8/src/main/java/com/baeldung/reducingIfElse/Multiplication.java Normal file
View File

@ -0,0 +1,7 @@
package com.baeldung.reducingIfElse;
public class Multiplication implements Operation {
@Override public int apply(int a, int b) {
return 0;
}
}

5
core-java-8/src/main/java/com/baeldung/reducingIfElse/Operation.java Normal file
View File

@ -0,0 +1,5 @@
package com.baeldung.reducingIfElse;
public interface Operation {
int apply(int a, int b);
}

41
core-java-8/src/main/java/com/baeldung/reducingIfElse/Operator.java Normal file
View File

@ -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);
}

21
core-java-8/src/main/java/com/baeldung/reducingIfElse/OperatorFactory.java Normal file
View File

@ -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));
}
}

8
core-java-8/src/main/java/com/baeldung/reducingIfElse/Rule.java Normal file
View File

@ -0,0 +1,8 @@
package com.baeldung.reducingIfElse;
public interface Rule {
boolean evaluate(Expression expression);
int getResult();
}

20
core-java-8/src/main/java/com/baeldung/reducingIfElse/RuleEngine.java Normal file
View File

@ -0,0 +1,20 @@
package com.baeldung.reducingIfElse;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class RuleEngine {
private static List<Rule> rules = new ArrayList<>();
static {
rules.add(new AddRule());
}
public List<Rule> process(Expression expression) {
return rules.stream()
.filter(r -> r.evaluate(expression))
.collect(Collectors.toList());
}
}

7
core-java-8/src/main/java/com/baeldung/reducingIfElse/Subtraction.java Normal file
View File

@ -0,0 +1,7 @@
package com.baeldung.reducingIfElse;
public class Subtraction implements Operation {
@Override public int apply(int a, int b) {
return a - b;
}
}

27
core-java-8/src/test/java/com/baeldung/reduceIfelse/RuleEngineUnitTest.java Normal file
View File

@ -0,0 +1,27 @@
package com.baeldung.reduceIfelse;
import com.baeldung.reducingIfElse.Expression;
import com.baeldung.reducingIfElse.Operator;
import com.baeldung.reducingIfElse.Rule;
import com.baeldung.reducingIfElse.RuleEngine;
import org.junit.Test;
import java.util.List;
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();
List<Rule> rules = engine.process(expression);
assertNotNull(rules);
assertEquals(1, rules.size());
assertEquals(10, rules.get(0)
.getResult());
}
}