Java/File Input Output/OutputStream

A null output stream. All data written to this stream is ignored.

  
/**
 * 
 * JFreeReport : a free Java reporting library
 * 
 *
 * Project Info:  http://reporting.pentaho.org/
 *
 * (C) Copyright 2001-2007, by Object Refinery Ltd, Pentaho Corporation and Contributors.
 *
 * This library is free software; you can redistribute it and/or modify it under the terms
 * of the GNU Lesser General Public License as published by the Free Software Foundation;
 * either version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License along with this
 * library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
 * Boston, MA 02111-1307, USA.
 *
 * [Java is a trademark or registered trademark of Sun Microsystems, Inc.
 * in the United States and other countries.]
 *
 * ------------
 * NullOutputStream.java
 * ------------
 * (C) Copyright 2001-2007, by Object Refinery Ltd, Pentaho Corporation and Contributors.
 */
import java.io.IOException;
import java.io.OutputStream;
/**
 * A null output stream. All data written to this stream is ignored.
 *
 * @author Thomas Morgner
 */
public class NullOutputStream extends OutputStream
{
  /**
   * Default constructor.
   */
  public NullOutputStream ()
  {
  }
  /**
   * Writes to the stream (in this case, does nothing).
   *
   * @param i the value.
   * @throws IOException if there is an I/O problem.
   */
  public void write (final int i)
          throws IOException
  {
    // no i wont do anything here ...
  }
  /**
   * Writes to the stream (in this case, does nothing).
   *
   * @param bytes the bytes.
   * @throws IOException if there is an I/O problem.
   */
  public void write (final byte[] bytes)
          throws IOException
  {
    // no i wont do anything here ...
  }
  /**
   * Writes to the stream (in this case, does nothing).
   *
   * @param bytes the bytes.
   * @param off   the start offset in the data.
   * @param len   the number of bytes to write.
   * @throws IOException if there is an I/O problem.
   */
  public void write (final byte[] bytes, final int off, final int len)
          throws IOException
  {
    // no i wont do anything here ...
  }
}

Byte Counting OutputStream

 


import java.io.IOException;
import java.io.OutputStream;
/**
 * Output stream that counts bytes written to it (but discards them).
 * 
 * @author Jonathan Locke
 */
public final class ByteCountingOutputStream extends OutputStream
{
  private long size;
  /**
   * @see java.io.OutputStream#write(int)
   */
  public void write(int b) throws IOException
  {
    size++;
  }
  /**
   * @see java.io.OutputStream#write(byte[], int, int)
   */
  public void write(byte b[], int off, int len) throws IOException
  {
    size += len;
  }
  /**
   * @return Number of bytes written to this stream
   */
  public long size()
  {
    return size;
  }
}

Compare the contents of two Streams to determine if they are equal or not.

  
/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
/** * Origin of code: Apache Avalon (Excalibur)
 * 
 * @author Peter Donald
 * @author Jeff Turner
 * @author Matthew Hawthorne
 * @author Stephen Colebourne
 * @author Gareth Davis
 * @version CVS $Revision$ $Date$*/
public class Main {
  /**
   * Compare the contents of two Streams to determine if they are equal or not.
   * <p>
   * This method buffers the input internally using <code>BufferedInputStream</code> if they are
   * not already buffered.
   * 
   * @param input1
   *            the first stream
   * @param input2
   *            the second stream
   * @return true if the content of the streams are equal or they both don"t exist, false
   *         otherwise
   * @throws NullPointerException
   *             if either input is null
   * @throws IOException
   *             if an I/O error occurs
   */
  public static boolean contentEquals(InputStream input1, InputStream input2) throws IOException
  {
    if (!(input1 instanceof BufferedInputStream))
    {
      input1 = new BufferedInputStream(input1);
    }
    if (!(input2 instanceof BufferedInputStream))
    {
      input2 = new BufferedInputStream(input2);
    }
    int ch = input1.read();
    while (-1 != ch)
    {
      int ch2 = input2.read();
      if (ch != ch2)
      {
        return false;
      }
      ch = input1.read();
    }
    int ch2 = input2.read();
    return (ch2 == -1);
  }
}

