Admin: 1 версия

2010-06-01T06:04:27Z

1 версия

в 18:01, 31 мая 2010

2010-05-31T18:01:43Z

Новая страница

== Copy a file ==



<source lang="java">

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
public class Main {
public static void main(String[] args) throws Exception {
FileInputStream fin = null;
FileOutputStream fout = null;
File file = new File("C:/myfile1.txt");
fin = new FileInputStream(file);
fout = new FileOutputStream("C:/myfile2.txt");
byte[] buffer = new byte[1024];
int bytesRead;
while ((bytesRead = fin.read(buffer)) > 0) {
fout.write(buffer, 0, bytesRead);
}
fin.close();
fout.close();
}
}

</source>



== Copy a file with FileOutputStream and FileInputStream ==



<source lang="java">

/*
* Copyright (c) 2004 David Flanagan. All rights reserved.
* This code is from the book Java Examples in a Nutshell, 3nd Edition.
* It is provided AS-IS, WITHOUT ANY WARRANTY either expressed or implied.
* You may study, use, and modify it for any non-commercial purpose,
* including teaching and use in open-source projects.
* You may distribute it non-commercially as long as you retain this notice.
* For a commercial use license, or to purchase the book,
* please visit http://www.davidflanagan.ru/javaexamples3.
*/
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
/**
* This class is a standalone program to copy a file, and also defines a static
* copy() method that other programs can use to copy files.
*/
public class FileCopy {
/** The main() method of the standalone program. Calls copy(). */
public static void main(String[] args) {
if (args.length != 2) // Check arguments
System.err.println("Usage: java FileCopy <source> <destination>");
else {
// Call copy() to do the copy; display any error messages
try {
copy(args[0], args[1]);
} catch (IOException e) {
System.err.println(e.getMessage());
}
}
}
/**
* The static method that actually performs the file copy. Before copying the
* file, however, it performs a lot of tests to make sure everything is as it
* should be.
*/
public static void copy(String from_name, String to_name) throws IOException {
File from_file = new File(from_name); // Get File objects from Strings
File to_file = new File(to_name);
// First make sure the source file exists, is a file, and is readable.
// These tests are also performed by the FileInputStream constructor
// which throws a FileNotFoundException if they fail.
if (!from_file.exists())
abort("no such source file: " + from_name);
if (!from_file.isFile())
abort("can"t copy directory: " + from_name);
if (!from_file.canRead())
abort("source file is unreadable: " + from_name);
// If the destination is a directory, use the source file name
// as the destination file name
if (to_file.isDirectory())
to_file = new File(to_file, from_file.getName());
// If the destination exists, make sure it is a writeable file
// and ask before overwriting it. If the destination doesn"t
// exist, make sure the directory exists and is writeable.
if (to_file.exists()) {
if (!to_file.canWrite())
abort("destination file is unwriteable: " + to_name);
// Ask whether to overwrite it
System.out.print("Overwrite existing file " + to_file.getName() + "? (Y/N): ");
System.out.flush();
// Get the user"s response.
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
String response = in.readLine();
// Check the response. If not a Yes, abort the copy.
if (!response.equals("Y") && !response.equals("y"))
abort("existing file was not overwritten.");
} else {
// If file doesn"t exist, check if directory exists and is
// writeable. If getParent() returns null, then the directory is
// the current dir. so look up the user.dir system property to
// find out what that is.
String parent = to_file.getParent(); // The destination directory
if (parent == null) // If none, use the current directory
parent = System.getProperty("user.dir");
File dir = new File(parent); // Convert it to a file.
if (!dir.exists())
abort("destination directory doesn"t exist: " + parent);
if (dir.isFile())
abort("destination is not a directory: " + parent);
if (!dir.canWrite())
abort("destination directory is unwriteable: " + parent);
}
// If we"ve gotten this far, then everything is okay.
// So we copy the file, a buffer of bytes at a time.
FileInputStream from = null; // Stream to read from source
FileOutputStream to = null; // Stream to write to destination
try {
from = new FileInputStream(from_file); // Create input stream
to = new FileOutputStream(to_file); // Create output stream
byte[] buffer = new byte[4096]; // To hold file contents
int bytes_read; // How many bytes in buffer
// Read a chunk of bytes into the buffer, then write them out,
// looping until we reach the end of the file (when read() returns
// -1). Note the combination of assignment and comparison in this
// while loop. This is a common I/O programming idiom.
while ((bytes_read = from.read(buffer)) != -1)
// Read until EOF
to.write(buffer, 0, bytes_read); // write
}
// Always close the streams, even if exceptions were thrown
finally {
if (from != null)
try {
from.close();
} catch (IOException e) {
;
}
if (to != null)
try {
to.close();
} catch (IOException e) {
;
}
}
}
/** A convenience method to throw an exception */
private static void abort(String msg) throws IOException {
throw new IOException("FileCopy: " + msg);
}
}

</source>



== Copying One File to Another ==



<source lang="java">

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
public class Main {
public static void main(String[] argv) throws Exception {
copy(new File("src.dat"), new File("dst.dat"));
}
static void copy(File src, File dst) throws IOException {
InputStream in = new FileInputStream(src);
OutputStream out = new FileOutputStream(dst);
byte[] buf = new byte[1024];
int len;
while ((len = in.read(buf)) > 0) {
out.write(buf, 0, len);
}
in.close();
out.close();
}
}

</source>



== Copying One File to Another with FileChannel ==



<source lang="java">

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.channels.FileChannel;
public class Main {
public static void main(String[] argv) throws Exception {
FileChannel srcChannel = new FileInputStream("srcFilename").getChannel();
FileChannel dstChannel = new FileOutputStream("dstFilename").getChannel();
dstChannel.transferFrom(srcChannel, 0, srcChannel.size());
srcChannel.close();
dstChannel.close();
}
}

</source>



== Count characters with FileInputStream ==



<source lang="java">

/*
* Copyright (c) 1995 - 2008 Sun Microsystems, Inc. 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 Sun Microsystems 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 COPYRIGHT OWNER 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.
*/
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
public class Count {
public static void countChars(InputStream in) throws IOException {
int count = 0;
while (in.read() != -1)
count++;
System.out.println("Counted " + count + " chars.");
}
public static void main(String[] args) throws Exception {
if (args.length >= 1)
countChars(new FileInputStream(args[0]));
else
System.err.println("Usage: Count filename");
}
}

</source>



== Display file contents in hexadecimal ==



<source lang="java">

import java.io.FileInputStream;
public class Main {
public static void main(String[] args) throws Exception {
FileInputStream fis = new FileInputStream("/home/username/data.txt");
int i = 0;
int count = 0;
while ((i = fis.read()) != -1) {
if (i != -1) {
System.out.printf("%02X ", i);
count++;
}
if (count == 16) {
System.out.println("");
count = 0;
}
}
fis.close();
}
}

</source>



== Read and copy with FileInputStream and FileOutputStream ==



<source lang="java">

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
public class FileInputOutputExample {
public static void main(String[] args) throws Exception {
InputStream is = new FileInputStream("in.txt");
OutputStream os = new FileOutputStream("out.txt");
int c;
while ((c = is.read()) != -1) {
System.out.print((char) c);
os.write(c);
}
is.close();
os.close();
}
}

</source>



== Read bytes and display their hexadecimal values. ==



<source lang="java">

import java.io.FileInputStream;
public class Main {
public static void main(String[] argv) throws Exception {
FileInputStream fin = new FileInputStream("text.txt");
int len;
byte data[] = new byte[16];
// Read bytes until EOF is encountered.
do {
len = fin.read(data);
for (int j = 0; j < len; j++)
System.out.printf("%02X ", data[j]);
} while (len != -1);
}
}

</source>



== Read file character by character ==



<source lang="java">

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
public class Main {
public static void main(String[] args) {
File file = new File(args[0]);
if (!file.exists()) {
System.out.println(args[0] + " does not exist.");
return;
}
if (!(file.isFile() && file.canRead())) {
System.out.println(file.getName() + " cannot be read from.");
return;
}
try {
FileInputStream fis = new FileInputStream(file);
char current;
while (fis.available() > 0) {
current = (char) fis.read();
System.out.print(current);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}

</source>



== Read file in byte array using FileInputStream ==



<source lang="java">

import java.io.File;
import java.io.FileInputStream;
public class Main {
public static void main(String[] args) throws Exception {
File file = new File("C:/String.txt");
FileInputStream fin = new FileInputStream(file);
byte fileContent[] = new byte[(int) file.length()];
fin.read(fileContent);
System.out.println(new String(fileContent));
}
}

</source>



== Read file using FileInputStream ==



<source lang="java">

import java.io.File;
import java.io.FileInputStream;
public class Main {
public static void main(String[] args) throws Exception {
File file = new File("C:/String.txt");
StringBuffer strContent = new StringBuffer();
FileInputStream fin = new FileInputStream(file);
int ch;
while ((ch = fin.read()) != -1) {
strContent.append((char) ch);
}
fin.close();
System.out.println(strContent);
}
}

</source>



== Reading a File into a Byte Array: reads the entire contents of a file into a byte array ==



<source lang="java">

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
public class Main {
public static void main(String[] argv) throws Exception {
File file = new File("c:\\a.bat");
InputStream is = new FileInputStream(file);
long length = file.length();
if (length > Integer.MAX_VALUE) {
System.out.println("File is too large");
}
byte[] bytes = new byte[(int) length];
int offset = 0;
int numRead = 0;
while (numRead >= 0) {
numRead = is.read(bytes, offset, bytes.length - offset);
offset += numRead;
}
if (offset < bytes.length) {
throw new IOException("Could not completely read file " + file.getName());
}
is.close();
System.out.println(new String(bytes));
}
}

</source>



== Read one byte from a file ==



<source lang="java">

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class Main {
public void readOneByte() throws FileNotFoundException {
FileInputStream file = null;
byte x = -1;
try {
file = new FileInputStream("fileName");
x = (byte) file.read();
} catch (FileNotFoundException f) {
throw f;
} catch (IOException i) {
i.printStackTrace();
} finally {
try {
if (file != null) {
file.close();
}
} catch (IOException e) {
}
}
}
}

</source>



== Resettable File InputStream ==



<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.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
/**
* @author Federico Barbieri <fede@apache.org>
*/
public class ResettableFileInputStream
extends InputStream
{
protected static final int DEFAULT_BUFFER_SIZE = 1024;
protected final String m_filename;
protected int m_bufferSize;
protected InputStream m_inputStream;
protected long m_position;
protected long m_mark;
protected boolean m_isMarkSet;
public ResettableFileInputStream( final File file )
throws IOException
{
this( file.getCanonicalPath() );
}
public ResettableFileInputStream( final String filename )
throws IOException
{
this( filename, DEFAULT_BUFFER_SIZE );
}
public ResettableFileInputStream( final String filename, final int bufferSize )
throws IOException
{
m_bufferSize = bufferSize;
m_filename = filename;
m_position = 0;
m_inputStream = newStream();
}
public void mark( final int readLimit )
{
m_isMarkSet = true;
m_mark = m_position;
m_inputStream.mark( readLimit );
}
public boolean markSupported()
{
return true;
}
public void reset()
throws IOException
{
if( !m_isMarkSet )
{
throw new IOException( "Unmarked Stream" );
}
try
{
m_inputStream.reset();
}
catch( final IOException ioe )
{
try
{
m_inputStream.close();
m_inputStream = newStream();
m_inputStream.skip( m_mark );
m_position = m_mark;
}
catch( final Exception e )
{
throw new IOException( "Cannot reset current Stream: " + e.getMessage() );
}
}
}
protected InputStream newStream()
throws IOException
{
return new BufferedInputStream( new FileInputStream( m_filename ), m_bufferSize );
}
public int available()
throws IOException
{
return m_inputStream.available();
}
public void close() throws IOException
{
m_inputStream.close();
}
public int read() throws IOException
{
m_position++;
return m_inputStream.read();
}
public int read( final byte[] bytes, final int offset, final int length )
throws IOException
{
final int count = m_inputStream.read( bytes, offset, length );
m_position += count;
return count;
}
public long skip( final long count )
throws IOException
{
m_position += count;
return m_inputStream.skip( count );
}
}

</source>



== Skip n bytes while reading the file using FileInputStream ==



<source lang="java">

import java.io.File;
import java.io.FileInputStream;
public class Main {
public static void main(String[] args) throws Exception {
File file = new File("C:/String.txt");
FileInputStream fin = new FileInputStream(file);
int ch;
// skip first 10 bytes
fin.skip(10);
while ((ch = fin.read()) != -1){
System.out.print((char) ch);
}
}
}

</source>



== Use Java NIO to Copy File ==



<source lang="java">

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
public class Main {
public static void main(String[] args) throws Exception {
String source = "s.txt";
String destination = "d.txt";
FileInputStream fis = new FileInputStream(source);
FileOutputStream fos = new FileOutputStream(destination);
FileChannel fci = fis.getChannel();
FileChannel fco = fos.getChannel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
while (true) {
int read = fci.read(buffer);
if (read == -1)
break;
buffer.flip();
fco.write(buffer);
buffer.clear();
}
}
}

</source>

← Предыдущая	Версия 06:04, 1 июня 2010
(нет различий)

Java/File Input Output/FileInputStream - История изменений

Admin: 1 версия

в 18:01, 31 мая 2010