Parse Binary Data

Question

I have an application that receives data in binary form through Bluetooth. I read the data using inputstream from a bluetoothsocket to a byte[]. But I must parse all messages, because they must have a given format to be valid. All messages are in binary.

My solution was to convert the byte[] to a string and then split the string and parse all received messages.

An example of the data to parse: 0000000010000001

I should know that the first 8 zeros are the header and 10000001 the real data.

My idea was to create a string (from the byte[]) that represents -> 0000000010000001 using new String(byte[]) and then split the whole string in one byte and check the value, like:

string1 had 00000000 string2 had 10000001

I know that 8 zeros are the header, therefore string2 has the representation of the data.

My question is about the efficiency of this method. Is this the best method to do this in a mobile environment?

new String(byte[]) doesn't do "binary" 010101 strings, but interprets the byte[] as characters using the default encoding (ASCII, UTF-8, etc.): download.oracle.com/javase/6/docs/api/java/lang/… (link here because parser doesn't like [] in markup) — Philipp Reichart
– Philipp Reichart, Commented Sep 22, 2011 at 22:46

A.H. · Accepted Answer · 2011-09-23 20:56:02Z

2

String manipulation for parsing binary data is quite inefficient in terms of speed, memory consumption and also puts quite some burden on the garbage collector - because you always generate new string objects and forget them immediately.

In Java you have several choices to do it better:

DataInputStream: is a wrapper for an InputStream where you read bytes, shorts, longs, doubles, etc directly from the stream.
NIO using ByteBuffers and "derived" types like ShortBuffer... these are good for bulkd data transfers and also for binary parsing.

As long as your data is byte-aligned, these are easy ways to go. If that's not the case - well, then better learn how to do bit-manipulation using operators like &, |, ~, <<, >>.

My suggestion is that you stick to DataInputStream as long as possible.

answered Sep 23, 2011 at 20:56

A.H.

66.8k16 gold badges97 silver badges132 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Igor Maznitsa · Accepted Answer · 2016-01-11 13:20:37Z

1

just FYI, there is free OSS library called Java Binary Block Parser (JBBP), it is compatible with Android (2.1+) and it allows just describe structure of data in text format and automatically parse data stream (or array), if you want to parse whole stream to bits then it can be executed in single string

byte [] parsedBits = JBBPParser.prepare("bit:1 [_];").parse(new byte[]{1,2,3,4,5}).findFieldForType(JBBPFieldArrayBit.class).getArray();

answered Jan 11, 2016 at 13:20

Igor Maznitsa

8637 silver badges12 bronze badges

1 Comment

user218046 Over a year ago

That's what I've been looking for ma man :)

Philipp Reichart · Accepted Answer · 2011-09-22 22:42:07Z

0

Strings are the least efficient way to do this indeed.

If your binary 0000000010000001 is actually byte[] {0, 0, 0, 0, 2, 0, 0, 1} in decimal, then just check if b[0] == b[1] == b[3] == b[4] == 0.

Edit: Ignore the "in decimal" part, it's irrelevant as long as you only want to check the if your array begins with 00000000 (i.e. 4 zero bytes)

answered Sep 22, 2011 at 22:42

Philipp Reichart

21k6 gold badges61 silver badges66 bronze badges

Comments

blackgreen · Accepted Answer · 2022-12-28 22:39:13Z

It is a very low efficiency way, and is not recommended. To parse binary data, we should have the protocol, and always use bit operation. If you are not fimiliar with that,

FastProto is a better choice, what you need to do is annotating the fileds of the data object, FastProto would help you complete all.

Imagine the binary data has fixed length of 20 bytes:

65 00 7F 69 3D 84 7A 01 00 00 55 00 F1 FF 0D 00 00 00 07 00

The binary data contains 3 different types of signals, the specific protocol is as follows:

Byte Offset	Data Type(C/C++)	Signal Name	Unit
0	unsigned char	device id
2-9	long	time	ms
12-13	short	temperature	℃

import org.indunet.fastproto.annotation.*;

public class Weather {
    @UInt8Type(offset = 0)
    int id;

    @TimeType(offset = 2)
    Timestamp time;

    @Int16Type(offset = 12)
    int temperature;
}

byte[] bytes= ...   // binary need parsing

Weather weather = FastProto.parse(datagram, Weather.class);

Maybe you have noticed that FastProto describes the field information in binary data through annotations, which is very simple and efficient.

Collectives™ on Stack Overflow

Parse Binary Data

4 Answers 4

Comments

1 Comment

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

Comments

1 Comment

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related