Java/File Input Output/File Writer
Содержание
Append or add some contents to the file
<source lang="java">
import java.io.File; import java.io.FileWriter; public class Main {
public static void main(String[] args) throws Exception{ File file = new File("user.txt"); FileWriter writer = new FileWriter(file, true); writer.write("username=java;password=secret" + System.getProperty("line.separator")); writer.flush(); writer.close(); }
}
</source>
Demonstrate FileWriter.
<source lang="java">
import java.io.FileWriter; import java.io.IOException; class FileWriterDemo {
public static void main(String args[]) throws IOException { String source = "test"; char buffer[] = new char[source.length()]; source.getChars(0, source.length(), buffer, 0); FileWriter f0 = new FileWriter("file1.txt"); for (int i = 0; i < buffer.length; i += 2) { f0.write(buffer[i]); } f0.close(); FileWriter f1 = new FileWriter("file2.txt"); f1.write(buffer); f1.close(); FileWriter f2 = new FileWriter("file3.txt"); f2.write(buffer, buffer.length - buffer.length / 4, buffer.length / 4); f2.close(); }
}
</source>
Implementation of a fast Writer.
<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.IOException; import java.io.Writer; /**
* Implementation of a fast Writer. It was originally taken from JspWriter * and modified to have less syncronization going on. * * @author * @author Anil K. Vijendran * @version $Id: VelocityWriter.java 463298 2006-10-12 16:10:32Z henning $ */
public final class VelocityWriter extends Writer {
/**
* constant indicating that the Writer is not buffering output
*/
public static final int NO_BUFFER = 0;
/**
* constant indicating that the Writer is buffered and is using the
* implementation default buffer size
*/
public static final int DEFAULT_BUFFER = -1;
/**
* constant indicating that the Writer is buffered and is unbounded;
* this is used in BodyContent
*/
public static final int UNBOUNDED_BUFFER = -2;
private int bufferSize;
private boolean autoFlush;
private Writer writer;
private char cb[];
private int nextChar;
private static int defaultCharBufferSize = 8 * 1024;
/**
* Create a buffered character-output stream that uses a default-sized
* output buffer.
*
* @param writer Writer to wrap around
*/
public VelocityWriter(Writer writer)
{
this(writer, defaultCharBufferSize, true);
}
/**
* private constructor.
*/
private VelocityWriter(int bufferSize, boolean autoFlush)
{
this.bufferSize = bufferSize;
this.autoFlush = autoFlush;
}
/**
* This method returns the size of the buffer used by the JspWriter.
*
* @return the size of the buffer in bytes, or 0 is unbuffered.
*/
public int getBufferSize() { return bufferSize; }
/**
* This method indicates whether the JspWriter is autoFlushing.
*
* @return if this JspWriter is auto flushing or throwing IOExceptions on
* buffer overflow conditions
*/
public boolean isAutoFlush() { return autoFlush; }
/**
* Create a new buffered character-output stream that uses an output
* buffer of the given size.
*
* @param writer Writer to wrap around
* @param sz Output-buffer size, a positive integer
* @param autoFlush
*
* @exception IllegalArgumentException If sz is <= 0
*/
public VelocityWriter(Writer writer, int sz, boolean autoFlush)
{
this(sz, autoFlush);
if (sz < 0)
throw new IllegalArgumentException("Buffer size <= 0");
this.writer = writer;
cb = sz == 0 ? null : new char[sz];
nextChar = 0;
}
/**
* Flush the output buffer to the underlying character stream, without
* flushing the stream itself. This method is non-private only so that it
* may be invoked by PrintStream.
*/
private final void flushBuffer() throws IOException
{
if (bufferSize == 0)
return;
if (nextChar == 0)
return;
writer.write(cb, 0, nextChar);
nextChar = 0;
}
/**
* Discard the output buffer.
*/
public final void clear()
{
nextChar = 0;
}
private final void bufferOverflow() throws IOException
{
throw new IOException("overflow");
}
/**
* Flush the stream.
* @throws IOException
*
*/
public final void flush() throws IOException
{
flushBuffer();
if (writer != null)
{
writer.flush();
}
}
/**
* Close the stream.
* @throws IOException
*
*/
public final void close() throws IOException {
if (writer == null)
return;
flush();
}
/**
* @return the number of bytes unused in the buffer
*/
public final int getRemaining()
{
return bufferSize - nextChar;
}
/**
* Write a single character.
* @param c
* @throws IOException
*
*/
public final void write(int c) throws IOException
{
if (bufferSize == 0)
{
writer.write(c);
}
else
{
if (nextChar >= bufferSize)
if (autoFlush)
flushBuffer();
else
bufferOverflow();
cb[nextChar++] = (char) c;
}
}
/**
* Our own little min method, to avoid loading
* java.lang.Math
if we"ve run out of file
* descriptors and we"re trying to print a stack trace.
*/
private final int min(int a, int b)
{
return (a < b ? a : b);
}
/**
* Write a portion of an array of characters.
*
* Ordinarily this method stores characters from the given array into
* this stream"s buffer, flushing the buffer to the underlying stream as
* needed. If the requested length is at least as large as the buffer,
* however, then this method will flush the buffer and write the characters
* directly to the underlying stream. Thus redundant
* DiscardableBufferedWriter
s will not copy data unnecessarily.
*
* @param cbuf A character array
* @param off Offset from which to start reading characters
* @param len Number of characters to write
* @throws IOException
*
*/
public final void write(char cbuf[], int off, int len)
throws IOException
{
if (bufferSize == 0)
{
writer.write(cbuf, off, len);
return;
}
if (len == 0)
{
return;
}
if (len >= bufferSize)
{
/* If the request length exceeds the size of the output buffer,
flush the buffer and then write the data directly. In this
way buffered streams will cascade harmlessly. */
if (autoFlush)
flushBuffer();
else
bufferOverflow();
writer.write(cbuf, off, len);
return;
}
int b = off, t = off + len;
while (b < t)
{
int d = min(bufferSize - nextChar, t - b);
System.arraycopy(cbuf, b, cb, nextChar, d);
b += d;
nextChar += d;
if (nextChar >= bufferSize)
if (autoFlush)
flushBuffer();
else
bufferOverflow();
}
}
/**
* Write an array of characters. This method cannot be inherited from the
* Writer class because it must suppress I/O exceptions.
* @param buf
* @throws IOException
*/
public final void write(char buf[]) throws IOException
{
write(buf, 0, buf.length);
}
/**
* Write a portion of a String.
*
* @param s String to be written
* @param off Offset from which to start reading characters
* @param len Number of characters to be written
* @throws IOException
*
*/
public final void write(String s, int off, int len) throws IOException
{
if (bufferSize == 0)
{
writer.write(s, off, len);
return;
}
int b = off, t = off + len;
while (b < t)
{
int d = min(bufferSize - nextChar, t - b);
s.getChars(b, b + d, cb, nextChar);
b += d;
nextChar += d;
if (nextChar >= bufferSize)
if (autoFlush)
flushBuffer();
else
bufferOverflow();
}
}
/**
* Write a string. This method cannot be inherited from the Writer class
* because it must suppress I/O exceptions.
* @param s
* @throws IOException
*/
public final void write(String s) throws IOException
{
if (s != null)
{
write(s, 0, s.length());
}
}
/**
* resets this class so that it can be reused
* @param writer
*
*/
public final void recycle(Writer writer)
{
this.writer = writer;
clear();
}
}
</source>
Use FileWriter to write an array of strings to a file.
<source lang="java">
import java.io.FileWriter; public class Main {
public static void main(String[] argv) throws Exception { FileWriter fw = new FileWriter("file.dat"); String strs[] = { "com", "exe", "doc" }; for (int i = 0; i < strs.length; i++) { fw.write(strs[i] + "\n"); } fw.close(); }
}
</source>
Using a Reader and a Writer, returns a String from an InputStream
<source lang="java">
import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.StringWriter; /* Copyright (c) 1995-2000, The Hypersonic SQL Group.
* All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * Redistributions of source code must retain the above copyright notice, this * list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * * Neither the name of the Hypersonic SQL Group nor the names of its * contributors may be used to endorse or promote products derived from this * software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE HYPERSONIC SQL GROUP, * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * This software consists of voluntary contributions made by many individuals * on behalf of the Hypersonic SQL Group. * * * For work added by the HSQL Development Group: * * Copyright (c) 2001-2009, The HSQL Development Group * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * Redistributions of source code must retain the above copyright notice, this * list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * * Neither the name of the HSQL Development Group nor the names of its * contributors may be used to endorse or promote products derived from this * software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL HSQL DEVELOPMENT GROUP, HSQLDB.ORG, * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
/**
* Collection of static methods for converting strings between different formats * and to and from byte arrays. * <p> * * Includes some methods based on Hypersonic code as indicated. * * @author Thomas Mueller (Hypersonic SQL Group) * @author Fred Toussi (fredt@users dot sourceforge.net) * @version 1.9.0 * @since 1.7.2 */
public class Main {
private static final byte[] HEXBYTES = { (byte) "0", (byte) "1", (byte) "2", (byte) "3", (byte) "4", (byte) "5", (byte) "6", (byte) "7", (byte) "8", (byte) "9", (byte) "a", (byte) "b", (byte) "c", (byte) "d", (byte) "e", (byte) "f" };
/** * Using a Reader and a Writer, returns a String from an InputStream. * * Method based on Hypersonic Code * * @param x InputStream to read from * @throws IOException * @return a Java string */ public static String inputStreamToString(InputStream x, String encoding) throws IOException { InputStreamReader in = new InputStreamReader(x, encoding); StringWriter writer = new StringWriter(); int blocksize = 8 * 1024; char[] buffer = new char[blocksize]; for (;;) { int read = in.read(buffer); if (read == -1) { break; } writer.write(buffer, 0, read); } writer.close(); return writer.toString(); }
}
</source>