In ordinary Java code, including Java SE 17, you cannot use a boolean or Boolean variable as the selector of a switch. A two-way true/false decision should normally use if/else. Making switch an expression does not change the types that the language permits. Java SE 26 has a version-specific preview specification for primitive types in patterns, instanceof, and switch; that preview changes the answer for some targets, but it is not an ordinary rule you can assume for older JDKs or for a build that has preview features disabled.
The direct answer
Under the established Java language rules used by Java SE 17, a switch selector may be a primitive integral type (char, byte, short, or int), the corresponding wrapper classes, String, or an enum type. boolean and Boolean are not in that list. Consequently, this code is not legal Java 17:
As an Amazon Associate I earn from qualifying purchases.
boolean enabled = getEnabled();
switch (enabled) {
case true:
start();
break;
case false:
stop();
break;
}The compiler rejects the selector before it considers the case labels. Replacing the statement with a switch expression does not make the selector legal. For code that must compile under ordinary Java 17 rules, write the branch directly:
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
if (enabled) {
start();
} else {
stop();
}Java SE 26 contains preview work that includes primitive types in patterns, instanceof, and switch. If you are targeting that release and explicitly enabling its preview language features, check the exact specification and compiler settings for your JDK. Do not copy a preview example into a Java 17 project and expect it to compile.
Why the selector type matters separately from the switch form
A switch statement
A switch statement chooses one of several execution paths. Its selector still has to be one of the types allowed by the language version you compile against. The fact that the body can contain many labels does not turn an unsupported type into a supported one.
A switch expression
A switch expression is the value-producing counterpart to a switch statement. It can appear on the right side of an assignment, in a return statement, or inside another expression:
String label = switch (status) {
case READY -> "ready";
case STOPPED -> "stopped";
};The expression form changes how a result is produced and how exhaustiveness is handled; it does not, by itself, add boolean to the selector-type list. The historical switch-expression specification associated with JEP 325 likewise excluded boolean selectors. Treat these as two independent questions:
The Tool Desk
Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →- Which switch form are you using: a statement or an expression?
- Is the selector type permitted by the target Java language level?
A “yes” to the first question never supplies a “yes” to the second.
Selector types in ordinary Java SE 17
The Java SE 17 language specification defines the ordinary selector categories. The following table separates the permitted categories from the types that often cause confusion.
| Selector type | Allowed in an ordinary Java SE 17 switch? | Notes |
|---|---|---|
char, byte, short, int |
Yes | These are the supported primitive integral types. |
Character, Byte, Short, Integer |
Yes | The listed wrapper classes are supported selector types. |
String |
Yes | String case labels are supported under ordinary switch rules. |
| An enum type | Yes | Use the enum constants as the cases. |
boolean |
No | Boolean is absent from the Java SE 17 selector list. |
Boolean |
No | The wrapper does not become valid merely because other wrappers are listed. |
This is a language-legality issue, not a performance measurement. The specifications establish which programs are accepted; they do not establish that one legal branching form is faster than another for your workload.
Rank #2
What compiler error to expect
Exact diagnostic wording varies by compiler and release, but a Java compiler will report that the switch selector or selector type is invalid when it sees a boolean. The error is not caused by the spelling of true and false as case labels. The selector is rejected first.
Recommended Free Tools
Changing the variable from primitive to wrapper does not solve it:
Boolean enabled = getEnabledObject();
switch (enabled) {
case true -> start();
case false -> stop();
}Boolean is not one of the wrapper classes named for ordinary switch selection. Casting it to boolean also leaves you with the same unsupported selector. Converting it to an allowed type can compile, but that conversion introduces semantics you must choose deliberately, especially if a nullable Boolean is involved.
The ordinary solution: if/else
For exactly two states, if/else states the intent directly and works across established Java releases:
if (enabled) {
enableFeature();
} else {
disableFeature();
}Use an independent if when the false path should do nothing:
Free tools Windows power users keep installed
One-click scans. No signup required.
if (enabled) {
refreshCache();
}When the branch produces a value, the conditional operator may be clearer than a switch conversion:
String mode = enabled ? "on" : "off";These forms preserve the boolean meaning without manufacturing numeric case values or relying on preview syntax.
When an enum is a better model than a boolean
A boolean is appropriate when there are genuinely only two states and the second state is simply the inverse of the first. Real domain logic often has more states hidden behind a boolean-looking flag: a job may be QUEUED, RUNNING, PAUSED, FAILED, or COMPLETE. In that situation, an enum makes the states explicit and gives ordinary switch code a supported selector:
enum JobState {
QUEUED, RUNNING, PAUSED, FAILED, COMPLETE
}
String message = switch (state) {
case QUEUED -> "waiting";
case RUNNING -> "in progress";
case PAUSED -> "paused";
case FAILED -> "failed";
case COMPLETE -> "complete";
};Do not convert a simple boolean to an enum merely to force a switch. The conversion is worthwhile when the domain already has named states, when more states are likely, or when each state has distinct behavior that would become difficult to read in nested conditions.
Converting a boolean to another selector: benefits and risks
You can map a boolean to an allowed selector such as an integer or string, but this is usually less readable than if/else:
int key = enabled ? 1 : 0;
switch (key) {
case 1 -> start();
case 0 -> stop();
default -> throw new AssertionError(key);
}The conversion adds an artificial representation and a possible maintenance trap: a later contributor may add another numeric value without understanding why it exists. If the original value can be null, decide explicitly whether null is an error, a third state, or a default. Do not let unboxing throw an exception accidentally or silently treat missing data as false.
What changes in the Java SE 26 preview
The Java SE 26 specification includes preview work titled “Primitive Types in Patterns, instanceof, and switch.” That is a release-specific preview feature, not a retroactive change to Java 17. Availability depends on the exact JDK build, the compiler’s preview configuration, and the runtime used to execute the class.
Rank #4
Under the preview rules, boolean selector details are addressed, so a preview-enabled Java 26 example may look conceptually like this:
String state = switch (flag) {
case true -> "enabled";
case false -> "disabled";
};Read that snippet as version-qualified syntax. It is not portable source for ordinary Java 8, 11, 17, or another release without the corresponding preview feature. Before using it, verify all of the following:
- The project targets the Java release that defines the preview behavior.
- The compiler is configured to enable preview language features for that release.
- The runtime invocation uses a compatible release and preview configuration.
- Your build, IDE, formatter, static-analysis tools, and CI environment understand the preview syntax.
- The feature has not changed between the preview specification and the final language rules.
Preview specifications can evolve or be withdrawn. A code review should therefore record the target JDK and the reason preview syntax is acceptable, rather than presenting a preview-only switch as a general Java technique.
The true/false/default restriction
The Java SE 26 preview text includes a specific restriction for boolean switch blocks: a block that names true, false, and default together is disallowed. Do not assume that every combination of those labels is valid simply because boolean selectors are recognized in the preview. In particular, adding a redundant default to a block that already lists both boolean constants violates that rule.
For a two-state preview example, use the form allowed by the exact preview specification and avoid adding labels “just in case.” If you need a fallback for a future or non-boolean value, revisit the selector type and the model instead of guessing at a permitted label combination.
Choosing an approach by project constraints
| Situation | Recommended construct | Reason |
|---|---|---|
| Two branches; compatibility with Java 17 or earlier ordinary rules is required | if/else |
Directly expresses a boolean decision and requires no conversion or preview feature. |
| One branch only matters | A single if |
Avoids an unnecessary false branch. |
| Several named domain states | An enum with an ordinary switch | Names the states and keeps cases readable. |
| Java SE 26 preview is deliberately enabled | Preview boolean switch, after verification | Uses the release-specific feature while accepting preview compatibility costs. |
| Boolean data is nullable or has an “unknown” meaning | Model the third state explicitly | Prevents accidental unboxing or loss of information. |
This is a readability and compatibility decision, not a benchmark ranking. The cited language specifications do not provide a performance contest between if, switch, and enum dispatch.
Best Value
Common mistakes and how to correct them
“Switch expressions allow any selector”
They do not. An expression produces a value, but its selector remains subject to the language version’s switch rules. Replace a boolean expression selector with if/else, or target a release whose documented preview rules actually support boolean selection.
“Boolean is a wrapper, so it should work like Integer”
The ordinary wrapper list is selective. Boolean is not included. Treat the specification’s list as closed for the target release rather than inferring support from Java’s boxing relationships.
“I can use numeric cases without consequences”
Mapping false and true to numbers can hide intent and creates a place for inconsistent mappings. Use it only when the numeric key is already part of the surrounding data model and its null behavior is explicit.
Do these 3 things before closing this tab:
1Fix the driver behind crashes, sound loss and screen glitches2Clear out junk files and repair common Windows errors3Scan for outdated or missing drivers - takes under a minute“A Java 26 example proves Java supports boolean switch everywhere”
A preview example proves only that the specified release may support the feature under its preview conditions. State the release and preview status in documentation and keep a non-preview alternative when your library or application supports older JDKs.
A practical checklist before committing code
- Identify the source and target JDK versions used by local development, CI, and production.
- Check whether the code uses an ordinary language rule or a preview feature.
- If the selector is
booleanorBooleanand the target is Java 17 ordinary syntax, replace the switch withif/else. - If the domain has more than two meaningful states, define an enum or another explicit model instead of encoding states as a flag.
- If converting a nullable
Boolean, decide how null is handled before unboxing or mapping it. - For a Java 26 preview build, verify compiler and runtime preview settings and check the current specification’s label restrictions.
- Document the chosen language level so a future maintainer does not mistake preview-only code for portable Java.
Bottom line for the “Boolean-Switch” question
For ordinary Java SE 17 code, a boolean selector is not legal in either a switch statement or a switch expression. Use if/else for a true/false decision, and use an enum when the underlying concept has several named states. Java SE 26’s primitive-pattern preview may permit boolean switch selectors under version-specific conditions, including a restriction on combining true, false, and default; treat that as preview-only until your exact JDK and build configuration confirm otherwise.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
