更清洁的IF声明

Question

在Java中,当您有很多术语时,以下语句看起来非常混乱:

if(a.equals("x") || a.equals("y") || a.equals("z") || Any number of terms...... )
    //Do something

是否有更简洁的方法来执行相同的操作,我希望我的代码尽可能可读.

注意:x,y和z只是任何长度的任何字符串的占位符.这里可能有20个字符串的变量长度,如果条件各自被OR在一起

谢谢

Answer 1

你觉得什么看起来"不干净"？

如果你有一堆复杂的布尔逻辑,你可以将它的不同部分分成单独的布尔变量,并在if语句中引用它们.

或者你可以创建一个带有'a'变量并返回布尔值的函数.你只是将你的逻辑隐藏在方法中,但它会清理你的if语句.

Answer 2

Set<String> stuff = new HashSet<String>();
stuff.add("x");
stuff.add("y");
stuff.add("z");
if(stuff.contains(a)) {
    //stuff
}

如果这是一个紧密循环,您可以使用静态集.

static Set<String> stuff;
static {
    stuff = new HashSet<String>();
    stuff.add("x");
    stuff.add("y");
    stuff.add("z");
}

//Somewhere else in the cosmos

if(stuff.contains(a)) {
    //stuff
}

如果你想要更加确定在你不看的时候没有任何东西被修改.

Set<String> test = Collections.unmodifiableSet(new HashSet<String>() {
        {
            add("x");
            add("y");
            add("z");
        }
    });

如果您只想在少数硬编码条件中获得一些逻辑,则切换或if语句中的一个使用换行解决方案可能会更好.但是如果你有很多条件,那么将配置与逻辑分开可能会很好.

Answer 3

或者,如果您使用的是Java 7+,则可以在switch/case中使用字符串.例如(我从Oracle doc中提取并修改了)

         switch (str) {

             case "x":
             case "y":
             case "z":
                 //do action
                 break;
             default:
              throw new IllegalArgumentException("argument not matched "+str);

    }

这是链接

Answer 4

使用正则表达式

