正确的折射if语句的方法

Question

I wonder if this is a good way to refactor multiple if statements? What I have heard is that if-statements are "bad" practice and i would like to take my programing to the next level by refactor some of my code.

Original code:

public int Colors(String col, int row){
    int ret = 0;
    if(col.equals("R")){
        ret = Color.parseColor("#EF5350");
    }else if(col.equals("B")) {
        ret = Color.parseColor("#7986CB");
    }else if(col.equals("V")){
        ret = Color.WHITE;
    }else if(col.equals("G")){
     ret = Color.parseColor("#FFE082");
    }else if(Math.floorMod(row,2) == 0){
        ret = Color.parseColor("#e0e0e0");
    }else{
         ret = Color.parseColor("#eeeeee");
    }

return ret; }

New code:

public int Colors(String col, int row){

    Map<String,Integer> ColorMap1 = new HashMap<>();

    ColorMap1.put("R", Color.parseColor("#EF5350"));
    ColorMap1.put("B",Color.parseColor("#7986CB"));
    ColorMap1.put("V",Color.parseColor("#FFE082"));
    ColorMap1.put("G",Color.parseColor("#FFFFFF"));

    Integer current = ColorMap1.get(col);

    Map<Integer,Integer> ColorMap2 = new HashMap<>();

    ColorMap2.put(0,Color.parseColor("#e0e0e0"));
    ColorMap2.put(1,Color.parseColor("#eeeeee"));

    Integer current2 = ColorMap2.get(Math.floorMod(row,2));

    return  current != null ? current  : current2 ;

}

Answer 1

If-statements aren't inherently bad. They can be a bit clunky for large comparison blocks, but in Java, there's no universal alternative. (You could use when in Kotlin.)

Since you've got a big block there, and you're comparing Strings, you can always use a switch statement, for most of it:

public int colors(String col, int row) //method names in Java should usually use camelCase, not TitleCase
    switch(col) {
        case "R":
            return Color.parseColor("#EF5350");
        case "B":
            return Color.parseColor("#7986CB");
        case "V":
            return Color.WHITE;
        case "G":
            return Color.parseColor("#FFE082");
        default: //comparable to an "else" statement
            if (Math.floorMod(row, 2) == 0) return Color.parseColor("#e0e0e0");
            else return Color.parseColor("#eeeeee");
    }
}

Answer 2

if in general is not bad practice. It's just that when you find yourself using multiple chained if - else if blocks in a row, that's usually code smell that indicates you could be doing what you are doing more efficiently.

In this case, using a static Map is a good way to refactor your most of your code to be more efficient than the if equivalent. The problem is that, because one of the conditions doesn't match the rest and it isn't a constant value. So you can partially refactor your code like this:

static HashMap<String, Color> colorMap;

static {
    colorMap = new HashMap<>();
    colorMap.put("R",Color.parseColor("#EF5350"));
    colorMap.put("B",Color.parseColor("#7986CB"));
    colorMap.put("V",Color.parseColor("#FFE082"));
    colorMap.put("G",Color.parseColor("#FFFFFF"));
}

// ...

public int Colors(String col, int row) {
    if (colorMap.containsKey(col)) {
      return colorMap.get(col);
    }

    if (Math.floorMod(row, 2) == 0) {
      return Color.parseColor("#e0e0e0");
    }

    return Color.parseColor("#eeeeee");
}

Alternatively, you can accomplish a similar thing with a switch block:

public int Colors(String col, int row) {
    switch (col) {
        case "R": return Color.parseColor("#EF5350");
        case "B": return Color.parseColor("#7986CB");
        case "V": return Color.parseColor("#FFE082");
        case "G": return Color.parseColor("#FFFFFF");
    }

    if (Math.floorMod(row, 2) == 0) {
      return Color.parseColor("#e0e0e0");
    }

    return Color.parseColor("#eeeeee");
}

Answer 3

It's arguable that if-statements or switch-statements are always bad. Sometimes they lead to much more concise code. But if number of cases grows really high, then it becomes cleaner to use Map .

You can use map registry for colors as follows:

public class SomeClass {
    private static int DEFAULT_COLOR = Color.parseColor("#eeeeee");
    private static Map<ColorKey, Integer> COLORS = new HashMap<>();
    static {
        COLORS.put(ColorKey.of("R", null), Color.parseColor("#EF5350"));
        COLORS.put(ColorKey.of("B", null), Color.parseColor("#7986CB"));
        COLORS.put(ColorKey.of("V", null), Color.WHITE);
        COLORS.put(ColorKey.of("G", null), Color.parseColor("#FFE082"));
        COLORS.put(ColorKey.of(null, 0), Color.parseColor("#e0e0e0"));
    }

    public Integer colors(String col, int row) {
        return COLORS.getOrDefault(ColorKey.of(col, row), DEFAULT_COLOR);
    }

    private static final class ColorKey {
       private final String col;
       private final Integer row;
       private ColorKey(String col, Integer row) {
           this.col = col; this.row = row;
       }
       private static ColorKey of(String col, Integer row) {
           return new ColorKey(key(col), key(row));
       }
       private static String key(String col) {
           Set<String> columns = new HashSet<>(Arrays.asList("R", "B", "V", "G"));
           return columns.contains(col) ? col : null;
       }
       private static Integer key(Integer row) {
           return row != null && Math.floorMod(row,2) == 0 ? Integer.valueOf(0) : null;
       }
       @Override
       public boolean equals(Object obj) {
           if (obj == null) return false;
           if (obj == this)  return true;
           if (!(obj instanceof ColorKey)) return false;
           ColorKey that = (ColorKey) obj;
           return Objects.equals(this.col, that.col) && Objects.equals(this.row, that.row);
       }
       @Override
       public int hashCode() {
           int result = 17;
           result = 31 * result + Objects.hash(col);
           result = 31 * result + Objects.hash(row);
           return result;
       }
    }
}

Answer 4

If statement is bad practice if you used it excessively and in different places. The best way to refactor it is to use a design pattern There are many patterns can be used instead of if statement, like strategy , state or command pattern

Answer 5

You can use enum to add different colors:

public class Main
{
    public static void main(String[] args) {
        String colorName = "R";
        int row = 23;
        System.out.println("Color code: " + ColorSchema.getColor(colorName, row).getCode());
    }
}


enum ColorSchema {

  R("#EF5350"), 
  B("#7986CB"), 
  V("#FFE082"),
  G("#FFFFFF"),

  ROW0("#e0e0e0"),
  ROW1("#eeeeee");

  private String color;

  ColorSchema(String color) {this.color = color;}
  public int getCode(){ return Color.parseColor(color);}

  public static ColorSchema getColor(String name, int row) {
    for (ColorSchema c : ColorSchema.values()) {
      if (c.color.equals(name)) {
        return c;
      }
    }
    return ColorSchema.valueOf("ROW" + Math.floorMod(row, 2));
  }

}