我想出了这样的办法

if (status != null)
{
    if (MDOConstants.DOCREATED.equals(status)) 
    {
        return null;
    }
    else if(MDOConstants.INPROGRESS.equals(status)) 
    {
        if(MDOConstants.MDO_Stored.equals(subStatus) || 
            MDOConstants.GCSS_SUBMITTED.equals(subStatus) ||
            MDOConstants.PENDING_TASKS.equals(subStatus) ||
            MDOConstants.ISSUANCE_OK.equals(subStatus) || 
            MDOConstants.DEADLINE_PASSED.equals(subStatus) ||
            MDOConstants.DEADLINE_PASSED_OR_NEW_PICKUPDATE_NEEDED.equals(subStatus))
        {
            return MDOConstants.INPROGRESS;
        } 
        else if(MDOConstants.GCSS_REQUESTED.equals(subStatus) ||
            MDOConstants.GCSS_ISSUED.equals(subStatus))
        {
            return MDOConstants.ISSUANCE_REQUESTED;
        }
    }  
    else if(MDOConstants.MNLHNDLD.equals(status))
    {
        if(MDOConstants.MNLHNDLD_TECHNICAL.equals(subStatus) ||
            MDOConstants.MNLHNDLD_OUTSIDE_MDO.equals(subStatus))
        {
            return MDOConstants.MNLHNDLD;
        }
    } 
    else if(MDOConstants.DOISSUED.equals(status))
    {
        return MDOConstants.DOISSUED;
    }
}

就像鬼猫说的，我不会因为不好的原因更新这个。但我用这种逻辑为你的未来代码小评论，我将在这里使用一个小块

if (MDOConstants.INPROGRESS.equalsIgnoreCase(status)
                && MDOConstants.MDO_Stored.equalsIgnoreCase(subStatus)) {
    return MDOConstants.INPROGRESS;
} else if (MDOConstants.INPROGRESS.equalsIgnoreCase(status)
                 && MDOConstants.GCSS_SUBMITTED.equalsIgnoreCase(subStatus)) {
     return MDOConstants.INPROGRESS;
} else if (MDOConstants.INPROGRESS.equalsIgnoreCase(status)
                 && MDOConstants.PENDING_TASKS.equalsIgnoreCase(subStatus)) {
     return MDOConstants.INPROGRESS;
} else if (MDOConstants.INPROGRESS.equalsIgnoreCase(status)
                 && MDOConstants.ISSUANCE_OK.equalsIgnoreCase(subStatus)) {
     return MDOConstants.INPROGRESS;
}

这是有意义的。你总是先做同样的检查。就在这个街区里每星期做一次，做一次特定的测试。

if (MDOConstants.INPROGRESS.equalsIgnoreCase(status)){
    if(MDOConstants.MDO_Stored.equalsIgnoreCase(subStatus)) {
        return MDOConstants.INPROGRESS;
    } else if (MDOConstants.GCSS_SUBMITTED.equalsIgnoreCase(subStatus)) {
         return MDOConstants.INPROGRESS;
    } else if (MDOConstants.PENDING_TASKS.equalsIgnoreCase(subStatus)) {
         return MDOConstants.INPROGRESS;
    } else if (MDOConstants.ISSUANCE_OK.equalsIgnoreCase(subStatus)) {
         return MDOConstants.INPROGRESS;
    }
}

那么，你有很多 return ，这样您就可以存储要返回的结果，这样更容易跟踪（但这是针对个人的）。
当然，只返回几个不同的值，可以使用一个大条件

if (MDOConstants.INPROGRESS.equalsIgnoreCase(status)){
    if(MDOConstants.MDO_Stored.equalsIgnoreCase(subStatus) ||  
               MDOConstants.GCSS_SUBMITTED.equalsIgnoreCase(subStatus) || 
               MDOConstants.PENDING_TASKS.equalsIgnoreCase(subStatus)) || 
               MDOConstants.ISSUANCE_OK.equalsIgnoreCase(subStatus)) {
         return MDOConstants.INPROGRESS;
    }
}

