public synchronized int read() throws IOException

int res=bis.read();

System.out.println((char)res)

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

 byte[] buff=new byte[LEN];

 int res=bis.read(buff,0,LEN);

 System.out.println(new String(buff,0,res));

public synchronized int available() throws IOException

 public synchronized void mark(int readlimit)

 public synchronized void reset() throws IOException

  public synchronized void mark(int readlimit) {

        marklimit = readlimit;

        markpos = pos;

    }

    public synchronized void reset() throws IOException {

        getBufIfOpen(); // Cause exception if closed

        if (markpos < 0)

            throw new IOException("Resetting to invalid mark");

        pos = markpos;

    }

 private void fill() throws IOException {

        byte[] buffer = getBufIfOpen();

        if (markpos < 0)

            pos = 0;            /* no mark: throw away the buffer */

        else if (pos >= buffer.length)  /* no room left in buffer */

            if (markpos > 0) {  /* can throw away early part of the buffer */

                int sz = pos - markpos;

                System.arraycopy(buffer, markpos, buffer, 0, sz);

                pos = sz;

                markpos = 0;

            } else if (buffer.length >= marklimit) {

                markpos = -1;   /* buffer got too big, invalidate mark */

                pos = 0;        /* drop buffer contents */

            } else if (buffer.length >= MAX_BUFFER_SIZE) {

                throw new OutOfMemoryError("Required array size too large");

            } else {            /* grow buffer */

                int nsz = (pos <= MAX_BUFFER_SIZE - pos) ?

                        pos * 2 : MAX_BUFFER_SIZE;

                if (nsz > marklimit)

                    nsz = marklimit;

                byte nbuf[] = new byte[nsz];

                System.arraycopy(buffer, 0, nbuf, 0, pos);

                if (!bufUpdater.compareAndSet(this, buffer, nbuf)) {

                    // Can't replace buf if there was an async close.

                    // Note: This would need to be changed if fill()

                    // is ever made accessible to multiple threads.

                    // But for now, the only way CAS can fail is via close.

                    // assert buf == null;

                    throw new IOException("Stream closed");

                }

                buffer = nbuf;

            }

        count = pos;

        int n = getInIfOpen().read(buffer, pos, buffer.length - pos);

        if (n > 0)

            count = n + pos;

    }

 public synchronized void write(int b) throws IOException 

 public synchronized void write(byte b[], int off, int len) throws IOException  

 public synchronized void flush() throws IOException

 private void flushBuffer() throws IOException