首页 > 代码库 > Java IO文件流

Java IO文件流


package com.zb.io.test;


import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.OutputStream;

import java.io.OutputStreamWriter;

import java.io.Reader;

import java.io.Writer;


public class IO {

public static final String PATH1 = "temp/1.txt";

public static final String PATH2 = "temp/2.txt";

public static final String PATH3 = "temp/3.txt";

public static final String PATH4 = "temp/4.txt";

public static final String PATH5 = "temp/5.txt";

 

public static void main(String[] args) {

try {

// 创建文件夹和文件

File file = createDirAndFile(PATH1);

// 使用字节流OutPutStream写入文件信息

setFileByByteIoOutPutStream(file);

// 使用字节流InPutStream读取文件信息

getFileByByteIoInPutStream(file);

file = createDirAndFile(PATH2);

//使用Writer写入文件信息

setFileByCharIoWriter(file);

//使用Reader读取文件信息

getFileByCharIoReader(file);

file = createDirAndFile(PATH3);

//使用OutputStreamWriter写入文件信息

setFileByCharIoOutputStreamWriter(file);

//使用InputStreamReader读取文件信息

getFileByCharIoInputStreamReader(file);

file = createDirAndFile(PATH4);

//使用BufferedWriter写入文件信息

setFileByCharIoBufferedWriter(file);

//使用BufferedReader读取文件信息

getFileByCharIoBufferedReader(file);

file = createDirAndFile(PATH5);

//使用BufferedOutputStream写入文件信息

setFileByBufferedOutputStream(file);

//使用BufferedInputStream读取文件信息

getFileByBufferedInputStream(file);

 

} catch (IOException e) {

e.printStackTrace();

}

}

/**

* 在指定的目录创建文件夹和文件

* @param path 

* @throws IOException

*/

public static File createDirAndFile(String path) throws IOException {

File fileDir = new File("temp");

if (!fileDir.exists() && !fileDir.isDirectory()) {

System.out.println("开始创建新的文件夹!");

fileDir.mkdir();

} else {

System.out.println("文件夹已存在,无需创建!");

}

System.out.println("当前文件夹的路径是:" + fileDir.getAbsolutePath());

File file = new File(path);

if (!file.exists()) {

System.out.println("开始创建新的文件!");

file.createNewFile();

} else {

System.out.println("文件已存在,无需创建!");

}

System.out.println("当前文件的路径是:" + file.getAbsolutePath());

return file;

}


/**

* 使用OutPutStream写入文件

* @throws IOException

*/

public static void setFileByByteIoOutPutStream(File file) throws IOException {

StringBuffer sb = new StringBuffer("使用字节流OutPutStream写入文件信息!");

sb.append("\r\n在java中,可以使用InputStream对文件进行读取,就是字节流的输入。!");

sb.append("\r\n当读取文件内容进程序时,需要使用一个byte数组来进行存储,如此会有如下两个问题:");

sb.append("\r\n1.如何建立合适大小的byte数组,如果已知输入流的大小。");

sb.append("\r\n2.如果不知输入流的大小,则肯定需要建立一个很大的byte数组,那么byte中很可能有空的内容,那么如何正确合适的将byte数组的中的内容输出?");

sb.append("\r\n先看第一个问题:解决之道就是获取输入流的大小,创建此大小的byte数组。代码如下:view plaincopy to clipboardprint?\r\n//使用InputStream从文件中读取数据,在已知文件大小的情况下,建立合适的存储字节数组   ");

sb.append("\r\n第二个问题:问题的解决之道就是获得输入流何时结束,它在byte中的尾索引位置。可以通过read()方法实现,read()返回读取的字节内容,当内容为空时返回-1。利用此特征可以解决第二个问题。");

OutputStream out = new FileOutputStream(file);

out.write(sb.toString().getBytes());

// 刷新此输出流并强制写出所有缓冲的输出字节

out.flush();

out.close();

System.out.println("字节流写入文件完成!!!");

}


/**

* 使用InputStream读取文件

* @throws IOException

*/

public static void getFileByByteIoInPutStream(File file) throws IOException {

InputStream in = new FileInputStream(file);

System.out.println("===============字节流开始读取文件===================");

//创建合适文件大小的数组

byte b[]=new byte[(int)file.length()];     

//读取文件中的内容到b[]数组

 in.read(b);

 //关闭流

 in.close();

 System.out.println(new String(b));

in.close();

System.out.println("\n===============文件流读取完成===================");

}

/**

* 使用Writer写入文件

* @param file

* @throws IOException 

*/

private static void setFileByCharIoWriter(File file) throws IOException {

Writer wr = new FileWriter(file);

StringBuffer sb = new StringBuffer("使用字符流Writer写入文件信息!");

sb.append("\r\n java中的字符是Unicode编码的, InputStream和OutputStream都是用来处理字节的,在处理字符时需要用getBytes()转换成字节,这就需要编写字节、字符之间的转换代码java中提供了单独的类对IO设备进行字符输入与输出!");

sb.append("\r\n Reader和Writer是所有字符流类的的抽象基类,用于简化对字符串的输入输出编程,即用于读写文本数据");

sb.append("\r\n 二进制文件和文本文件的区别。");

sb.append("\r\n 如果一个文件专用于存储文本字符,而又没有包含文本之外的字符,就可称之为文本文件。除此之外的文件就是二进制文件");

sb.append("\r\n Reader和Writer两个类主要用于操作文本数据的内容,而InputStream和OutputStream主要操作二进制格式的内容  ");

sb.append("\r\n 使用FileWriter写入字符数据比FileOutputStream要简便很多,但是FileReader并不比FileInputStream读取字符数据要简便多少,都是要先读取到一个字符数组或者字节数组中,然后把数组转换成字符串。");

wr.write(sb.toString());

wr.flush();

wr.close();

System.out.println("字符流写入文件完成!!!");

}

/**

* 使用Reader读取文件

* @throws IOException 

*/

public static void getFileByCharIoReader(File file) throws IOException{

Reader reader = new FileReader(file);

char[] buffer = new char[1024];

int length = reader.read(buffer);

System.out.println("===============字符流开始读取文件===================");

String text = new String(buffer,0,length);

System.out.println(text);

reader.close();

System.out.println("\n===============文件流读取完成===================");

}

/**

* 使用OutputStreamWriter写入文件

* @param file

* @throws IOException 

*/

private static void setFileByCharIoOutputStreamWriter(File file) throws IOException {

OutputStreamWriter out = new OutputStreamWriter(new FileOutputStream(file));

StringBuffer sb = new StringBuffer("使用OutputStreamWriter写入文件信息!");

sb.append("\r\n 读取文件流时,经常会遇到乱码的现象,造成乱码的原因当然不可能是一个,这里主要介绍因为文件编码格式而导致的乱码的问题。首先,明确一点,文本文件与二进制文件的概念与差异。");

sb.append("\r\n 文本文件是基于字符编码的文件,常见的编码有ASCII编码,UNICODE编码、ANSI编码等等。二进制文件是基于值编码的文件,你可以根据具体应用,指定某个值是什么意思(这样一个过程,可以看作是自定义编码。)");

sb.append("\r\n 因此可以看出文本文件基本上是定长编码的(也有非定长的编码如UTF-8)。而二进制文件可看成是变长编码的,因为是值编码嘛,多少个比特代表一个值,完全由你决定。");

sb.append("\r\n 对于二进制文件,是千万不能使用字符串的,因为字符串默认初始化时会使用系统默认编码,然而,二进制文件因为自定义编码自然与固定格式的编码会有所冲突,所以对于二进制的文件只能采用字节流读取、操作、写入。");

sb.append("\r\n  对于文本文件,因为编码固定,所以只要在读取文件之前,采用文件自身的编码格式解析文件,然后获取字节,再然后,通过指定格式初始化字符串,那么得到的文本是不会乱码的。  ");

sb.append("\r\n  虽然,二进制文件也可以获取到它的文本编码格式,但是那是不准确的,所以不能同日而语。");

out.write(sb.toString());

out.flush();

out.close();

}

/**

* 使用InputStreamReader读取文件

* @param file

* @throws IOException 

*/

private static void getFileByCharIoInputStreamReader(File file) throws IOException {

InputStreamReader isr = new InputStreamReader(new FileInputStream(file),"UTF-8");

int length = -1;

char[] buffer = new char[1024];

StringBuffer sb = new StringBuffer(0);

System.out.println("===============InputStreamReader开始读取文件===================");

while((length=isr.read(buffer,0,1024))!=-1){

sb.append(buffer,0,length);

}

isr.close();

System.out.println(sb.toString());

System.out.println("===============InputStreamReader读取完成===================");

}

/**

* 使用BufferedWriter写入文件

* @param file

* @throws IOException 

*/

private static void setFileByCharIoBufferedWriter(File file) throws IOException {

BufferedWriter bw = new BufferedWriter(new FileWriter(file));

StringBuffer sb = new StringBuffer("使用BufferedWriter写入文件信息!");

sb.append("\r\n java.io.BufferedReader和java.io.BufferedWriter类各拥有8192字符的缓冲区。");

sb.append("\r\n 当BufferedReader在读取文本文件时,会先尽量从文件中读入字符数据并置入缓冲区,而之后若使用read()方法,会先从缓冲区中进行读取。");

sb.append("\r\n 如果缓冲区数据不足,才会再从文件中读取,使用BufferedWriter时,写入的数据并不会先输出到目的地,而是先存储至缓冲区中。 ");

sb.append("\r\n 如果缓冲区中的数据满了,才会一次对目的地进行写出。");

sb.append("\r\n  从标准输入流System.in中直接读取使用者输入时,使用者每输入一个字符,System.in就读取一个字符。为了能一次读取一行使用者的输入,使用了BufferedReader来对使用者输入的字符进行缓冲。  ");

sb.append("\r\n  readLine()方法会在读取到使用者的换行字符时,再一次将整行字符串传入。");

bw.write(sb.toString());

//BufferedWriter换行的方法

bw.newLine();

bw.flush();

bw.close();

}

/**

* 使用BufferedReader读取文件

* @param file

* @throws IOException 

*/

private static void getFileByCharIoBufferedReader(File file) throws IOException {

BufferedReader br = new BufferedReader(new FileReader(file));

System.out.println("===============BufferedReader开始读取文件===================");

int length = -1;

String text = br.readLine();

while((text=br.readLine())!=null){

System.out.println(text);

}

System.out.println("===============BufferedReader读取文件完成===================");

}

/**

*使用BufferedOutputStream写入文件

* @throws IOException 

*/

private static void setFileByBufferedOutputStream(File file) throws IOException {

BufferedOutputStream bos = new  BufferedOutputStream(new FileOutputStream(file));

StringBuffer sb = new StringBuffer("使用BufferedWriter写入文件信息!");

sb.append("\r\n 在创建BufferedInputStream  实例时(BufferedOutputStream同上),需要先给定一个InputStream类型的实例(如:FileInputStream)。");

sb.append("\r\n 解释BufferedInputStream实现流程:其实质是实现了一个缓存装置,在读取源数据的时候其实还是用的InputStream来实现的。只是在读取之前给他们加了一个缓存区而已。");

sb.append("\r\n 注意这个缓存区默认是位数组,大小2048,当读文件的时候,BufferedInputStream会首先填满缓存区,然后在使用InputStream的read()方法的时候,把缓存数组中的数据在读到目的地");

sb.append("\r\n 对BufferedOutputStream,有一个默认512字节的缓存数组,当使用write()方法写数据时,实质上是先将数据写至缓存中,当缓存满时,在用write()方法把数据写入");

byte[] bytes = sb.toString().getBytes();

bos.write(bytes);

bos.flush();

bos.close();

}

/**

* 使用BufferedInputStream

* @throws IOException 

*/

private static void getFileByBufferedInputStream(File file) throws IOException {

BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file)); 

byte[] buffer = new byte[bis.available()];

int length = 0;

StringBuffer sb = new StringBuffer(0);

System.out.println("===============BufferedInputStream开始读取文件===================");

while((length=bis.read(buffer,0,buffer.length))!=-1){

System.out.println(new String(buffer));

}

System.out.println("===============BufferedInputStream读取文件结束===================");

}

}


本文出自 “HTMLDOM” 博客,转载请与作者联系!

Java IO文件流