java 文件流 追加_(IO流)java中多种方式读文件,追加文件内容,对文件的各种操作...

import java.io.BufferedReader;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileReader;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.RandomAccessFile;

import java.io.Reader;

public class ReadFromFile {

public static void main(String[] args) {

String fileName =

"C:/temp/newTemp.txt";

ReadFromFile.readFileByBytes(fileName);

ReadFromFile.readFileByChars(fileName);

ReadFromFile.readFileByLines(fileName);

ReadFromFile.readFileByRandomAccess(fileName);

}

public static void readFileByBytes(String

fileName) {

File file = new

File(fileName);

InputStream in = null;

try {

System.out.println("以字节为单位读取文件内容，一次读一个字节：");

//

一次读一个字节

in = new

FileInputStream(file);

int

tempbyte;

while

((tempbyte = in.read()) != -1) {

System.out.write(tempbyte);

}

in.close();

} catch (IOException e) {

e.printStackTrace();

return;

}

try {

System.out.println("以字节为单位读取文件内容，一次读多个字节：");

//

一次读多个字节

byte[]

tempbytes = new byte[100];

int byteread

= 0;

in = new

FileInputStream(fileName);

ReadFromFile.showAvailableBytes(in);

//

读入多个字节到字节数组中，byteread为一次读入的字节数

while

((byteread = in.read(tempbytes)) != -1) {

System.out.write(tempbytes,

0, byteread);

}

} catch (Exception e1) {

e1.printStackTrace();

} finally {

if (in !=

null) {

try

{

in.close();

}

catch (IOException e1) {

}

}

}

}

public static void readFileByChars(String

fileName) {

File file = new

File(fileName);

Reader reader = null;

try {

System.out.println("以字符为单位读取文件内容，一次读一个字节：");

//

一次读一个字符

reader = new

InputStreamReader(new FileInputStream(file));

int

tempchar;

while

((tempchar = reader.read()) != -1) {

//

对于windows下，\r\n这两个字符在一起时，表示一个换行。

//

但如果这两个字符分开显示时，会换两次行。

//

因此，屏蔽掉\r，或者屏蔽\n。否则，将会多出很多空行。

if

(((char) tempchar) != '\r') {

System.out.print((char)

tempchar);

}

}

reader.close();

} catch (Exception e) {

e.printStackTrace();

}

try {

System.out.println("以字符为单位读取文件内容，一次读多个字节：");

//

一次读多个字符

char[]

tempchars = new char[30];

int charread

= 0;

reader = new

InputStreamReader(new FileInputStream(fileName));

//

读入多个字符到字符数组中，charread为一次读取字符数

while

((charread = reader.read(tempchars)) != -1) {

//

同样屏蔽掉\r不显示

if

((charread == tempchars.length)

&&

(tempchars[tempchars.length - 1] != '\r')) {

System.out.print(tempchars);

}

else {

for

(int i = 0; i < charread; i++) {

if

(tempchars[i] == '\r') {

continue;

}

else {

System.out.print(tempchars[i]);

}

}

}

}

} catch (Exception e1) {

e1.printStackTrace();

} finally {

if (reader !=

null) {

try

{

reader.close();

}

catch (IOException e1) {

}

}

}

}

public static void readFileByLines(String

fileName) {

File file = new

File(fileName);

BufferedReader reader =

null;

try {

System.out.println("以行为单位读取文件内容，一次读一整行：");

reader = new

BufferedReader(new FileReader(file));

String

tempString = null;

int line =

1;

//

一次读入一行，直到读入null为文件结束

while

((tempString = reader.readLine()) != null) {

//

显示行号

System.out.println("line

" + line + ": " + tempString);

line++;

}

reader.close();

} catch (IOException e) {

e.printStackTrace();

} finally {

if (reader !=

null) {

try

{

reader.close();

}

catch (IOException e1) {

}

}

}

}

public static void readFileByRandomAccess(String

fileName) {

RandomAccessFile randomFile =

null;

try {

System.out.println("随机读取一段文件内容：");

//

打开一个随机访问文件流，按只读方式

randomFile =

new RandomAccessFile(fileName, "r");

//

文件长度，字节数

long

fileLength = randomFile.length();

//

读文件的起始位置

int

beginIndex = (fileLength > 4) ? 4 : 0;

//

将读文件的开始位置移到beginIndex位置。

randomFile.seek(beginIndex);

byte[] bytes

= new byte[10];

int byteread

= 0;

//

一次读10个字节，如果文件内容不足10个字节，则读剩下的字节。

//

将一次读取的字节数赋给byteread

while

((byteread = randomFile.read(bytes)) != -1) {

System.out.write(bytes,

0, byteread);

}

} catch (IOException e) {

e.printStackTrace();

} finally {

if

(randomFile != null) {

try

{

randomFile.close();

}

catch (IOException e1) {

}

}

}

}

private static void

showAvailableBytes(InputStream in) {

try {

System.out.println("当前字节输入流中的字节数为:"

+ in.available());

} catch (IOException e) {

e.printStackTrace();

}

}

}

//二、将内容追加到文件尾部

import java.io.FileWriter;

import java.io.IOException;

import java.io.RandomAccessFile;

public class ReadFromFile {

public static void appendMethodA(String

fileName, String content) {

try {

//

打开一个随机访问文件流，按读写方式

RandomAccessFile

randomFile = new RandomAccessFile(fileName, "rw");

//

文件长度，字节数

long

fileLength = randomFile.length();

//

将写文件指针移到文件尾。

randomFile.seek(fileLength);

randomFile.writeBytes(content);

randomFile.close();

} catch (IOException e) {

e.printStackTrace();

}

}

public static void appendMethodB(String

fileName, String content) {

try {

//

打开一个写文件器，构造函数中的第二个参数true表示以追加形式写文件

FileWriter

writer = new FileWriter(fileName, true);

writer.write(content);

writer.close();

} catch (IOException e) {

e.printStackTrace();

}

}

}

//三文件的各种操作类

import java.io.*;

public class FileOperate

{

public FileOperate()

{

}

public void newFolder(String folderPath)

{

try

{

String

filePath = folderPath;

filePath =

filePath.toString();

File

myFilePath = new File(filePath);

if(!myFilePath.exists())

{

myFilePath.mkdir();

}

System.out.println("新建目录操作 成功执行");

}

catch(Exception e)

{

System.out.println("新建目录操作出错");

e.printStackTrace();

}

}

2008-5-7 09:58 我思念的城市

public void newFile(String filePathAndName, String

fileContent)

{

try

{

String

filePath = filePathAndName;

filePath =

filePath.toString();

File

myFilePath = new File(filePath);

if

(!myFilePath.exists())

{

myFilePath.createNewFile();

}

FileWriter

resultFile = new FileWriter(myFilePath);

PrintWriter

myFile = new PrintWriter(resultFile);

String

strContent = fileContent;

myFile.println(strContent);

resultFile.close();

System.out.println("新建文件操作 成功执行");

}

catch (Exception e)

{

System.out.println("新建目录操作出错");

e.printStackTrace();

}

}

2008-5-7 09:58 我思念的城市

public void delFile(String filePathAndName)

{

try

{

String

filePath = filePathAndName;

filePath =

filePath.toString();

File

myDelFile = new File(filePath);

myDelFile.delete();

System.out.println("删除文件操作 成功执行");

}

catch (Exception e)

{

System.out.println("删除文件操作出错");

e.printStackTrace();

}

}

public void delFolder(String folderPath)

{

try

{

delAllFile(folderPath); //删除完里面所有内容

String

filePath = folderPath;

filePath =

filePath.toString();

File

myFilePath = new File(filePath);

if(myFilePath.delete()) { //删除空文件夹

System.out.println("删除文件夹" + folderPath + "操作 成功执行");

} else {

System.out.println("删除文件夹" +

folderPath + "操作 执行失败");

}

}

catch (Exception e)

{

System.out.println("删除文件夹操作出错");

e.printStackTrace();

}

}

2008-5-7 09:59 我思念的城市

public void delAllFile(String path)

{

File file = new

File(path);

if(!file.exists())

{

return;

}

if(!file.isDirectory())

{

return;

}

String[] tempList =

file.list();

File temp = null;

for (int i = 0; i

< tempList.length; i++)

{

if(path.endsWith(File.separator))

{

temp = new File(path +

tempList[i]);

}

else

{

temp = new File(path +

File.separator + tempList[i]);

}

if

(temp.isFile())

{

temp.delete();

}

if

(temp.isDirectory())

{

//delAllFile(path+"/"+

tempList[i]);//先删除文件夹里面的文件

delFolder(path+

File.separatorChar + tempList[i]);//再删除空文件夹

}

}

System.out.println("删除文件操作成功执行");

}

2008-5-7 09:59 我思念的城市

public void copyFile(String oldPath, String newPath)

{

try

{

int bytesum

= 0;

int byteread

= 0;

File oldfile

= new File(oldPath);

if

(oldfile.exists())

{

//文件存在时

InputStream inStream = new

FileInputStream(oldPath); //读入原文件

FileOutputStream fs = new

FileOutputStream(newPath);

byte[] buffer = new

byte[1444];

while ( (byteread =

inStream.read(buffer)) != -1)

{

bytesum += byteread;

//字节数文件大小

System.out.println(bytesum);

fs.write(buffer, 0,

byteread);

}

inStream.close();

}

System.out.println("删除文件夹操作 成功执行");

}

catch (Exception e)

{

System.out.println("复制单个文件操作出错");

e.printStackTrace();

}

}

2008-5-7 10:00 我思念的城市

public void copyFolder(String oldPath, String newPath)

{

try

{

(new

File(newPath)).mkdirs(); //如果文件夹不存在 则建立新文件夹

File a=new

File(oldPath);

String[]

file=a.list();

File

temp=null;

for (int i =

0; i < file.length; i++)

{

if(oldPath.endsWith(File.separator))

{

temp=new

File(oldPath+file[i]);

}

else

{

temp=new

File(oldPath+File.separator+file[i]);

}

if(temp.isFile())

{

FileInputStream input = new

FileInputStream(temp);

FileOutputStream output = new

FileOutputStream(newPath + "/" +

(temp.getName()).toString());

byte[] b = new byte[1024 *

5];

int len;

while ( (len = input.read(b))

!= -1)

{

output.write(b, 0, len);

}

output.flush();

output.close();