What's the correct way to flip one bit in a byte while preserving the rest?

Question

[EDIT]

I realized that unfortunately I oversimplified the question and the answers aren't really helping me, so I'm rephraseing it...

So, my situation I have a stream of incoming bytes (sample) in which the ONLY bit that is potentially set is the first one (0000 | 0001).

So, let's say I get a sequence of these that looks like this:

0000,000**0**,
0000,000**1**,
0000,000**0**,
0000,000**1**,
0000,000**0**,
0000,000**0**,
0000,000**0**,
0000,000**0**

I'm setting the relevant bit to bold to make it clearer as to what I'm actually collecting.

So, as these 'bits' arrive I need to sort them into something that looks like this: 0000,1010

I'm doing this by shifting the existing value >> 1 and then adding the incoming value shifted over by << 7

byte aggregateByte = 0;
//loop 8 times as incoming samples arrive...
aggregateByte = (aggregateByte >> 1) + incomingSample << 7

This (*should) produce the correct result.

HOWEVER because java doesn't have the notion of an signed/insigned, EVERY time I shift, because I'm starting on the left hand side, if the previous incoming bit was 1, java PRESERVES the 1 since it sees this as the sign bit and never allows it to reset back to 0.

So... what I need to do prior to adding my incoming bit is to flip the first bit in the existing byte to 0 and then the incoming bit will be set to whatever it needs to be set to.

Currently I'm doing this by setting a mask of 0x7F and &ing that against the byte.

So, my actual addition looks like this: ((aggregateByte >> 1) & 0x7F ) + incomingSample << 7

0x7F creates a mask that looks like this: 0111,111 So, when I & this against the existing value, it flips the last bit to 0.

I guess my question is "am I reinventing the wheel, and is there a better way to handle this, or will this reliably work and is a relatively efficient way to handle this process?"

Read here: http://stackoverflow.com/questions/6351374/bitwise-operator-for-simply-flipping-all-bits-in-an-integer — PeterMmm, Aug 19 '13 at 16:04
The easiest and most readable way - use a BitSet class. Of course, not as efficient as manipulating a byte array directly. — Evgheni Crujcov, Aug 19 '13 at 16:09
You could just use a logical right shift ie `(aggregateByte >>> 1) | (incomingSample << 7)` — harold, Aug 19 '13 at 17:41
@harold, excellent suggestion! I had overlooked that operator. — Yevgeny Simkin, Aug 19 '13 at 17:54

score 4 · Accepted Answer · answered Aug 19 '13 at 16:03

4

Neither | nor & is for toggling bits. For that, you need to use ^. But 0x40 is indeed the correct value for flipping bit 6 ("7th" in your terms).

answered Aug 19 '13 at 16:03

C. K. Young

219,335
46
382
435

1

@Chris It may be "nicer" but `&` is definitely the wrong operator for the OP, where they need to turn a bit _on_. – C. K. Young Aug 19 '13 at 16:05
Yup! Just had a re-think. Answer has been deleted. – christopher Aug 19 '13 at 16:05
I edited my question because I realized that I oversimplified it. – Yevgeny Simkin Aug 19 '13 at 17:04
@Dr.Dredel As harold already mentioned, `>>>` is indeed the correct operator for your case. :-D – C. K. Young Aug 19 '13 at 21:20

score 3 · Answer 2 · answered Aug 19 '13 at 16:05

3

To flip bit 3:

 final int N = 3;
 b = (byte) (b ^ (1 << N));

answered Aug 19 '13 at 16:05

fred02138

3,323
1
14
17

What's the correct way to flip one bit in a byte while preserving the rest?

2 Answers2