Casting double[] to byte[] using stream in Java

Question

Hey I'm working on an app that uses Paho mqtt

Now I'm trying to cast the contents of a couple of objects to byte arrays so I can send them to the broker. There are a couple of different objects that all adhere to a abstract class, but the one I started with contains a double[]

Here's the function I'm trying to implement:

    @Override
public byte[] getBytes() {

    return Arrays.stream(driveVector).map(d -> Double.valueOf(d).byteValue()).toArray();
}

I thought this would work, but I get an error that the return value is a double[]

I think I either don't understand the map method or I'm goin about this all wrong in general (I looked at the ByteBuffer class, but it seems like a pain to implement this with it)

Thanks in advance

Are you trying to convert each `double` to a single `byte`, or to the 8 bytes that make it up? — Mureinik, May 20 '18 at 14:21
There is no ByteStream hence the `map` operation will yield a `DoubleStream` and therefore you're getting back a `double[]` when you call `toArray()` — Ousmane D., May 20 '18 at 14:28
*"or I'm goin about this all wrong in general"* You are. Don't use streams. A normal `for` loop of copying values from `double[]` to `byte[]` would do it, and run much faster too. — Andreas, May 20 '18 at 14:31
*"I don't understand the map method"* The [`map`](https://docs.oracle.com/javase/10/docs/api/java/util/stream/DoubleStream.html#map(java.util.function.DoubleUnaryOperator)) method of `DoubleStream` maps to another `DoubleStream`. You can use `mapToInt`, `mapToLong`, or `mapToObj` if you want a different type of stream, but there is no `mapToByte`. — Andreas, May 20 '18 at 14:35
Re-opened, since I don't think it's a duplicate of [In Java 8, is there a ByteStream class?](https://stackoverflow.com/q/32459683/5221149) — Andreas, May 20 '18 at 14:38
In any case, don't use `Double.valueOf(d).byteValue()`: simply use `(byte) d`, to avoid the unnecessary boxing. — Andy Turner, May 20 '18 at 14:39
@Mureinik Yes I was trying to get the 8 bytes that make it up — Typhaon, May 20 '18 at 15:18

Andy Turner · Answer 1 · 2018-05-20T16:06:48.153

You can't cast a double[] to a byte[] for the fundamental reason that they are unrelated types, and you can only cast between related types.

Casts in Java, unlike, say, C++, don't actually create a new object: they are merely a way to the compiler "I know more about the type of this object than you; trust me." For example, you might know that a variable of type Object actually holds a reference to a String, something which the compiler cannot know; in that case, you can cast the reference.

You can, however, construct a new array:

byte[] output = new byte[input.length];
for (int j = 0; j < input.length; j++) {
  output[j] = (byte) input[j];
}

There is no way to do this with streams. Or rather, there is, in that you could crowbar this code into a stream operation on a Stream<double[]>, say; but involving streams like that clearly adds no benefit.

score 1 · Accepted Answer · answered May 20 '18 at 15:00

1

You can use ByteBuffer for it:

double[] doubles = new double[] {1,2,3,4,5};
ByteBuffer buffer = ByteBuffer.allocate(doubles.length * Double.BYTES);
Arrays.stream(doubles).forEach(buffer::putDouble);
buffer.array();

answered May 20 '18 at 15:00

Nikita Ryanov

1,520
3
17
34

For some reason I was trying to avoid this, but thanks. I guess this is the best answer – Typhaon May 20 '18 at 15:19

score 0 · Answer 3 · answered May 20 '18 at 14:42

Java Streams is not the right tool here, especially not since there is no ByteStream in Java.

Your method can be implemented as a simple for loop.

@Override
public byte[] getBytes() {
    byte[] arr = new byte[driveVector.length];
    for (int i = 0; i < arr.length; i++)
        arr[i] = (byte) driveVector[i];
    return arr;
}

M. le Rutte · Answer 4 · 2018-05-20T15:25:27.090

In my MQTT application I read a single double value and post that to the broker. However, there is no real difference between a single and an array of doubles. The client needs to know the array length, while with a single value it always knows there is one.

I'm confident that you can adapt my code to writing multiple values, adapt the toMessage to write multiple double values.

public abstract class SensorMonitor {
  protected final MqttAsyncClient client;
  protected final String topic;
  protected final Logger logger = Logger.getLogger(getClass().getName()); 
  private final ByteArrayOutputStream byteOut = new ByteArrayOutputStream(8);
  private final DataOutputStream dataOut = new DataOutputStream(byteOut);

  public SensorMonitor(MqttAsyncClient mqttClient, String topic) {
    this.client = mqttClient;
    this.topic = topic;
  }

  public void start(ScheduledExecutorService service) {
    service.scheduleWithFixedDelay(this::publish, 0, 30, TimeUnit.SECONDS);
  }

  protected void publish() {
    try {
        MqttMessage message = toMessage(readNewValue());
        client.publish(topic, message);

    } catch (MqttException | IOException e) {
        logger.log(Level.SEVERE, "Could not publish message", e);
    }
  }

  private MqttMessage toMessage(double value) throws IOException {
    byteOut.reset();
    dataOut.writeDouble(value);
    return new MqttMessage(byteOut.toByteArray());
  }

  protected abstract double readNewValue();
}

The DataOutputStream.writeDouble uses Double.doubleToLongBits to create a IEEE 754 floating-point "double format" bit layout.

In my case I could pre-alloc and reuse the byteOut output stream as I knew upfront the needed size of the byte[].

Casting double[] to byte[] using stream in Java

4 Answers4