Java 为什么在写入字节数组时ObjectOutputStream.writeObject比写入字节快？

我做了一个小的基准测试，发现

ObjectOutputStream.writeObject

比

ObjectOutputStream.write（byte[]bytes）

快，但我似乎找不到可能的解释，因为在幕后，

writeObject

将间接调用

ObjectOutputStream.write（byte[]bytes）

测试代码

publicstaticvoidmain（字符串[]args）引发异常{
字节[]字节=新字节[10000]；
对于（int i=0；i<10000；++i）{
字节[i]=（字节）（i%256）；
}
ByteArrayOutputStream out2=新建ByteArrayOutputStream（）；
try（ObjectOutputStream ostream2=新的ObjectOutputStream（out2））{
对于（int i=0；i<10000；++i）{
ostream2.writeInt（字节.长度）；
ostream2.write（字节，0，字节.长度）；
}
out2.reset（）；
长启动=System.nanoTime（）；
对于（int i=0；i<10000；++i）{
ostream2.writeInt（字节.长度）；
ostream2.write（字节，0，字节.长度）；
}
long end=System.nanoTime（）；
System.out.println（“write byte[]take:”+（（end-start）/1000）+“micros”）；
}
ByteArrayOutputStream out=新建ByteArrayOutputStream（）；
try（ObjectOutputStream ostream=newobjectoutputstream（out））{
对于（int i=0；i<10000；++i）{
ostream.writeObject（字节）；
}
out.reset（）；
长启动=System.nanoTime（）；
对于（int i=0；i<10000；++i）{
ostream.writeObject（字节）；
}
long end=System.nanoTime（）；
System.out.println（“writeObject take:”+（（结束-开始）/1000）+“micros”）；
}
}

输出

写入字节[]花费：15445微秒

写入对象：3111微秒

---

ObjectOutputStream.writeObject（）

保存写入的对象。如果您已经编写了该对象，它将只向同一对象写入句柄，而不是整个对象。

我对您的代码做了一些修改：

public class Test {

  public static final int REPS = 10000;

  public static void main(String argv[]) throws IOException {
    ByteArrayOutputStream out2 = new ByteArrayOutputStream();
    try (ObjectOutputStream ostream2 = new ObjectOutputStream(out2)) {
      writeBytes(ostream2);
      out2.reset();
      long start = System.nanoTime();
      writeBytes(ostream2);
      long end = System.nanoTime();
      System.out.println("write byte[] took: " + ((end - start) / 1000) + " micros");
    }

    ByteArrayOutputStream out = new ByteArrayOutputStream();
    try (ObjectOutputStream ostream = new ObjectOutputStream(out)) {
      writeObject(ostream);
      out.reset();
      long start = System.nanoTime();
      writeObject(ostream);
      long end = System.nanoTime();
      System.out.println("writeObject took: " + ((end - start) / 1000) + " micros");
    }
  }

  private static void writeObject(ObjectOutputStream ostream) throws IOException {
    for (int i = 0; i < REPS; ++i) {
      final byte[] bytes = bytes();
      ostream.writeObject(bytes);
    }
  }

  private static void writeBytes(ObjectOutputStream ostream2) throws IOException {
    for (int i = 0; i < REPS; ++i) {
      final byte[] bytes = bytes();
      ostream2.writeInt(bytes.length);
      ostream2.write(bytes, 0, bytes.length);
    }
  }

  static byte[] bytes() {
    byte[] bytes = new byte[REPS];
    for (int i = 0; i < REPS; ++i) {
      bytes[i] = (byte) i;
    }
    return bytes;
  }
}

---

事实上，你是对的。我每次都会替换代码以拥有一个新的数组，写入字节数组现在比writeObject快。我完全忘记了WriteObject所做的缓存。谢谢你的回答。事实上，我完全忘记了writeObject中的缓存机制

public class Test {

  public static final int REPS = 10000;

  public static void main(String argv[]) throws IOException {
    ByteArrayOutputStream out2 = new ByteArrayOutputStream();
    try (ObjectOutputStream ostream2 = new ObjectOutputStream(out2)) {
      writeBytes(ostream2);
      out2.reset();
      long start = System.nanoTime();
      writeBytes(ostream2);
      long end = System.nanoTime();
      System.out.println("write byte[] took: " + ((end - start) / 1000) + " micros");
    }

    ByteArrayOutputStream out = new ByteArrayOutputStream();
    try (ObjectOutputStream ostream = new ObjectOutputStream(out)) {
      writeObject(ostream);
      out.reset();
      long start = System.nanoTime();
      writeObject(ostream);
      long end = System.nanoTime();
      System.out.println("writeObject took: " + ((end - start) / 1000) + " micros");
    }
  }

  private static void writeObject(ObjectOutputStream ostream) throws IOException {
    for (int i = 0; i < REPS; ++i) {
      final byte[] bytes = bytes();
      ostream.writeObject(bytes);
    }
  }

  private static void writeBytes(ObjectOutputStream ostream2) throws IOException {
    for (int i = 0; i < REPS; ++i) {
      final byte[] bytes = bytes();
      ostream2.writeInt(bytes.length);
      ostream2.write(bytes, 0, bytes.length);
    }
  }

  static byte[] bytes() {
    byte[] bytes = new byte[REPS];
    for (int i = 0; i < REPS; ++i) {
      bytes[i] = (byte) i;
    }
    return bytes;
  }
}

write byte[] took: 51697 micros
writeObject took: 57203 micros