If (a.matches("[xyz]")){
    // matches either "x", "y", or "z"

或者,对于更长的弦乐,

If (a.matches("one|two|three")){
    // matches either "one", "two" or "three"

但这在计算上是昂贵的,但可能并不比实例化等差set.但这是我能想到的最清晰的方式.

但最终,最好的方法可能是保持原样,并调整格式:

if (a.equals("x") || 
    a.equals("y") || 
    a.equals("z")
    ){

因此,代码所做的事情绝对没有歧义,因此您的代码将更容易维护.如果性能很重要,您甚至可以将最可能出现的事件放在列表的顶部.

Answer 5

达到语义

在语义层面上,您要检查的是设置成员资格.但是,您在非常低的级别上实现它,基本上内联实现检查所需的所有代码.除了强迫读者推断出这种大规模条件背后的意图之外,这种方法的一个突出问题是一般布尔表达式中的大量自由度:确保整个事物等于只检查集合成员资格,必须仔细检查每个条款,注意任何括号,重复变量名称的拼写错误等等.

每个松散的自由度意味着不仅暴露于另外一个bug,而且还暴露于另一类 bug.

使用显式集合的方法具有以下优点:

• 清晰明确的语义;
• 严格限制照顾的自由度;
• O(1)时间复杂度与代码的O(n)复杂度.

这是实现基于集合的习语所需的代码:

static final Set<String> matches = 
                            unmodifiableSet(new HashSet<>(asList("a","b","c")));
...

if (matches.contains(a)) // do something;

*_{我暗示import static java.util.Arrays.asList和import static java.util.Collections.unmodifiableSet}

Answer 6

可读性主要是格式化

不可读......

if(a.equals("x") || a.equals("y") || a.equals("z") || Any number of terms...... )
    //Do something

现在很容易实现......

if(a.equals("x") || 
   a.equals("y") || 
   a.equals("z") ||
   Any number of terms...... )
    //Do something

可读性对于阅读源代码的人来说是非常主观的.

如果我遇到了在这里实现集合,循环或许多其他复杂答案之一的代码.我不相信地摇头.

将逻辑从问题中分离出来

你混合了两件不同的东西.存在使业务逻辑易于阅读以及实现业务逻辑的问题.

 if(validState(a))
     // Do something

你如何实施validState并不重要.重要的是带有if语句的代码可以作为业务逻辑读取.它不应该是一个长链的布尔运算,隐藏正在发生的事情的意图.

以下是可读业务逻辑的示例.

if(!isCreditCard(a)) {
    return false;
}
if(isExpired(a)) {
    return false;
}
return paymentAuthorized(a);

在某种程度上,必须有处理基本逻辑,字符串,数组等等的代码.但它不应该处于这个级别.

如果你发现你经常需要检查一个字符串是否等于一堆其他字符串.将该代码放入字符串实用程序类中.将它与您的工作分开并保持您的代码可读性.通过确保它显示您真正想要做的事情.

Answer 7

你可以使用Arrays.asList().这是最简单的方法,而不是冗长.

Arrays.asList("x","y","z"...).contains(a)

出于性能原因,如果您的集合太大,您可以将数据放入HashSet搜索原因中.

示例制作您自己的util方法

public final class Utils{

    private Utils(){}//don't let instantiate

    public static <T> boolean contains(T a,T ... x){
      return new HashSet<>(Arrays.asList(x)).contains(a);
    }
}    

然后在您的客户端代码中:

if(Utils.contains(a,"x","y","z","n")){
  //execute some code
}

Answer 8

通过一些帮助,你可以获得一个更好的if语句的语法糖,只需要一点点开销.详细说明蒂姆的建议和耶稣的推荐......

public abstract class Criteria {

  public boolean matchesAny( Object... objects ) {
    for( int i = 0, count = objects.length; i < count; i++ ) {
      Object object = objects[i];
      if( matches( object ) ) {
        return true;
      }
    }
    return false;
  }

  public boolean matchesAll( Object... objects ) {
    for( int i = 0, count = objects.length; i < count; i++ ) {
      Object object = objects[i];
      if( !matches( object ) ) {
        return false;
      }
    }
    return true;
  }

  public abstract boolean matches( Object object );

}

public class Identity extends Criteria {

  public static Identity of( Object self ) {
    return new Identity( self );
  }

  private final Object self;

  public Identity( Object self ) {
    this.self = self;
  }

  @Override
  public boolean matches( Object object ) {
    return self != null ? self.equals( object ) : object == null;
  }

}

你的if语句看起来像这样:

if( Identity.of( a ).matchesAny( "x", "y", "z" ) ) {
  ...
}

这在具有这种条件匹配的通用语法和使表达式描述特定意图之间具有中间意义.遵循此模式还允许您使用除相等之外的条件执行相同类型的匹配,就像Comparator设计s 一样.

即使使用改进的语法,这个条件表达式仍然有点过于复杂.进一步的重构可能会导致术语外部化并将"x", "y", "z"表达式移动到一个名称明确定义其意图的方法中:

private static final String [] IMPORTANT_TERMS = {
  "x",
  "y",
  "z"
};

public boolean isImportant( String term ) {
  return Identity.of( term ).matchesAny( IMPORTANT_TERMS );
}

......而你原来的if语句最终将被简化为......

if( isImportant( a ) ) {
  ...
}

这样做要好得多,现在包含条件表达式的方法可以更容易地关注"做一件事".

Answer 9

这与你想要实现的目标无关

if(a.equals("x") || a.equals("y") || a.equals("z") || Any number of terms...... )
    //Do something

是总是凌乱和不洁的.首先,它很快就能很快理解它.

在最简单的解决方案,我会表达你的意图,而不是被明确.

尝试这样做:

   public class SomeClass{
    public void SomeMethod(){
        if ( matchesSignificantChar(a) ){
          //doSomething
        }    
    }
    private bool matchesSignificantChar(String s){
        return (s.equals("x") || s.equals("y") || s.equals("z") || Any number of terms......    )
      }
   }

这简化了条件语句的范围,使其更易于理解,同时将复杂性转移到更小和命名的范围,这是由您的意图引导的.

但是,这仍然不是很容易扩展.如果你试图使它更干净,你可以将布尔方法提取到另一个类中,并将其作为委托传递给SomeClass'es构造函数,甚至是SomeMethod.您还可以查看策略模式以获得更高的可行性.

请记住,作为程序员,您将花费更多时间阅读代码(不仅仅是您的代码)而不是编写代码,因此从长远来看,创建更易理解的代码将获得回报.

Answer 10

我使用以下模式

boolean cond = false; // Name this variable reasonably

cond = cond || a.equals("x");
cond = cond || a.equals("y");
cond = cond || a.equals("z");

// Any number of terms......

if (cond) {
    // ...
}

注意:堆上没有创建对象.您也可以使用任何条件,而不仅仅是"等于".

在ruby中,您可以使用运算符||=来实现此目的cond ||= a.equals("x").