Why did Java 11 add writeBytes​(byte[] b) method to the ByteArrayOutputStream class while the write​(byte[] b) method did the same?

Question

Oracle added writeBytes​(byte[] b) method to the ByteArrayOutputStream class since Java 11. This method takes a byte array and writes it to ByteArrayOutputStream . However, ByteArrayOutputStream extends OutputStream class that defines a write​(byte[] b) to do same thing. Why did Java need a new method to do that?

Answer 1

As noted by others, the benefit of the new method is that it isn't declared as throws IOException .

It was added in response to this issue JDK-8180410 "ByteArrayOutputStream should not throw IOExceptions" . The stated rationale in the issue is simply that it makes no sense ¹ to have to write a try ... catch for an exception that will never be thrown. That's it.

They (strictly) didn't need to add it. They added it as a convenience.

---

^{1 - As the reporter puts it: "It's contradictive."}

Answer 2

ByteArrayOutputStream.writeBytes doesn't throw the unnecessary IOException .

It's a new method specific to the byte array output stream, whereas the other options are inherited from OutputStream and are declared to throw the checked IOException (which is an unnecessary pain to handle if you know you're writing to a byte array output stream - you don't have a network connection to fail or similar)

Answer 3

Both method write bytes to outputstream. To compare them first we should look at their source code:

On the one hand in OutputStream class we have these 3 nested method to writing bytes:

  public void write(byte b[]) throws IOException {
       write(b, 0, b.length);
  }

  public void write(byte b[], int off, int len) throws IOException {
     Objects.checkFromIndexSize(off, len, b.length);
     for (int i = 0 ; i < len ; i++) {
         write(b[off + i]);
     }
  }
  public abstract void write(int b) throws IOException;

All above method throws IOException.

On the other hand writesByte method of ByteArrayOutputStream calls this method:

public void writeBytes(byte b[]) {
     write(b, 0, b.length);
}
public synchronized void write(byte b[], int off, int len) {
    Objects.checkFromIndexSize(off, len, b.length);
    ensureCapacity(count + len);
    System.arraycopy(b, off, buf, count, len);
    count += len;
}

These methods check byte array capacity before writing bytes, so they got rid of IOException. Also, the write method is trade safe because it is synchronized method.