處理智能方式的條件

if (lineStyle == 5 || lineStyle == 21 || lineStyle == 82 || lineStyle == 83 || lineStyle == 3) { 
    lineStyleString = "DOUBLE"; 
} else if (lineStyle == 6 || lineStyle == 35 || lineStyle == 39 || lineStyle == 30) { 
    lineStyleString = "DOTTED" ; 
} else if (lineStyle == 26 || lineStyle == 27 || lineStyle == 28 || lineStyle == 29 || lineStyle == 1) { 
    lineStyleString = "SOLID"; 
} else if(lineStyle == -1) { 
    lineStyleString = "NONE"; 
}

我們如何在Java中處理這種代碼的智能方式？切換大小寫，枚舉或密鑰對值模式？處理智能方式的條件

來源

2017-07-18 user1023675

所有的神奇數字看起來都是隨機的。這樣做的「聰明方式」很大程度上取決於它們的結構。 – chrylis

如果編譯器足夠聰明並且值是所示的文字，'switch（）'很可能是最有效的選擇。 – JensG

您的情況看起來更隨機。

開關看起來不錯，這裏

switch(lineStyle) { 
    case 5: 
    case 21: 
    case 82: 
    case 83: 
    case 3: 
    lineStyleString = "DOUBLE"; 
    break; 
    .. // add more cases 
}

或者我希望創建實用方法

public static boolean contains(int expecxted, int... vals) { 
     for (int i = 0; i < vals.length; i++) { 
      if (expecxted == vals[i]) { 
       return true; 
      } 
     } 
     return false; 
    }

而且你可以使用它像

if (contains(lineStyle, 5,21,82,83,3)) { 
    lineStyleString = "DOUBLE"; 
} else if(contains(lineStyle,6,35,39,30)){ 
    lineStyleString = "DOTTED"; 
}

來源

2017-07-18 10:25:29

它需要30行^^ – azro

@azro但更有效率（時間/內存），如果有的話 –

@azro對於任何程序員來說，理解函數和意圖的30行都比10行要好得多心理工作要了解。 – Elemental

的開關情況良好縮進需要線（Netbeans的提出本身進行改造，所以我能數）

所以我認爲這種方式是更好的（線）：

if (Arrays.asList(5, 21, 82, 83, 3).contains(lineStyle)) { 
    lineStyleString = "DOUBLE"; 
} else if (Arrays.asList(6, 35, 39, 30).contains(lineStyle)) { 
    lineStyleString = "DOTTED"; 
} else if (Arrays.asList(26, 27, 28, 29, 1).contains(lineStyle)) { 
    lineStyleString = "SOLID"; 
}else if (lineStyle == -1) { 
    lineStyleString = "NONE"; 
}

來源

2017-07-18 10:27:32 azro

可能考慮爲數組創建常量......使用有意義的名稱，所以它更容易理解/維護 –

我覺得這個想法的性能太可怕了 - 構建動態常量數組只是爲了實現簡單的切換似乎過於複雜從人類可讀和計算的角度來看都是如此。 – Elemental

@CarlosHeuberger另外它會阻止創建太多的對象。 – QBrute

你可以這樣做：

