8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package java.io;
27
28 import java.util.Arrays;
29 import java.util.Objects;
30
31 /**
32 * This abstract class is the superclass of all classes representing
33 * an input stream of bytes.
34 *
35 * <p> Applications that need to define a subclass of <code>InputStream</code>
36 * must always provide a method that returns the next byte of input.
37 *
38 * @author Arthur van Hoff
39 * @see java.io.BufferedInputStream
40 * @see java.io.ByteArrayInputStream
41 * @see java.io.DataInputStream
42 * @see java.io.FilterInputStream
43 * @see java.io.InputStream#read()
44 * @see java.io.OutputStream
45 * @see java.io.PushbackInputStream
46 * @since 1.0
47 */
48 public abstract class InputStream implements Closeable {
212 *
213 * <p> The behavior for the case where the input stream is <i>asynchronously
214 * closed</i>, or the thread interrupted during the read, is highly input
215 * stream specific, and therefore not specified.
216 *
217 * <p> If an I/O error occurs reading from the input stream, then it may do
218 * so after some, but not all, bytes have been read. Consequently the input
219 * stream may not be at end of stream and may be in an inconsistent state.
220 * It is strongly recommended that the stream be promptly closed if an I/O
221 * error occurs.
222 *
223 * @return a byte array containing the bytes read from this input stream
224 * @throws IOException if an I/O error occurs
225 * @throws OutOfMemoryError if an array of the required size cannot be
226 * allocated. For example, if an array larger than {@code 2GB} would
227 * be required to store the bytes.
228 *
229 * @since 9
230 */
231 public byte[] readAllBytes() throws IOException {
232 byte[] buf = new byte[DEFAULT_BUFFER_SIZE];
233 int capacity = buf.length;
234 int nread = 0;
235 int n;
236 for (;;) {
237 // read to EOF which may read more or less than initial buffer size
238 while ((n = read(buf, nread, capacity - nread)) > 0)
239 nread += n;
240
241 // if the last call to read returned -1, then we're done
242 if (n < 0)
243 break;
244
245 // need to allocate a larger buffer
246 if (capacity <= MAX_BUFFER_SIZE - capacity) {
247 capacity = capacity << 1;
248 } else {
249 if (capacity == MAX_BUFFER_SIZE)
250 throw new OutOfMemoryError("Required array size too large");
251 capacity = MAX_BUFFER_SIZE;
252 }
253 buf = Arrays.copyOf(buf, capacity);
254 }
255 return (capacity == nread) ? buf : Arrays.copyOf(buf, nread);
256 }
257
258 /**
259 * Reads the requested number of bytes from the input stream into the given
260 * byte array. This method blocks until {@code len} bytes of input data have
261 * been read, end of stream is detected, or an exception is thrown. The
262 * number of bytes actually read, possibly zero, is returned. This method
263 * does not close the input stream.
264 *
265 * <p> In the case where end of stream is reached before {@code len} bytes
266 * have been read, then the actual number of bytes read will be returned.
267 * When this stream reaches end of stream, further invocations of this
268 * method will return zero.
269 *
270 * <p> If {@code len} is zero, then no bytes are read and {@code 0} is
271 * returned; otherwise, there is an attempt to read up to {@code len} bytes.
272 *
273 * <p> The first byte read is stored into element {@code b[off]}, the next
274 * one in to {@code b[off+1]}, and so on. The number of bytes read is, at
275 * most, equal to {@code len}. Let <i>k</i> be the number of bytes actually
|
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package java.io;
27
28 import java.util.ArrayList;
29 import java.util.Arrays;
30 import java.util.List;
31 import java.util.Objects;
32
33 /**
34 * This abstract class is the superclass of all classes representing
35 * an input stream of bytes.
36 *
37 * <p> Applications that need to define a subclass of <code>InputStream</code>
38 * must always provide a method that returns the next byte of input.
39 *
40 * @author Arthur van Hoff
41 * @see java.io.BufferedInputStream
42 * @see java.io.ByteArrayInputStream
43 * @see java.io.DataInputStream
44 * @see java.io.FilterInputStream
45 * @see java.io.InputStream#read()
46 * @see java.io.OutputStream
47 * @see java.io.PushbackInputStream
48 * @since 1.0
49 */
50 public abstract class InputStream implements Closeable {
214 *
215 * <p> The behavior for the case where the input stream is <i>asynchronously
216 * closed</i>, or the thread interrupted during the read, is highly input
217 * stream specific, and therefore not specified.
218 *
219 * <p> If an I/O error occurs reading from the input stream, then it may do
220 * so after some, but not all, bytes have been read. Consequently the input
221 * stream may not be at end of stream and may be in an inconsistent state.
222 * It is strongly recommended that the stream be promptly closed if an I/O
223 * error occurs.
224 *
225 * @return a byte array containing the bytes read from this input stream
226 * @throws IOException if an I/O error occurs
227 * @throws OutOfMemoryError if an array of the required size cannot be
228 * allocated. For example, if an array larger than {@code 2GB} would
229 * be required to store the bytes.
230 *
231 * @since 9
232 */
233 public byte[] readAllBytes() throws IOException {
234 List<byte[]> bufs = null;
235 byte[] result = null;
236 byte[] buf = new byte[DEFAULT_BUFFER_SIZE];
237 int total = 0;
238 int n;
239 do {
240 int nread = 0;
241
242 // read to EOF which may read more or less than buffer size
243 while ((n = read(buf, nread, buf.length - nread)) > 0) {
244 nread += n;
245 }
246
247 if (nread > 0) {
248 if (MAX_BUFFER_SIZE - total < nread) {
249 throw new OutOfMemoryError("Required array size too large");
250 }
251 total += nread;
252 byte[] copy;
253 if (nread == DEFAULT_BUFFER_SIZE) {
254 copy = buf;
255 if (n >= 0) {
256 buf = new byte[DEFAULT_BUFFER_SIZE];
257 }
258 } else {
259 copy = Arrays.copyOf(buf, nread);
260 }
261 if (result == null) {
262 result = copy;
263 } else {
264 if (bufs == null) {
265 bufs = new ArrayList<>();
266 bufs.add(result);
267 }
268 bufs.add(copy);
269 }
270 }
271 } while (n >= 0); // if the last call to read returned -1, then break
272
273 if (bufs == null) {
274 return result == null ? new byte[0] : result;
275 }
276
277 result = new byte[total];
278 int offset = 0;
279 for (byte[] b : bufs) {
280 System.arraycopy(b, 0, result, offset, b.length);
281 offset += b.length;
282 }
283
284 return result;
285 }
286
287 /**
288 * Reads the requested number of bytes from the input stream into the given
289 * byte array. This method blocks until {@code len} bytes of input data have
290 * been read, end of stream is detected, or an exception is thrown. The
291 * number of bytes actually read, possibly zero, is returned. This method
292 * does not close the input stream.
293 *
294 * <p> In the case where end of stream is reached before {@code len} bytes
295 * have been read, then the actual number of bytes read will be returned.
296 * When this stream reaches end of stream, further invocations of this
297 * method will return zero.
298 *
299 * <p> If {@code len} is zero, then no bytes are read and {@code 0} is
300 * returned; otherwise, there is an attempt to read up to {@code len} bytes.
301 *
302 * <p> The first byte read is stored into element {@code b[off]}, the next
303 * one in to {@code b[off+1]}, and so on. The number of bytes read is, at
304 * most, equal to {@code len}. Let <i>k</i> be the number of bytes actually
|