Memory Byte Array OutputStream

  
/**
 * 
 * JFreeReport : a free Java reporting library
 * 
 *
 * Project Info:  http://reporting.pentaho.org/
 *
 * (C) Copyright 2001-2007, by Object Refinery Ltd, Pentaho Corporation and Contributors.
 *
 * This library is free software; you can redistribute it and/or modify it under the terms
 * of the GNU Lesser General Public License as published by the Free Software Foundation;
 * either version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License along with this
 * library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
 * Boston, MA 02111-1307, USA.
 *
 * [Java is a trademark or registered trademark of Sun Microsystems, Inc.
 * in the United States and other countries.]
 *
 * ------------
 * MemoryByteArrayOutputStream.java
 * ------------
 * (C) Copyright 2001-2007, by Object Refinery Ltd, Pentaho Corporation and Contributors.
 */
import java.io.IOException;
import java.io.OutputStream;
/**
 * A string writer that is able to write large amounts of data. The original
 * StringWriter contained in Java doubles its buffersize everytime the buffer
 * overflows. This is nice with small amounts of data, but awfull for huge
 * buffers.
 * 
 * @author Thomas Morgner
 */
public class MemoryByteArrayOutputStream extends OutputStream {
  private int maximumBufferIncrement;
  private int cursor;
  private byte[] buffer;
  private byte[] singleIntArray;
  /**
   * Create a new character-stream writer whose critical sections will
   * synchronize on the writer itself.
   */
  public MemoryByteArrayOutputStream() {
    this(4096, 65536);
  }
  /**
   * Create a new character-stream writer whose critical sections will
   * synchronize on the writer itself.
   */
  public MemoryByteArrayOutputStream(final int bufferSize, final int maximumBufferIncrement) {
    this.maximumBufferIncrement = maximumBufferIncrement;
    this.buffer = new byte[bufferSize];
    this.singleIntArray = new byte[1];
  }
  /**
   * Write a portion of an array of characters.
   * 
   * @param cbuf
   *          Array of characters
   * @param off
   *          Offset from which to start writing characters
   * @param len
   *          Number of characters to write
   * @throws java.io.IOException
   *           If an I/O error occurs
   */
  public synchronized void write(final byte[] cbuf, final int off, final int len)
      throws IOException {
    if (len < 0) {
      throw new IllegalArgumentException();
    }
    if (off < 0) {
      throw new IndexOutOfBoundsException();
    }
    if (cbuf == null) {
      throw new NullPointerException();
    }
    if ((len + off) > cbuf.length) {
      throw new IndexOutOfBoundsException();
    }
    ensureSize(cursor + len);
    System.arraycopy(cbuf, off, this.buffer, cursor, len);
    cursor += len;
  }
  /**
   * Writes <code>b.length</code> bytes from the specified byte array to this
   * output stream. The general contract for <code>write(b)</code> is that it
   * should have exactly the same effect as the call <code>write(b, 0,
   * b.length)</code>.
   * 
   * @param b
   *          the data.
   * @throws java.io.IOException
   *           if an I/O error occurs.
   * @see java.io.OutputStream#write(byte[], int, int)
   */
  public void write(final byte[] b) throws IOException {
    write(b, 0, b.length);
  }
  /**
   * Writes the specified byte to this output stream. The general contract for
   * <code>write</code> is that one byte is written to the output stream. The
   * byte to be written is the eight low-order bits of the argument
   * <code>b</code>. The 24 high-order bits of <code>b</code> are ignored.
   * <p/> Subclasses of <code>OutputStream</code> must provide an
   * implementation for this method.
   * 
   * @param b
   *          the <code>byte</code>.
   * @throws java.io.IOException
   *           if an I/O error occurs. In particular, an
   *           <code>IOException</code> may be thrown if the output stream has
   *           been closed.
   */
  public synchronized void write(final int b) throws IOException {
    this.singleIntArray[0] = (byte) (0xFF & b);
    write(singleIntArray, 0, 1);
  }
  private void ensureSize(final int size) {
    if (this.buffer.length >= size) {
      return;
    }
    final int computedSize = (int) Math.min((this.buffer.length + 1) * 1.5, this.buffer.length
        + maximumBufferIncrement);
    final int newSize = Math.max(size, computedSize);
    final byte[] newBuffer = new byte[newSize];
    System.arraycopy(this.buffer, 0, newBuffer, 0, cursor);
    this.buffer = newBuffer;
  }
  /**
   * Flush the stream. If the stream has saved any characters from the various
   * write() methods in a buffer, write them immediately to their intended
   * destination. Then, if that destination is another character or byte stream,
   * flush it. Thus one flush() invocation will flush all the buffers in a chain
   * of Writers and OutputStreams. <p/> If the intended destination of this
   * stream is an abstraction provided by the underlying operating system, for
   * example a file, then flushing the stream guarantees only that bytes
   * previously written to the stream are passed to the operating system for
   * writing; it does not guarantee that they are actually written to a physical
   * device such as a disk drive.
   * 
   * @throws java.io.IOException
   *           If an I/O error occurs
   */
  public void flush() throws IOException {
    if ((buffer.length - cursor) > 50000) {
      System.out.println("WASTED: " + (buffer.length - cursor));
    }
  }
  /**
   * Close the stream, flushing it first. Once a stream has been closed, further
   * write() or flush() invocations will cause an IOException to be thrown.
   * Closing a previously-closed stream, however, has no effect.
   * 
   * @throws java.io.IOException
   *           If an I/O error occurs
   */
  public void close() throws IOException {
  }
  public synchronized byte[] toByteArray() {
    final byte[] retval = new byte[cursor];
    System.arraycopy(buffer, 0, retval, 0, cursor);
    return retval;
  }
  public int getLength() {
    return cursor;
  }
  public byte[] getRaw() {
    if ((buffer.length - cursor) > 50000) {
      System.out.println("WASTED: " + (buffer.length - cursor) + " Length: " + buffer.length);
    }
    return buffer;
  }
}

