Hi is something like this possible in Java?
boolean flag = true;
if(flag) return flag = false; // return true and assign false to flag afterwards
To clarify. The above works, but is assigns false first. Want I want to achieve is to return the flag as soon as its true and reset it to false afterwards.
The structure looks something like this:
boolean flag = false;
// some operations which can set the flag true
if(flag){ flag = false ; return true};
// some operations which can set the flag true
if(flag){ flag = false ; return true};
// some operations which can set the flag true
if(flag){ flag = false ; return true};
I was thinking about to do it in one go by return flag = false;
No, there's nothing built-in that does what you describe. You'd do it with a temporary variable:
boolean flag = true;
boolean returnValue = flag;
flag = false;
return returnValue;
Or based on your further edit to the question ("The structure looks something like this"), you can use !:
boolean flag = false;
// some operations which can set the flag true
if(flag) return !(flag = false);
// some operations which can set the flag true
if(flag) return !(flag = false);
// some operations which can set the flag true
if(flag) return !(flag = false);
I really, really would not do that. It's unnecessarily obtuse.
Have a look at java.util.concurrent.AtomicBoolean. I haven't tried this, but it might give the behavior you're asking about:
AtomicBoolean flag = new AtomicBoolean(true);
System.out.println("First, I'm " + flag.get());
Boolean was = flag.getAndSet(false);
System.out.println("I was " + was + " but now I'm " +
Flag.get());
No, there isn't a way to do that.
Why not?
Well you would need to ask the Java language designers for the real answer, but I imagine that they would have dismissed such a proposal out of hand. Java is designed to be a language that is easy to learn, read and understand. Adding operators that are designed to do "clever" things in a concise way is liable to make the language harder to learn, and harder to read ... for the average programmer. And, if the operator is only really useful in a tiny number of use-cases, that makes the readability versus utility argument even harder to win.
Also, adding new features to Java is often more technically difficult than you would imagine because of interactions with other (existing) language features.
And actually, there is precedent to back this up. One of the Java 7 / 8 revision proposals in Project Coin was to add an elvis operator to Java. The proposal was considered ... and ultimately dismissed.
