Is there a more efficient way to write multiple if else?

Question

I need to match the average score to a letter grade. That means

if (90 < avg && avg < 100) {
     return 'A';
} 

and so on until 'F', with 5 if-else statements.

That's a lot of repetition, and the ranges I'm matching to are of the same length.

Is there a more efficient way to do this? I don't want to repeat the if-else statement 5 times.

Answer 1

I like to use an enum for this kind of problem.

You simply define your ranges in the enum values and use a predicate.

import java.util.*;

public class MyClass {
    public static void main(String args[]) {
      System.out.println(Letter.getValue(13)); // B
      System.out.println(Letter.getValue(28)); // C
      System.out.println(Letter.getValue(43)); // empty
    }
}

enum Letter {

    A(1, 10), B(11, 20), C(21, 30);

    int min;
    int max;

    Letter (int min, int max) {
        this.min = min;
        this.max = max;
    }

    boolean inRange(int v) {
        return v >= min && v <= max;
    }

    static Optional<Letter> getValue(int i) {
        return Arrays.stream(values())
           .filter(v -> v.inRange(i))
           .findAny();
    }

}

Answer 2

You may find this approach verbose and overengineered. Yes, it's.

Though, I like the way the grading system is defined.

class Test {
  public static void main(String[] args) {
    Map<String, Predicate<Integer>> gradingSystem = new HashMap<>();

    gradingSystem.put("A", mark -> mark >= 90 && mark <= 100);
    gradingSystem.put("B", mark -> mark >= 80 && mark < 90);

    translateScoreIntoGrade(86, gradingSystem); // B
    translateScoreIntoGrade(95, gradingSystem); // A
  }

  public static String translateScoreIntoGrade(int score, Map<String, Predicate<Integer>> gradingSystem) {
    return gradingSystem.entrySet().stream()
        .filter(gradePredicate -> gradePredicate.getValue().test(score))
        .findFirst()
        .map(Map.Entry::getKey)
        .orElseThrow(() -> new IllegalArgumentException("This grade isn't valid for this system!"));
  }
} 

Answer 3

You could do it like this example:

public static String avgValuetoGrade(int value) {
        int index = value/10;
        int gradeIndex = Math.max(0, index - 4);
        return (char)('F'-gradeIndex );
    }

First divide you avg by 10, you get the number 0-9 (integer division). Next you have to reduce the numbers 0-4 somehow to one number -4 gives you the numbers 0-5 and maps the 0-4 to 0. Then you can return the char (thanks to @Carlos Heuberger).

Answer 4

This would be an example of the same thing written in a functional style. There is no repetition, but it's quite verbose.

I wouldn't use it unless the bands were different sizes (where you can exploit integer division)

Map<Range<Integer>, Character> rangeToGrade = Map.of(
   Range.between(90, 100), 'A',
   Range.between(80, 90), 'B'
   //... the rest
);

int mark = 50;
char grade = rangeToGrade.entrySet().stream()
    .filter(e -> e.getKey().contains(mark))
    .map(Map.Entry::getValue)
    .findFirst()
    .orElse('?'); // or throw an exception

Map.of from Java 9. Range from e.g. Apache Commons

Answer 5

You can map it to an array and avoid the branch prediction rules, thereby making it more efficient and also saving the if/else stuff.

class StackOverflow
{
    public static void main(String args[])
    {
        char grades[]={'A','B','C','D','E','F'};
        convert(grades,95);
        convert(grades,90);
        convert(grades,110);
        convert(grades,123);
        convert(grades,150);
    }
    static void convert(char grades[],int marks)
    {
        if(marks<=90||marks>=150)
        {
            System.out.println("Invalid marks");
            return;
        }
        int val=marks/10-9;
        System.out.println(grades[val]);
    }
}

Note: This assumes that 91-99 is A, 100-109 is B, 110-119 is C and so on. If you want to avoid the numbers 100,110 etc. just add the rule ||marks%10==0 in the if statement above.

Hope this is helpful :)

Answer 6

Just to show off, in Java version 12 (preview enabled), using the new Switch Expressions:

String grade = switch(avg/10) {
    case 9,10 -> "A";
    case 8    -> "B";
    case 7    -> "C";
    case 6    -> "D";
    case 5    -> "E";
    default   -> "F";
};

or, very flexible, if not being to lazy:

String grade = switch(avg) {
    case 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100 -> "A";
    case 80, 81, 82, 83, 84, 85, 86, 87, 88, 89      -> "B";
    // you got the idea, I AM lazy

Real (_?) solution: use NavigableMap (example TreeMap) with its floorEntry() or lowerEntry() methods:

NavigableMap<Integer, String> grades = new TreeMap<>();
grades.put(90, "A");
grades.put(80, "B"); 
...
// usage
String grade = grades.floorEntry(avg).getValue();

^{values in map must eventually be adjusted}

Answer 7

Note: This is made using Java 8 and does not have access to MapOf and does not use external libraries. Also did not use Streams to show other options.

I made a GradeBook class that when it is instantiated, a class field for a Map is filled with the keys used to find the letter grade. You can then just call .getGrade(int) from your GradeBook object with will also handle cases of negative input and input above 100 with a return of N. Otherwise it will return the correct grade from the Map.

This is more of an Object Oriented approach rather than using a static method call:

public class GradeBook {

    private Map<Integer, Character> map;

    public GradeBook() {
        constructMap();
    }

    public char getGrade(int grade) {
        if (grade >= 0 && grade <= 100) {
            return map.get(Math.max(0, grade/10 - 4));
        }
        else {
            return 'N';
        }
    }

    public void constructMap() {
        //You can use MapOf to add all of them at once in Java9+
        map = new HashMap<>();
        map.put(0, 'F');
        map.put(1, 'E');
        map.put(2, 'D');
        map.put(3, 'C');
        map.put(4, 'B');
        map.put(5, 'A');
        map.put(6, 'A');
    }

    public static void main(String [] args) {

        GradeBook grades = new GradeBook();

        //Testing different values
        System.out.println(grades.getGrade(100));
        System.out.println(grades.getGrade(75));
        System.out.println(grades.getGrade(80));
        System.out.println(grades.getGrade(91));
        System.out.println(grades.getGrade(45));
        System.out.println(grades.getGrade(2));
        System.out.println(grades.getGrade(-1));
    }
}

Output:

A
C
B
A
F
F
N

The downside to this implementation is it is slightly long to implement the first time, but the upside is it is very easy to reuse as you just need to create a new GradeBook() anywhere you need it.