I'm sure there are better examples than mine:)
Let's say that it's snowing and the users can earn points for each snowflake, but they have to do it fast to no get stuck in the snow, so this is my ex:
class apples{
public static void main(String args[]){
int points;
points = 1;
switch (points){
case 1:
System.out.println("32");
break;
case 2:
System.out.println("Almost half");
break;
case 3:
System.out.println("You're near");
break;
case 4:
System.out.println("Congratulations., You got 100 points");
default:
System.out.println("Want to start again?");
break;
}
}
}
The switch statement has been miss-used for a long time.
The original idea was to have an entry point system; a goto-like statement which worked like this :
If my value is 1; goto 1;
Else If my value is 2; goto 2;
Else If my value is 3; goto 3;
Else If goto default;
label 1 : ...;
label 2 : ...;
label 3 : ...;
label default : ...;
And people started to like this system and decided that it would be better than having a lot of if/else statements. So they used a little trick, the break; And now people really enjoy the switch as a replacement of the if/else by breaking every case of the switch.
To have a really good example of the original switch statement, you should have something like this:
public void printDaysLeftUntilNextMonday(){
switch(dayOfWeek){
case 1 :
System.out.println("Monday");
case 2 :
System.out.println("Tuesday");
case 3 :
System.out.println("Wednesday");
case 4 :
System.out.println("Thursday");
case 5 :
System.out.println("Friday");
case 6 :
System.out.println("Saturday");
case 7 :
System.out.println("Sunday");
}
}
I had a real use case on day (rare thing if you don't abuse of break; in switch) it was in a Hangman.
public void printHangman(){
switch(triesLeft){
case 1 :
printLeftLeg();
case 2 :
printRightLeg();
case 3 :
printLeftArm();
case 4 :
printRightArm();
case 5 :
printBody();
case 6 :
printHead();
}
}
If you want to have more flexibility than a HashMap (not that there's anything wrong with the solution), you can go with a chain of responsibility :
class PointScore {
private PointScore next;
private int points;
private String msg;
public PointScore(int points, String msg) {
this.points = points;
this.msg = msg;
this.next = null;
}
public PointScore setNext(PointScore next) {
this.next = next;
return next;
}
public boolean checkScore(int points) {
if (this.points == points) {
System.out.println(this.msg);
return true;
} else if (null != next) {
return next.checkScore(points);
} else {
return false;
}
}
}
Then your main entry point :
class Apples {
public static void main(String...args) {
int points;
points = 1;
// set first condition (highest priority first)
PointScore scores = new PointScore(4, "Congratulations., You got 100 points");
// set next chain members in order or priority (highest to lowest)
scores.setNext(new PointScore(3, "You're near"))
.setNext(new PointScore(2, "Almost half"))
.setNext(new PointScore(1, "32"));
if (!scores.checkScore(points)) {
System.out.println("Want to start again?");
}
}
}
This doesn't look much, but the checkScore method can perform other checks; for example, you could setup a range of values instead of a single points integer, etc.
Use a dictionary or a hashmap to map the number of points to the string.
I find switch statements make most sense when the range of a variable is bounded. So for example the days-of-the-week example given here is fine, and the one with the enum is even better.
Bit of a no-brainer, but wikipedia has an excellent page with the history, advantages and disadvantages of the switch statement, as well as a host of examples in different languages.
Okay here we go. At work we often use enum types, simple example:
public enum Colors {
RED,
GREEN,
BLUE,
YELLOW,
VIOLET,
BROWN,
ORANGE; // more to come
}
so we can switch over these literal constants:
public String colorToMood(final Colors color) {
String mood = "everything the same to me";
switch (color) {
case RED:
mood = "excited";
break;
case YELLOW:
mood = "I like the sun";
break;
case GREEN:
mood = "forests are nice";
break;
case BLUE:
mood = "I feel free like a bird in the sky";
break;
// fill in your code here for VIOLET, BROWN, ORANGE
// otherwise they get handled by the default clause
default:
mood = "I don't know your color";
break;
}
return mood;
}
Maybe you now get a better idea what the benefits of a switch in conjunction with enums are. You can even define a constructor for your enum constants, but that gets too advanced...
Related
I have different fields using the same parameters i.e. same grading scale. I want to use switch statement to return grades for different fields using the same scale. Something like this. I thought that there was something like this: switch (attend, job, initiative) { that would combine the three variables.
int attend = 5;
int job = 5;
int initiative = 5;
switch (attend) {
case 1:
getattendo = 5;
break;
case 2:
getattendo = 4;
break;
case 3:
getattendo = 3;
break;
case 4:
getattendo = 2;
case 5:
getattendo = 1;
break;
default:
getattendo = 0; // null
}
Your help is appreciated.
fmk
Enum works well with switch cases. So, you can define an enum that represents your range of value of it is a finite and reasonable range of values :
public enum OPTIONS {
OPTION1(5, 5, 5),
OPTION2(5, 2, 4),
OPTION3(1, 2, 3),
OPTION4(4, 4, 1);
private final int attend;
private final int jobs;
private final int initiative;
Directive(int attend, int jobs, int initiative) {
this.attend = attend;
this.jobs = jobs;
this.initiative = initiative;
}
// ... optional setters & getters
}
Given your create OPTION Enum, you can use a switch to handle the different cases :
switch (OPTION) {
case OPTION1:
getattendo = 5;
break;
case OPTION2:
getattendo = 4;
break;
case OPTION3:
getattendo = 3;
break;
case OPTION4:
getattendo = 2;
break;
default:
getattendo = 0; // null
break;
}
Note: Your switch is legitimate only if you have a finite number of condition. Otherwise, use a method to calculate your result.
A trick you use utilizes the unary or operation for checking binary digit presence.
This will help get you started on switching according to various conditions.
This is similar to how file permissions work in Linux.
public class ScoreCombinator {
public static final int ATTEND = 1; // binary: 001
public static final int JOB = 2; // binary: 010
public static final int INITIATIVE = 4; // binary: 100
public static void main(String[] args) {
evaluate(ATTEND | INITIATIVE); // Attend and Initiative
evaluate(INITIATIVE | ATTEND | JOB); // Attend, Job, and Initiative
}
private static void evaluate(int value) {
switch (value) {
case ATTEND: {
System.out.println("Attend");
break;
}
case ATTEND | JOB: {
System.out.println("Attend and Job");
break;
}
case ATTEND | JOB | INITIATIVE: {
System.out.println("Attend, Job, and Initiative");
break;
}
case ATTEND | INITIATIVE: {
System.out.println("Attend and Initiative");
break;
}
case JOB: {
System.out.println("Job");
break;
}
case JOB | INITIATIVE: {
System.out.println("Job and Initiative");
break;
}
case INITIATIVE: {
System.out.println("Initiative");
break;
}
}
}
}
Something like switch(a,b,c) is not possible.
If all values are the same, just use one of the valueslandmaybe verify that all values are the same).
However, there are workarounds if you want to switch-case with multiple numbers:
mathematical solution
For example, you could use prime numbers for this. As you only want to switch numbers, this is possible as long as there is a prime number higher than the highest expected value(for attend, prime and job).
Instead of switch(attend, job, initiative), you use switch((attend*prime+job)*prime+initiative) and instead of case (exampleAttend, exampleJob, exampleInitiative):, you use case ((exampleAttend*prime+exampleJob)*prime+exampleInitiative):
Note that prime must be the same in the switch and case statements.
Note that you should test if any of the input numbers is higher than the prime. This would logically lead to the default case but it could lead to collissions.
You may also want to make sure that the prime to the forth power is lower than the max value of the data type or there may be overflows.
On the other side, this method should be more performant than the second.
simple string concadation
Another option is to work with strings. As the string representation of a number is unique (to the number) and it does not contain some characters (like spaces), you can concadate those numbers and use such a character to seperate them.
Instead of switch(attend, job, initiative), you use switch(attend+" "+job+" "+initiative) and instead of case (exampleAttend,exampleJob,exampleInitiative):, you use case (exampleAttend+" "+exampleJob+" "+exampleInitiative):.
This is obviously easier and fail-safer than the first method involving prime numbers but there should be a performance impact as concadating strings is slower than multiplying ints.
Another possibility is to use enums. Look at the other answer by #Hassam Abdelillah
if you want to know how this works. If you like the enum approach, feel free to upvote the other answer.
I have a variable, x.
I want to call a method m() only if x is one of two possible values.
When calling m(), I want to pass an argument to it, whose value depends on the value of x.
Is there a way to do this in Java without checking the value of x more than once, and calling/writing m() in one place only (i.e. not in multiple branches of an if statement)?
One solution I'm entertaining:
switch (x) {
case 1:
y = "foo";
break;
case 2:
y = "bar";
break;
default:
y = null;
break;
}
if (y != null) m(y);
But I can't help but feel this is technically checking x twice, just obscuring this fact by adding a "proxy" for the second check.
(To clarify why the constraints are what they are: when reading code, I have a hard time understanding logic that branches a lot when there is a high degree of duplication between branches - it becomes a game of "spot the difference" rather than simply being able to see what is happening. I prefer to aggressively refactor such duplication away, which is a habit that serves me well in Ruby, JS, and other languages; I'm hoping I can learn to do the same for Java and make code easier for me and others to understand at a glance.)
I'm not sure of what you want to do, but you can maybe use a Map to get the 'y' parameter from 'x'
Map<Integer, String> map = new HashMap<>();
map.put(1, "foo");
map.put(2, "bar");
if (map.containsKey(x)) {
m(map.get(x));
}
Use "goto" or equivalent:
void do_m_if_appropriate() {
// x and y are assumed to be eg. member variables
switch (x) {
case 1:
y = "foo";
break;
case 2:
y = "bar";
break;
default:
return; // this is the "goto equivalent" part
}
m(y);
}
Above is pretty elegant. If necessary, it's also trivial to change it to return true or false depending on if it called m(), or just y or null.
You can also do tricks with loop constructs, though some might say this is abuse of the loop construct, and you should comment it accordingly:
do { // note: not a real loop, used to skip call to m()
switch (x) {
case 1:
y = "foo";
break;
case 2:
y = "bar";
break;
default:
continue; // "goto equivalent" part
}
m(y);
} while(false);
Here's a solution with Optionals (my Java syntax might be slightly incorrect). Note that to you, the code looks like so, but implementation wise, it's similar to the example you posted (i.e. checks whether y is an exceptional value).
switch (x) {
case 1:
y = Optional<String>.of("foo");
break;
case 2:
y = Optional<String>.of("bar");
break;
default:
y = Optional<String>.empty();
break;
}
y.map((m's class)::m);
result = y.orElse( <value result should take if x was invalid> );
Actually it may be better to modify m() to return an Optional and just return empty if y is not valid, but I assume you want to do this check caller-side.
Why not
switch (x) {
case 1:
y = "foo";
m(y);
break;
case 2:
y = "bar";
m(y);
break;
}
I am making a poker game and to generate a hand that contains non-duplicated I decided to use a HashSet and for-loop to give the player 5 cards.
public class CardDriver {
public static void main(String[] args) {
Set<Card> hands = new HashSet<Card>();
while(hands.size()!= 5) {
hands.add(new Card());
}
System.out.println("Player 1: " + hands);
}
}
The Card constructor:
public Card() {
Random nb = new Random();
int switchNb = nb.nextInt(13) + 1;
switch(switchNb)
{
case 1: value = Value.Ace; break;
case 2: value = Value.Two; break;
....
case 11: value = Value.Jack; break;
case 12: value = Value.Queen; break;
case 13: value = Value.King; break;
}
switchNb = nb.nextInt(4) + 1;
switch(switchNb)
{
case 1: suite = Suite.Hearts; break;
case 2: suite = Suite.Diamonds; break;
case 3: suite = Suite.Clubs; break;
case 4: suite = Suite.Spades; break;
}
}
I am faced with three problems and I believe that both can be solved once I figure out how to isolate certain elements (if it is even possible) from the player's hand.
First off I need to use the same HashSet to give 5 more cards to the second player and so on. For example I would have elements 1-5 of the Set go to player 1 and 6-10 go to player 2.
Also, by being able to isolate a card from the set, it would also enable me to replace a card (video poker).
Lastly, I figured that by being able to isolate each card in the user's hand, it would make it easier for me to analyze the value of the hand each player has. I am not very experience when it comes to using sets so perhaps it would be better to use an array?
Edit: Example of an output:
Player 1: [Three of Hearts, King of Clubs, Ten of Clubs, Two of Spades, Ace of Hearts]
I have a chunk of code that needs to determine if a given integer is between a set of other integers. I'd also like to have this in a case statement so as to not have a surplus of if..else statements everywhere. Here's a bit of the code:
switch (copies) {
case copies >= 0 && copies <= 99: copyPrice = 0.30; break;
case copies >= 100 && copies <= 499: copyPrice = 0.28; break;
case copies >= 500 && copies <= 749: copyPrice = 0.27; break;
case copies >= 750 && copies <= 1000: copyPrice = 0.26; break;
case copies > 1000: copies = 0.25; break;
}
where copies is an integer and copyPrice is a double. I get several errors saying that it expects to receive a integer but gets a boolean instead. What is the best (or optimal) way of setting this up? Any help is greatly appreciated!
This line (and similar):
case copies >= 0 && copies <= 99:
Returns a compiler error since it gives a boolean but the compiler expects an int since copy is declared as int.
One way to solve this is using an array with the desired ranks, and have a switch statement for the index found:
public double calculateCopyPrice(int copies) {
int[] range = { 99, 499, 749, 1000 };
double copyPrice = 0;
int index = -1;
for (int i = 0; i < range.length; i++) {
if (range[i] >= copies) {
index = i;
break;
}
}
switch (index) {
case 0: copyPrice = 0.30; break;
case 1: copyPrice = 0.28; break;
case 2: copyPrice = 0.27; break;
case 3: copyPrice = 0.26; break;
default: copyPrice = 0.25; break;
}
//probably more logic here...
return copyPrice;
}
After some tests, I've found a more flexible solution using a TreeMap<Integer, Double> which allows you to have a specie of range (what you're looking for) and ease the search by using TreeMap#ceilingEntry:
//TreeMap to store the "ranges"
TreeMap<Integer, Double> theMap = new TreeMap<Integer, Double>();
//add the data
theMap.put(99, 0.3);
theMap.put(499, 0.28);
theMap.put(749, 0.27);
theMap.put(1000, 0.26);
//the "default" value for max entries
theMap.put(Integer.MAX_VALUE, 0.25);
//testing the solution
Double ex1 = theMap.ceilingEntry(50).getValue();
Double ex2 = theMap.ceilingEntry(500).getValue();
Double ex3 = theMap.ceilingEntry(5000).getValue();
Double ex4 = theMap.ceilingEntry(100).getValue();
System.out.println(ex1);
System.out.println(ex2);
System.out.println(ex3);
System.out.println(ex4);
java has no native concept of "ranges", let alone support for them in case statements.
usually, when faced with this kind of logic i personally would do one of 2 things:
just have a chain of if-else statements. doesnt even habe to be a chain:
public static double calculateCopyPrice(int copies) {
if (copies > 1000) return 0.25;
if (copies >= 750) return 0.26;
//etc
}
this code has no "else" branches and is just as much typing as the switch syntax you'd like. possibly even less (i only check a single bound every time)
you could use an enum, say:
public enum Division {UNDER_100, 100_to_500, ... }
and then :
Division division = categorize(copies);
switch (division) {
case UNDER_100:
//etc
}
but this is serious overkill for what youre trying to do. i'd use that if this division is also useful elsewhere in your code.
Switch case function must have an exact number in case. For example:
case 0:
case 1:
You're trying to use case from some value to some value and it's not implemented that way in Java. For your problem, you must use if-else statement since it's impossible to do it with switch case. Hope it helped.
Look the problem is very basic..
In a switch statement it allows only the following datatypes and wrapper classes
Byte,short,char,int,Byte,Short,Character,Integer,enum,String..
If you are passing anything other than that will give you an error.
In your case the condition which you are evaluating will give you result which is a Boolean value.
NavigableMap.seilingEntry() may be a good solution in many cases,
but in other cases the following may be clearer:
double getPrice(int copies){
return copies>1000 ? 0.25
: copies>750 ? 0.26
: copies>500 ? 0.27
: copies>100 ? 0.28
: copies>0 ? 0.30
: 0; // or check this condition first, throwing an exception
}
I'm porting some old code that uses the int enum pattern to Enum and EnumSet. It is very easy but I don't know how translate the following code to EnumSet: :
int mask = (kind == 'C' ? CLASS_MODIFIERS
: kind == 'F' ? FIELD_MODIFIERS
: kind == 'M' ? METHOD_MODIFIERS
: (CLASS_MODIFIERS | FIELD_MODIFIERS | METHOD_MODIFIERS));
int bad_flags = flags & ~mask; // <--- this
flags &= mask; // <--- and this
~mask is simple as typing EnumSet.complementOf but I don't see how do &.
You want to use the Set method retainAll to get the intersection of two sets:
public class Test {
public enum Kind { CLASS, FIELD, METHOD }
public void applyMask(char kind, EnumSet<Kind> flags) {
final EnumSet<Kind> mask;
switch (kind) {
case 'C': mask = EnumSet.of(Kind.CLASS); break;
case 'F': mask = EnumSet.of(Kind.FIELD); break;
case 'M': mask = EnumSet.of(Kind.METHOD); break;
default: mask = EnumSet.allOf(Kind.class); break;
}
EnumSet<Kind> badFlags = EnumSet.copyOf(flags);
badFlags.removeAll(mask); // See note below
flags.retainAll(mask);
}
}
Note: I previously had the following line in place of the simpler removeAll. Tom Hawtin pointed out that removeAll is simpler and achieves the same end. Originally, I just copied the OP's original logic as closely as possible, without trying to optimize.
badFlags.retainAll(EnumSet.complementOf(mask));
CLASS_MODIFIERS, FIELD_MODIFIERS, and METHOD_MODIFIERS might be appropriate to leave as constants, since they are being used as bit masks. The link might help to clarify the point of this code.