Java/File Input Output/OutputStream

Материал из Java эксперт
Перейти к: навигация, поиск

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

   <source lang="java">
 

/**

* 
* 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 ...
 }

}


 </source>
   
  
 
  



Byte Counting OutputStream

   <source lang="java">


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;
 }

}

 </source>
   
  
 
  



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

   <source lang="java">
 

/*

* 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.
*

* This method buffers the input internally using BufferedInputStream 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); } } </source>

Memory Byte Array OutputStream

   <source lang="java">
 

/**

* 
* 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 b.length bytes from the specified byte array to this
  * output stream. The general contract for write(b) is that it
  * should have exactly the same effect as the call write(b, 0,
  * b.length).
  * 
  * @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
  * write is that one byte is written to the output stream. The
  * byte to be written is the eight low-order bits of the argument
  * b. The 24 high-order bits of b are ignored.
  * <p/> Subclasses of OutputStream must provide an
  * implementation for this method.
  * 
  * @param b
  *          the byte.
  * @throws java.io.IOException
  *           if an I/O error occurs. In particular, an
  *           IOException 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;
 }

}


 </source>
   
  
 
  



Read from InputStream and write to OutputStream

   <source lang="java">
 

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);
     }
 } 

}


 </source>
   
  
 
  



String Buffer OutputStream

   <source lang="java">
    

/*

* 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());
   }

}



 </source>