switch (lineStyle){ 
    case 5: 
    case 21: 
    case 82: 
    case 83: 
    case 3: 
     lineStyleString = "DOUBLE"; 
     break; 
    ...

來源

2017-07-18 10:30:15

它需要30行 – azro

儘管5分鐘後[Suresh的答案]（https://stackoverflow.com/a/45164058/85421）有什麼不同？ –

沒有區別。對不起，他的答案在我寄出後立即出現，我一邊工作一邊寫。 –

-1

我認爲最好使用switch語句。

int lcase = lineStyle; 
String lineStyleString = null; 
switch(lcase) 
{ 
    case 3 : 
    case 5 : 
    case 21: 
    case 82: 
    case 83: 
     lineStyleString = "DOUBLE"; 
     break; 
    case 6 : 
    case 30: 
    case 35: 
    case 39: 
     lineStyleString = "DOTTED"; 
     break; 
    case 1 : 
    case 26: 
    case 27: 
    case 28: 
    case 29: 
     lineStyleString = "SOLID"; 
     break; 
    case -1: 
     lineStyleString = "NONE"; 
     break;   
}

來源

2017-07-18 10:34:54

儘管9分鐘後，[Suresh的回答]（https://stackoverflow.com/a/45164058/85421）的第一部分有什麼不同？ –

我討厭懶惰的打字，這個問題很容易被任何編碼人員挑選出來。但他甚至不想寫出完整的答案。 –

真的嗎？然後談到懶惰：他的縮進是正確的，他沒有在代碼部分包含正常文本，沒有使用額外的不必要的變量......並且他發佈的示例應該足以理解這個想法 - StackOverflow不是一個站點做完整的編碼，就是回答問題。 –

-2

隨着一些瑣碎的重新格式化的罰款-是：

int s = lineStyle; 

if (s == 5 || s == 21 || s == 82 || s == 83 || s == 3) { 
    lineStyleString = "DOUBLE"; 

} else if (s == 6 || s == 35 || s == 39 || s == 30) { 
    lineStyleString = "DOTTED"; 

} else if (s == 26 || s == 27 || s == 28 || s == 29 || s == 1) { 
    lineStyleString = "SOLID"; 

} else if (s == -1) { 
    lineStyleString = "NONE"; 
}

來源

2017-07-18 10:35:01 Boann

我更喜歡一個枚舉，如：

enum LineStyle { 

    DOUBLE(3, 5, 21, 82, 83), 
    DOTTED(6, 30, 35, 39), 
    SOLID(1, 26, 27, 28, 29), 
    NONE(-1); 

    private final Set<Integer> types; 

    private LineStyle(Integer... types) { 
    this.types = Stream.of(types).collect(Collectors.toSet()); 
    } 

    public static LineStyle of(int lineStyle) { 
    return Stream.of(LineStyle.values()) 
     .filter(ls -> ls.types.contains(lineStyle)) 
     .findFirst().orElse(null); 
    } 
}

然後，您只需撥打：LineStyle ls = LineStyle.of(lineStyle);

來源

2017-07-18 10:36:46 Flown

與性能相比，哪一個更好。開關，Arrays.asList（常量）或枚舉 – user1023675

這是由你來測試它。我將它排序'switch/if' <<'Map' <'''enum' <'Arrays.asList'（其中開關是最快的） – Flown

@Flown實際上開關應該比（如果）稍微快一些，因爲它通常只是一個索引跳。不知道JIT編譯器如何影響這... –

你可以將條件提取到方法中以使其更具可讀性。

private boolean isDoubleStyle(int lineStyle) { 
    return lineStyle == 5 || lineStyle == 21 || lineStyle == 82 || lineStyle == 83 || lineStyle == 3; 
} 

private boolean isDottedStyle(int lineStyle) { 
    return lineStyle == 6 || lineStyle == 35 || lineStyle == 39 || lineStyle == 30; 
} 

private boolean isSolidStyle(int lineStyle) { 
    return lineStyle == 26 || lineStyle == 27 || lineStyle == 28 || lineStyle == 29 || lineStyle == 1; 
}

，然後調用方法

if (isDoubleStyle(lineStyle)) { 
    lineStyleString = "DOUBLE"; 
} else if (isDottedStyle(lineStyle)) { 
    lineStyleString = "DOTTED" ; 
} else if (isSolidStyle(lineStyle)) { 
    lineStyleString = "SOLID"; 
} else { 
    lineStyleString = "NONE"; 
}

我刪除了最後的檢查爲linestyle == -1，以確保lineStyleString總是有一個值，不管是什麼。

來源

2017-07-18 10:39:27 QBrute

您可以預先填入Map<Integer, String>並將其保存在某處，然後使用它在沒有條件檢查的情況下確定您的值。像，

Map<Integer, String> valueMap = new HashMap<>(); 
Stream.of(5, 21, 82, 83, 3).forEach(x -> valueMap.put(x, "DOUBLE")); 
Stream.of(6, 35, 39, 30).forEach(x -> valueMap.put(x, "DOTTED")); 
Stream.of(26, 27, 28, 29, 1).forEach(x -> valueMap.put(x, "SOLID")); 
valueMap.put(-1, "NONE");

再後來

String lineStyleString = valueMap.get(lineStyle);

來源

2017-07-18 10:39:52

-1

不知道這是否是聰明的方式，但它是definetly更具可讀性和短：

lineStyleString = (lineStyle == 5 || lineStyle == 21 || lineStyle == 82 || lineStyle == 83 || lineStyle == 3)? "DOUBLE" 
        :(lineStyle == 6 || lineStyle == 35 || lineStyle == 39 || lineStyle == 30)? "DOTTED" 
        :(lineStyle == 26 || lineStyle == 27 || lineStyle == 28 || lineStyle == 29 || lineStyle == 1)? "SOLID" 
        :"NONE";

或使用IntStream

lineStyleString = (IntStream.of(5,21,82,83,3).anyMatch(x -> x == lineStyle)) ? "DOUBLE" 
        :(IntStream.of(6,35,39,30).anyMatch(x -> x == lineStyle)) ? "DOTTED" 
        :(IntStream.of(26,27,28,29,1).anyMatch(x -> x == lineStyle))? "SOLID" 
        :"NONE";

來源

2017-07-18 10:51:00 Eritrean

我很驚訝，這是可讀的你。 – Flown

處理智能方式的條件

回答

相關問題