Read from InputStream and write to OutputStream

  

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
public class Main {
  /**
   * Read input from input stream and write it to output stream 
   * until there is no more input from input stream.
   *
   * @param is input stream the input stream to read from.
   * @param os output stream the output stream to write to.
   * @param buf the byte array to use as a buffer
   */
  public static void flow( InputStream is, OutputStream os, byte[] buf ) 
      throws IOException {
      int numRead;
      while ( (numRead = is.read(buf) ) >= 0) {
          os.write(buf, 0, numRead);
      }
  } 
}

String Buffer OutputStream

     
/*
 * Created on Dec 25, 2004
 * 
 * Copyright 2005 CafeSip.org 
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); 
 * you may not use this file except in compliance with the License. 
 * You may obtain a copy of the License at 
 *
 *  http://www.apache.org/licenses/LICENSE-2.0 
 *
 * Unless required by applicable law or agreed to in writing, software 
 * distributed under the License is distributed on an "AS IS" BASIS, 
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 * See the License for the specific language governing permissions and 
 * limitations under the License.
 *
 */
import java.io.IOException;
import java.io.OutputStream;
/**
 * @author amit
 *
 */
public class StringBufferOutputStream extends OutputStream
{
    private StringBuffer textBuffer = new StringBuffer();
    
    /**
     * 
     */
    public StringBufferOutputStream()
    {
        super();
    }
    /*
     * @see java.io.OutputStream#write(int)
     */
    public void write(int b) throws IOException
    {
        char a = (char)b;
        textBuffer.append(a);
    }
    public String toString()
    {
        return textBuffer.toString();
    }
  
    public void clear()
    {
        textBuffer.delete(0, textBuffer.length());
    }
}