ByteSourceJsonBootstrapper uses CharBufferReader for byte[] inputs

src/main/java/com/fasterxml/jackson/core/io/CharBufferReader.java

@@ -0,0 +1,66 @@
+package com.fasterxml.jackson.core.io;
+
+import java.io.Reader;
+import java.nio.CharBuffer;
+
+public class CharBufferReader extends Reader {
+    private final CharBuffer charBuffer;
+
+    public CharBufferReader(CharBuffer buffer) {
+        this.charBuffer = buffer.duplicate();
+    }
+
+    @Override
+    public int read(char[] chars, int off, int len) {
+        int remaining = this.charBuffer.remaining();
+        if (remaining <= 0) {
+            return -1;
+        }
+        int length = Math.min(len, remaining);
+        this.charBuffer.get(chars, off, length);
+        return length;
+    }
+
+    @Override
+    public int read() {
+        if (this.charBuffer.hasRemaining()) {
+            return this.charBuffer.get();
+        }
+        return -1;
+    }
+
+    @Override
+    public long skip(long n) {
+        if (n < 0L) {
+            throw new IllegalArgumentException("number of characters to skip cannot be negative");
+        }
+        int skipped = Math.min((int) n, this.charBuffer.remaining());
+        this.charBuffer.position(this.charBuffer.position() + skipped);
+        return skipped;
+    }
+
+    @Override
+    public boolean ready() {
+        return true;
+    }
+
+    @Override
+    public boolean markSupported() {
+        return true;
+    }
+
+    @Override
+    public void mark(int readAheadLimit) {
+        this.charBuffer.mark();
+    }
+
+    @Override
+    public void reset() {
+        this.charBuffer.reset();
+    }
+
+    @Override
+    public void close() {
+        this.charBuffer.position(this.charBuffer.limit());
+    }
+}

src/main/java/com/fasterxml/jackson/core/json/ByteSourceJsonBootstrapper.java

@@ -1,6 +1,9 @@
 package com.fasterxml.jackson.core.json;
 
 import java.io.*;
+import java.nio.ByteBuffer;
+import java.nio.CharBuffer;
+import java.nio.charset.Charset;
 
 import com.fasterxml.jackson.core.*;
 import com.fasterxml.jackson.core.format.InputAccessor;
@@ -230,7 +233,9 @@ public Reader constructReader() throws IOException
                 InputStream in = _in;
 
                 if (in == null) {
-                    in = new ByteArrayInputStream(_inputBuffer, _inputPtr, _inputEnd);
+                    // [jackson-core#488] Avoid overhead of InputStreamReader allocating ByteBuffer
+                    ByteBuffer byteBuffer = ByteBuffer.wrap(_inputBuffer, _inputPtr, _inputEnd);
+                    return new CharBufferReader(Charset.forName(enc.getJavaName()).decode(byteBuffer));
                 } else {
                     /* Also, if we have any read but unused input (usually true),
                      * need to merge that input in:

src/test/java/com/fasterxml/jackson/core/io/CharBufferReaderTest.java

@@ -0,0 +1,103 @@
+package com.fasterxml.jackson.core.io;
+
+import java.io.IOException;
+import java.io.Reader;
+import java.nio.CharBuffer;
+import java.util.Arrays;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertThrows;
+
+public class CharBufferReaderTest extends com.fasterxml.jackson.core.BaseTest {
+
+    public void testSingleCharRead() throws IOException {
+        CharBuffer buffer = CharBuffer.wrap("aB\u00A0\u1AE9\uFFFC");
+        Reader charBufferReader = new CharBufferReader(buffer);
+        try (Reader reader = charBufferReader) {
+            assertEquals('a', reader.read());
+            assertEquals('B', reader.read());
+            assertEquals('\u00A0', reader.read());
+            assertEquals('\u1AE9', reader.read());
+            assertEquals('', reader.read());
+            assertEquals(-1, reader.read());
+        }
+        assertEquals(-1, charBufferReader.read());
+    }
+
+
+    public void testBulkRead() throws IOException {
+        CharBuffer buffer = CharBuffer.wrap("abcdefghijklmnopqrst\u00A0");
+        char[] chars = new char[12];
+        Reader charBufferReader = new CharBufferReader(buffer);
+        try (Reader reader = charBufferReader) {
+            assertEquals(12, reader.read(chars));
+            assertArrayEquals("abcdefghijkl".toCharArray(), chars);
+            assertEquals(9, reader.read(chars));
+            assertArrayEquals("mnopqrst\u00A0".toCharArray(), Arrays.copyOf(chars, 9));
+            assertEquals(-1, reader.read(chars));
+        }
+        assertEquals(-1, charBufferReader.read(chars));
+    }
+
+
+    public void testSkip() throws IOException {
+        CharBuffer buffer = CharBuffer.wrap("abcdefghijklmnopqrst\u00A0");
+        Reader charBufferReader = new CharBufferReader(buffer);
+        char[] chars = new char[12];
+        try (Reader reader = charBufferReader) {
+            assertEquals(12, reader.read(chars));
+            assertArrayEquals("abcdefghijkl".toCharArray(), chars);
+            assertEquals(4, reader.skip(4));
+            assertEquals(5, reader.read(chars, 3, 9));
+            assertArrayEquals("qrst\u00A0".toCharArray(), Arrays.copyOfRange(chars, 3, 8));
+            assertEquals(0, reader.skip(0));
+            assertEquals(0, reader.skip(1));
+        }
+        assertEquals(0, charBufferReader.skip(1));
+    }
+
+
+    public void testInvalidSkip() throws IOException {
+        try (Reader reader = new CharBufferReader(CharBuffer.wrap("test"))) {
+            IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> reader.skip(-1));
+            assertEquals("number of characters to skip cannot be negative", exception.getMessage());
+        }
+    }
+
+
+    public void testReady() throws IOException {
+        try (Reader reader = new CharBufferReader(CharBuffer.wrap("test"))) {
+            assertEquals(true, reader.ready());
+        }
+    }
+
+
+    public void testMarkReset() throws IOException {
+        char[] chars = new char[8];
+        try (Reader reader = new CharBufferReader(CharBuffer.wrap("test"))) {
+            assertEquals(true, reader.markSupported());
+            reader.mark(3);
+            assertEquals(3, reader.read(chars, 0, 3));
+            assertArrayEquals("tes".toCharArray(), Arrays.copyOf(chars, 3));
+            reader.reset();
+            assertEquals(4, reader.read(chars));
+            assertArrayEquals("test".toCharArray(), Arrays.copyOf(chars, 4));
+            reader.reset();
+            Arrays.fill(chars, '\0');
+            assertEquals(4, reader.read(chars));
+        }
+    }
+
+
+    public void testClose() throws IOException {
+        char[] chars = new char[2];
+        try (Reader reader = new CharBufferReader(CharBuffer.wrap("test"))) {
+            assertEquals(2, reader.read(chars));
+            assertArrayEquals("te".toCharArray(), chars);
+            reader.close();
+            Arrays.fill(chars, '\0');
+            assertEquals(-1, reader.read(chars));
+            assertArrayEquals("\0\0".toCharArray(), chars);
+        }
+    }
+}