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?

CodePudding user response：

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."}

CodePudding user response：

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)

CodePudding user response：

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 UncheckedException.

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 UncheckedException. Also, the write method is tradesafe because it is synchronized method.