当参数中已提供字节数组对象时，为什么某些Java函数需要字节数组长度？

Question

While writing Java code, I really wonder why some functions require byte arrays length as an argument when the first argument was byte arrays object. Why they don't get the length from the object provided?

For example:

// E.g.: 1. Bitmap
byte[] bytes = task.getResult();
Bitmap bitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.length);    

// E.g.: 2. Datagram
byte[] data = new byte[1024];
DatagramPacket request = new DatagramPacket(data, data.length);

If they want the length, why they don't use data.length?

Answer 1

The byte array is a buffer to which data, the length of which is less than the length of the buffer, is read. The length parameter defines the amount of bytes in the buffer that are relevant. You're not supposed to pass the length of the buffer in the parameter, that would be redundant. You're supposed to pass the number of bytes in the buffer that contain actual data.

The API documentation of DatagramPacket, for example, reveals this.

length - the number of bytes to read

Answer 2

The simple answer is: most read methods (in Java, and any other language) that operate on buffer arrays have to tell you the exact number of bytes that were actually read.

Keep in mind: that array is an buffer. The default behavior is that buffer.length or less bytes can be read. So, knowing how long the buffer is doesn't help you. You have to know how many bytes were actually put into the buffer.

Answer 3

Broadly a buffer is used as a temporary data in a data loading processing.
You fill the buffer until its size or less but never more than its capacity of course.
The DatagramPacket javadoc confirms that :

The length argument must be less than or equal to buf.length.

And a thing that you don't have to forget : conceptually you use a buffer because the data has to be progressively loaded or only a specific part of that.
In some cases you will read as much data as its maximal capacity but in some other cases you need to read only the X first bytes or the bytes from X to Y offset.
So the buffer class methods provide generally multiple way to read from the buffer.
Such as :

public DatagramPacket(byte buf[], int length);
public DatagramPacket(byte buf[], int offset, int length);

Now conceptually you are not wrong, sometimes you want to fill the whole buffer because you know that you will need to read exactly this size of data. The java.net.DatagramSocket confirms that :

public synchronized void receive(DatagramPacket p) throws IOException {
...
   tmp = new DatagramPacket(new byte[1024], 1024);
...
}

So an additional overloading such as :

public DatagramPacket(byte buf[]);

would make sense.

Answer 4

Because the data that you want to read can be less than or equal to byte[] buf 's length.

Below is the API documentation :

public DatagramPacket(byte[] buf,
              int length)

Constructs a DatagramPacket for receiving packets of length length.

The length argument must be less than or equal to buf.length.

Parameters:
    buf - buffer for holding the incoming datagram.
    length - the number of bytes to read.

https://docs.oracle.com/javase/7/docs/api/java/net/DatagramPacket.html