Java switchステートメントの複数のケース
Java switchステートメントに多くの複数のケースを使用する方法を見つけようとしています。ここに私がやろうとしていることの例があります：
switch (variable)
{
case 5..100:
doSomething();
break;
}
対すること：
switch (variable)
{
case 5:
case 6:
etc.
case 100:
doSomething();
break;
}
これが可能であれば、何かアイデアがありますか？
悲しいことに、Javaでは不可能です。 if-elseステートメントを使用する必要があります。
2番目のオプションはまったく問題ありません。レスポンダーがそれが不可能だと言った理由がわかりません。これは結構です、そして私はこれをいつもします：
switch (variable)
{
case 5:
case 6:
etc.
case 100:
doSomething();
break;
}
以前の回答ほどエレガントではないかもしれませんが、いくつかの大きな範囲でスイッチケースを達成したい場合は、事前に範囲を単一のケースに結合してください：
// make a switch variable so as not to change the original value
int switchVariable = variable;
//combine range 1-100 to one single case in switch
if(1 <= variable && variable <=100)
switchVariable = 1;
switch (switchVariable)
{
case 0:
break;
case 1:
// range 1-100
doSomething();
break;
case 101:
doSomethingElse();
break;
etc.
}
public class SwitchTest {
public static void main(String[] args){
for(int i = 0;i<10;i++){
switch(i){
case 1: case 2: case 3: case 4: //First case
System.out.println("First case");
break;
case 8: case 9: //Second case
System.out.println("Second case");
break;
default: //Default case
System.out.println("Default case");
break;
}
}
}
}
でる：
Default case
First case
First case
First case
First case
Default case
Default case
Default case
Second case
Second case
Src： http://docs.Oracle.com/javase/tutorial/Java/nutsandbolts/switch.html
過度に大きいswitchおよびif/else構造を置き換えるオブジェクト指向オプションの1つは、Chain of Responsibility Patternを使用して意思決定をモデル化することです。
責任パターンのチェーン
責任の連鎖パターンにより、リクエストのソースを分離し、リクエストの潜在的に多数のハンドラーのどれをアクションにすべきかを決定することができます。チェーンの役割を表すクラスは、ハンドラーがリクエストを受け入れてアクションを実行するまで、ハンドラーのリストに沿ってソースからのリクエストを送信します。
ジェネリックを使用したタイプセーフでもある実装例を次に示します。
import Java.util.ArrayList;
import Java.util.List;
/**
* Generic enabled Object Oriented Switch/Case construct
* @param <T> type to switch on
*/
public class Switch<T extends Comparable<T>>
{
private final List<Case<T>> cases;
public Switch()
{
this.cases = new ArrayList<Case<T>>();
}
/**
* Register the Cases with the Switch
* @param c case to register
*/
public void register(final Case<T> c) { this.cases.add(c); }
/**
* Run the switch logic on some input
* @param type input to Switch on
*/
public void evaluate(final T type)
{
for (final Case<T> c : this.cases)
{
if (c.of(type)) { break; }
}
}
/**
* Generic Case condition
* @param <T> type to accept
*/
public static interface Case<T extends Comparable<T>>
{
public boolean of(final T type);
}
public static abstract class AbstractCase<T extends Comparable<T>> implements Case<T>
{
protected final boolean breakOnCompletion;
protected AbstractCase()
{
this(true);
}
protected AbstractCase(final boolean breakOnCompletion)
{
this.breakOnCompletion = breakOnCompletion;
}
}
/**
* Example of standard "equals" case condition
* @param <T> type to accept
*/
public static abstract class EqualsCase<T extends Comparable<T>> extends AbstractCase<T>
{
private final T type;
public EqualsCase(final T type)
{
super();
this.type = type;
}
public EqualsCase(final T type, final boolean breakOnCompletion)
{
super(breakOnCompletion);
this.type = type;
}
}
/**
* Concrete example of an advanced Case conditional to match a Range of values
* @param <T> type of input
*/
public static abstract class InRangeCase<T extends Comparable<T>> extends AbstractCase<T>
{
private final static int GREATER_THAN = 1;
private final static int EQUALS = 0;
private final static int LESS_THAN = -1;
protected final T start;
protected final T end;
public InRangeCase(final T start, final T end)
{
this.start = start;
this.end = end;
}
public InRangeCase(final T start, final T end, final boolean breakOnCompletion)
{
super(breakOnCompletion);
this.start = start;
this.end = end;
}
private boolean inRange(final T type)
{
return (type.compareTo(this.start) == EQUALS || type.compareTo(this.start) == GREATER_THAN) &&
(type.compareTo(this.end) == EQUALS || type.compareTo(this.end) == LESS_THAN);
}
}
/**
* Show how to apply a Chain of Responsibility Pattern to implement a Switch/Case construct
*
* @param args command line arguments aren't used in this example
*/
public static void main(final String[] args)
{
final Switch<Integer> integerSwitch = new Switch<Integer>();
final Case<Integer> case1 = new EqualsCase<Integer>(1)
{
@Override
public boolean of(final Integer type)
{
if (super.type.equals(type))
{
System.out.format("Case %d, break = %s\n", type, super.breakOnCompletion);
return super.breakOnCompletion;
}
else
{
return false;
}
}
};
integerSwitch.register(case1);
// more instances for each matching pattern, granted this will get verbose with lots of options but is just
// and example of how to do standard "switch/case" logic with this pattern.
integerSwitch.evaluate(0);
integerSwitch.evaluate(1);
integerSwitch.evaluate(2);
final Switch<Integer> inRangeCaseSwitch = new Switch<Integer>();
final Case<Integer> rangeCase = new InRangeCase<Integer>(5, 100)
{
@Override
public boolean of(final Integer type)
{
if (super.inRange(type))
{
System.out.format("Case %s is between %s and %s, break = %s\n", type, this.start, this.end, super.breakOnCompletion);
return super.breakOnCompletion;
}
else
{
return false;
}
}
};
inRangeCaseSwitch.register(rangeCase);
// run some examples
inRangeCaseSwitch.evaluate(0);
inRangeCaseSwitch.evaluate(10);
inRangeCaseSwitch.evaluate(200);
// combining both types of Case implementations
integerSwitch.register(rangeCase);
integerSwitch.evaluate(1);
integerSwitch.evaluate(10);
}
}
これはほんの数分で簡単に書き上げたものです。より洗練された実装では、ある種のCommand PatternをCase実装インスタンスに挿入して、よりコールバックIoCスタイルにすることができます。
このアプローチの良い点は、Switch/Caseステートメントがすべて副作用であるということです。これにより、副作用がクラスにカプセル化され、管理および再利用が可能になります。それは悪いことではありません。
これに対する更新または機能拡張を投稿します Gist Githubに。
基本的に：
if (variable >= 5 && variable <= 100)
{
doSomething();
}
スイッチを本当に使用する必要がある場合は、特定の範囲に対してさまざまなことを行う必要があるためです。その場合、そうです、物事は複雑になり、パターンに従うものだけがうまく圧縮されるため、コードが乱雑になります。
切り替えの唯一の理由は、数値の切り替え値をテストするだけの場合に変数名を入力する手間を省くためです。あなたは100のことをオンにするつもりはなく、それらはすべて同じことをしているわけではありません。それは「if」チャンクのように聞こえます。
この質問 によれば、それは完全に可能です。
同じロジックを含むすべてのケースをまとめて、breakを後ろに置かないでください。
switch (var) {
case (value1):
case (value2):
case (value3):
//the same logic that applies to value1, value2 and value3
break;
case (value4):
//another logic
break;
}
これは、caseのないbreakが、caseまたはbreakになるまで別のreturnにジャンプするためです。
編集：
コメントに返信して、同じロジックで95個の値が実際にあるが、異なるロジックでケースの数が少なければ、次のことができます。
switch (var) {
case (96):
case (97):
case (98):
case (99):
case (100):
//your logic, opposite to what you put in default.
break;
default:
//your logic for 1 to 95. we enter default if nothing above is met.
break;
}
より細かい制御が必要な場合は、if-elseを選択してください。
//違反コード例
switch (i) {
case 1:
doFirstThing();
doSomething();
break;
case 2:
doSomethingDifferent();
break;
case 3: // Noncompliant; duplicates case 1's implementation
doFirstThing();
doSomething();
break;
default:
doTheRest();
}
if (a >= 0 && a < 10) {
doFirstThing();
doTheThing();
}
else if (a >= 10 && a < 20) {
doTheOtherThing();
}
else if (a >= 20 && a < 50) {
doFirstThing();
doTheThing(); // Noncompliant; duplicates first condition
}
else {
doTheRest();
}
//適合ソリューション
switch (i) {
case 1:
case 3:
doFirstThing();
doSomething();
break;
case 2:
doSomethingDifferent();
break;
default:
doTheRest();
}
if ((a >= 0 && a < 10) || (a >= 20 && a < 50)) {
doFirstThing();
doTheThing();
}
else if (a >= 10 && a < 20) {
doTheOtherThing();
}
else {
doTheRest();
}
前回のJava-12リリースから、同じケースラベルの複数の定数が プレビュー言語機能
JDK機能リリースで利用でき、実際の使用に基づいて開発者のフィードバックを引き起こします。これにより、将来のJava SEプラットフォームで永続的になる可能性があります。
次のようになります。
switch(variable) {
case 1 -> doSomething();
case 2, 3, 4 -> doSomethingElse();
};
もっと見る JEP 325：式の切り替え（プレビュー）
Vavr libraryを使用してこれを処理することが可能です
import static io.vavr.API.*;
import static io.vavr.Predicates.*;
Match(variable).of(
Case($(isIn(5, 6, ... , 100)), () -> doSomething()),
Case($(), () -> handleCatchAllCase())
);
すべてのケースを明示的にリストする必要があるため、これはもちろんわずかな改善にすぎません。しかし、カスタム述語を定義するのは簡単です：
public static <T extends Comparable<T>> Predicate<T> isInRange(T lower, T upper) {
return x -> x.compareTo(lower) >= 0 && x.compareTo(upper) <= 0;
}
Match(variable).of(
Case($(isInRange(5, 100)), () -> doSomething()),
Case($(), () -> handleCatchAllCase())
);
一致は式なので、ここではメソッドを直接呼び出す代わりにRunnableインスタンスのようなものを返します。一致が実行された後、Runnableを実行できます。
詳細については、 公式ドキュメント を参照してください。
代わりに、次のように使用できます。
if (variable >= 5 && variable <= 100) {
doSomething();
}
または、次のコードも動作します
switch (variable)
{
case 5:
case 6:
etc.
case 100:
doSomething();
break;
}
ハードコードされた値を使用する代わりに、switchステートメントで範囲マッピングを使用することもできます。
private static final int RANGE_5_100 = 1;
private static final int RANGE_101_1000 = 2;
private static final int RANGE_1001_10000 = 3;
public boolean handleRanges(int n) {
int rangeCode = getRangeCode(n);
switch (rangeCode) {
case RANGE_5_100: // doSomething();
case RANGE_101_1000: // doSomething();
case RANGE_1001_10000: // doSomething();
default: // invalid range
}
}
private int getRangeCode(int n) {
if (n >= 5 && n <= 100) {
return RANGE_5_100;
} else if (n >= 101 && n <= 1000) {
return RANGE_101_1000;
} else if (n >= 1001 && n <= 10000) {
return RANGE_1001_10000;
}
return -1;
}