最后，我喜欢使用集合或数组来编写这个。

static final List<String> STATUS_IN_PROGRESS = Arrays.asList(
      MDOConstants.MDO_Stored.toLowerCase(), 
      MDOConstants.GCSS_SUBMITTED.toLowerCase(),
      MDOConstants.PENDING_TASKS.toLowerCase(), 
      MDOConstants.ISSUANCE_OK.toLowerCase()
);

if (MDOConstants.INPROGRESS.equalsIgnoreCase(status)){
    if(STATUS_IN_PROGRESS.contains(subStatus.toLowerCase()){
         return MDOConstants.INPROGRESS;
    }
}

如果这是您的确切业务逻辑，与上面所有的返回路径相反，那么您的代码实际上只返回5个不同的值，一个为null，另外4个为status。
在你所有的子状态中，只有2个在状态结果上也有差别。
如果上述代码正确，则此代码将获得完全相同的结果：

if (status == null || MDOConstants.DOCREATED.equalsIgnoreCase(status))
    return null;

if (MDOConstants.INPROGRESS.equalsIgnoreCase(status))
{
    if (MDOConstants.GCSS_REQUESTED.equalsIgnoreCase(subStatus) || MDOConstants.GCSS_ISSUED.equalsIgnoreCase(subStatus))
        return MDOConstants.ISSUANCE_REQUESTED;
    else
        return MDOConstants.INPROGRESS
}
else if (MDOConstants.MNLHNDLD.equalsIgnoreCase(status)
    return MDOConstants.MNLHNDLD;
else if (MDOConstants.DOISSUED.equalsIgnoreCase(status))
    return MDOConstants.DOISSUED;

//Maybe have some default if all else fails here.

你可以尝试创建 HashMap<Condition,String> ```
class Condition
{
String status;
String subStatus;

public Condition(String s, String subS)
{
    status = s;
    subStatus = subS;
}

public boolean equals(Condition c)
{
     return c.status.equalsIgnoreCase(status)
            && c.subStatus.equalsIgnoreCase(subStatus);
}

}

map.put(new Condition(MDOConstants.INPROGRESS, MDOConstants.DEADLINE_PASSED), MDOConstants.INPROGRESS);
//...
//...

map.get(new Condition(MDOConstants.INPROGRESS, MDOConstants.DEADLINE_PASSED)); // This will give you result.

当然，还有改进的余地，但你可能会得到一些提示。

首先，你不应该因为性能不好而重构这段代码；或者声纳抱怨。
你应该重构它，原因很简单，像这样的东西是不可读的。一个人可以在这样的代码中隐藏3到5个拼写错误，而很多人会忽略这一点。
所以，您要做的是：应用单层抽象原则。
因此，重做可以如下所示：

public Whatever findWhateverForPotentiallyNull(String status) {
  if (status == null) {
    return null;

  return findWhatEverFor(status.toUpperCase());
}

private Whatever findWhateverFor(String ucStatus) {
  if (ucStatus.equals(DOCREATED)) {
    return null;
  }

  if (ucStatus.equals(INPROGRESS)) {
    return findWhateverForSubStatus(substatus);
  }

... 等等。笔记：
使用 equals() 比…便宜 equalsIgnoreCase() ; 所以不要一直做后者；只需确保传入状态与常量具有相同的casi ness
我建议对所有这些常量使用静态导入；类名在那里经常重复；所以它在那里真的没有价值；与此相反；它使阅读更难。
是的-你真的去用一个小的私有助手方法的完整列表替换冗长的if/else树。关键是：简单、简短的方法的阅读和理解速度比任何大得多的方法快10倍。
除了纯粹的重构：
使用字符串作为状态。。。听起来是个坏习惯。java是一种强类型语言，您应该努力使用特定的类来为核心数据建模；而不是到处传绳子！
而且，正如一些评论中提到的：您可以考虑在这里使用其他类型的“查找”；例如，通过使用潜在状态列表；或Map；或者类似的东西。