Java/File Input Output/OutputStream
Содержание
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; } /** * Writesb.length
bytes from the specified byte array to this * output stream. The general contract forwrite(b)
is that it * should have exactly the same effect as the callwrite(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 ofb
are ignored. * <p/> Subclasses ofOutputStream
must provide an * implementation for this method. * * @param b * thebyte
. * @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>