Given that : 0000000000000000000000000000000000000000000000000000000000000001 = 1
What method would you use to determine if the the bit that represents 2^x is a 1 or 0 ?
+40
A:
I'd use:
if ((value & (1L << x)) != 0)
{
// The bit was set
}
(You may be able to get away with fewer brackets, but I never remember the precedence of bitwise operations.)
Jon Skeet
2009-07-07 13:42:54
you can remove the "!=0" because a non zero value is always true
ThibThib
2009-07-07 13:47:58
As a matter of curiosity: why did you prefer the left-shift of 1 versus the right-shifting of value?
Erich Mirabal
2009-07-07 13:50:03
That depends on the language. In java that isn't true.
harmanjd
2009-07-07 13:51:17
That should be 1L, or (1 << 32) ends up with the same value as (1 << 0)
Matt Kane
2009-07-07 13:52:24
"That depends on the language. In java that isn't true."You're right, I forgot that java was a strange language... ;-)
ThibThib
2009-07-07 13:55:08
@Erich: I find it mentally easier to think of varying the mask rather than varying the value. The problem is more easily described as "is bit x set to 1" than "is the value shifted right by x bits 1 in the least bit". Personal taste I guess. @Matt: Fixed, thanks.
Jon Skeet
2009-07-07 13:58:41
@ThibThib nothing strange about it. Please don't post stupid anti Java flame bait.
amischiefr
2009-07-07 14:04:25
ThibThib: s/strange/strongly typed/
Tom Hawtin - tackline
2009-07-07 14:13:33
Tom Hawtin - tackline
2009-07-07 14:16:15
@Tom: Yes, I was wondering much the same thing :)
Jon Skeet
2009-07-07 14:17:23
Paul Wagland
2010-01-27 13:45:33
+3
A:
For the nth LSB (least significant bit), the following should work:
bool isSet = (value & (1 << n)) != 0;
Noldorin
2009-07-07 13:43:46
That should be 1L, or (1 << 32) ends up with the same value as (1 << 0)
Matt Kane
2009-07-07 13:55:44
As Matt Kane said in identical solutions: That should be 1L, or (1 << 32) ends up with the same value as (1 << 0)
drvdijk
2009-07-07 13:59:58
+7
A:
You can also use
bool isSet = ((value>>x) & 1) != 0;
EDIT: the difference between "(value>>x) & 1" and "value & (1<<x)" relies on the behavior when x is greater than the size of the type of "value" (32 in your case).
In that particular case, with "(value>>x) & 1" you will have the sign of value, whereas you get a 0 with "value & (1<<x)" (it is sometimes useful to get the bit sign if x is too large).
If you prefer to have a 0 in that case, you can use the ">>>" operator, instead if ">>"
So, "((value>>>x) & 1) != 0" and "(value & (1<<x)) != 0" are completely equivalent
ThibThib
2009-07-07 13:46:24
+37
A:
Another alternative:
if (BigInteger.valueOf(value).testBit(x)) {
// ...
}
finnw
2009-07-07 14:05:00
Not a very good solution if this code is going to be called often. You're replacing a one-line alternative with a one line alternative, and the bit shifts really aren't that hard.
wds
2009-08-28 07:32:33
Length of line != readability of line, wds.You might be right that the previous solution is more efficient, but the difference is likely marginal, especially if testBit() gets inlined.
WCWedin
2009-08-29 16:05:01
It should be noted this solution allocates memory and is much less efficient than bitwise operators. Yes, it often doesn't matter, but sometimes it is important to avoid unnecessary GC and/or inefficient code (Android apps, in a game's main loop, etc).
NateS
2010-10-28 05:16:15
+6
A:
I wonder if:
if (((value >>> x) & 1) != 0) {
}
.. is better because it doesn't matter whether value is long or not, or if its worse because it's less obvious.
Tom Hawtin - tackline Jul 7 at 14:16
_ande_turner_
2009-07-15 10:26:53
I think it's better because there is less potential for errors - and if you think it isn't obvious, you can always extract the test into an appropriately named function (boolean isBitSet(long value, int x) or so)
hjhill
2009-08-26 08:30:00
+2
A:
You might want to check out BitSet: http://java.sun.com/javase/6/docs/api/java/util/BitSet.html
Yannick M.
2009-08-29 11:56:19