PipedInputStream

Overview | Package | Class | Use | Tree | Deprecated | Index | Help

PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## java.io
Class PipedInputStream

    java.lang.Object
      java.io.InputStream
          java.io.PipedInputStream

    public class PipedInputStream

extends InputStream

A piped input stream should be connected to a piped output stream; the piped input stream then provides whatever data bytes are written to the piped output stream. Typically, data is read from a `PipedInputStream` object by one thread and data is written to the corresponding `PipedOutputStream` by some other thread. Attempting to use both objects from a single thread is not recommended, as it may deadlock the thread. The piped input stream contains a buffer, decoupling read operations from write operations, within limits.

Since:
  JDK1.0
Version:
  1.30, 02/02/00
Author:
  James Gosling
See Also:
  `PipedOutputStream`

Constructor Summary
`PipedInputStream()` Creates a `PipedInputStream` so that it is not yet connected.
`PipedInputStream(PipedOutputStream src)` Creates a `PipedInputStream` so that it is connected to the piped output stream `src`.

Method Summary
`int` | `available()` Returns the number of bytes that can be read from this input stream without blocking.
`void` | `close()` Closes this piped input stream and releases any system resources associated with the stream.
`void` | `connect(PipedOutputStream src)` Causes this piped input stream to be connected to the piped output stream `src`.
`int` | `read()` Reads the next byte of data from this piped input stream.
`int` | `read(byte[] b, int off, int len)` Reads up to `len` bytes of data from this piped input stream into an array of bytes.

Methods inherited from class java.io.InputStream
`mark, markSupported, read, reset, skip`

Methods inherited from class java.lang.Object
`equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### PipedInputStream

    public PipedInputStream(PipedOutputStream src)
                     throws IOException

  Creates a `PipedInputStream` so that it is connected to the piped output stream `src`. Data bytes written to `src` will then be available as input from this stream.

  Parameters:
    `src` - the stream to connect to.
  Throws:
    `IOException` - if an I/O error occurs.

### PipedInputStream

    public PipedInputStream()

  Creates a `PipedInputStream` so that it is not yet connected. It must be connected to a `PipedOutputStream` before being used.

  See Also:
    `connect(java.io.PipedOutputStream)`, `PipedOutputStream.connect(java.io.PipedInputStream)`

Method Detail

### connect

    public void connect(PipedOutputStream src)
                 throws IOException

  Causes this piped input stream to be connected to the piped output stream `src`. If this object is already connected to some other piped output stream, an `IOException` is thrown.

  If `src` is an unconnected piped output stream and `snk` is an unconnected piped input stream, they may be connected by either the call:

      snk.connect(src)

  or the call:

      src.connect(snk)

  The two calls have the same effect.

  Parameters:
    `src` - The piped output stream to connect to.
  Throws:
    `IOException` - if an I/O error occurs.

### read

    public int read()
             throws IOException

  Reads the next byte of data from this piped input stream. The value byte is returned as an `int` in the range `0` to `255`. If no byte is available because the end of the stream has been reached, the value `-1` is returned. This method blocks until input data is available, the end of the stream is detected, or an exception is thrown. If a thread was providing data bytes to the connected piped output stream, but the thread is no longer alive, then an `IOException` is thrown.

  Specified by:
    `read` in class `InputStream`
  Returns:
    the next byte of data, or `-1` if the end of the stream is reached.
  Throws:
    `IOException` - if the pipe is broken.

### read

    public int read(byte[] b,
                    int off,
                    int len)
             throws IOException

  Reads up to `len` bytes of data from this piped input stream into an array of bytes. Less than `len` bytes will be read if the end of the data stream is reached. This method blocks until at least one byte of input is available. If a thread was providing data bytes to the connected piped output stream, but the thread is no longer alive, then an `IOException` is thrown.

  Overrides:
    `read` in class `InputStream`
  Parameters:
    `b` - the buffer into which the data is read.
    `off` - the start offset of the data.
    `len` - the maximum number of bytes read.
  Returns:
    the total number of bytes read into the buffer, or `-1` if there is no more data because the end of the stream has been reached.
  Throws:
    `IOException` - if an I/O error occurs.
  See Also:
    `InputStream.read()`

### available

    public int available()
                  throws IOException

  Returns the number of bytes that can be read from this input stream without blocking. This method overrides the `available` method of the parent class.

  Overrides:
    `available` in class `InputStream`
  Returns:
    the number of bytes that can be read from this input stream without blocking.
  Throws:
    `IOException` - if an I/O error occurs.
  Since:
    JDK1.0.2

### close

    public void close()
               throws IOException

  Closes this piped input stream and releases any system resources associated with the stream.

  Overrides:
    `close` in class `InputStream`
  Throws:
    `IOException` - if an I/O error occurs.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help

PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD