标签：
I/O：（输入/输出）指的是计算机与外部世界，或者一个与计算机其余部分的接口。它对任何计算机系统都非常关键。
Java类库中有大量的类，帮助我们从不同的设备读取数据并保存或输出到不同的设备中。
这些类统一放在java.io包java.nio包中，统称JavaI/O系统。（I：Input输入；O：Output输出）
流（Stream）：
流是java I/O的基础，java语言对I/O的一个最基本的抽象
基本特性：含有流质，有方向（流质是数据，方向就是读或写）。
对流的读或写就是针对设备进行信息的输入输出。
流按方向分：
输入流：（继承自InputStream或Reader）；
输出流：（继承自OutputStream或Writer）；
处理数据的最小单位分：
字节流：以byte为最小单位进行数据传送（继承自InputStream或OutputStream）；
字符流：以char为最小单位进行数据传送（继承自Reader或Writer）；
按功能分：
节点流：（低级流）节点流是可以直接从/向一个特定的数据源（磁盘文件、内存、网络等）读/写数据的流。
处理流：（高级流）不直接连接到设备，而是连接在已存在的流（节点流或处理流之上）通过对数据的处理为程序提供更强大的读写功能；
InputStream类层次
OutputStream类层次
Reader类层次
Writer类层次
1.创建File类对象:
File f;
f = new File("Test.java");
f = new File("E:\\ex\\","Test.java");
2.将目录也当作文件处理File类中提供了实现目录管理功能的方法:
File path = new File("E:\\ex\\");
File f = new File(path, "Test.java");
方法：
f.getName()：返回文件名 temp.dat
f.getParent()：返回文件所在目录名 data
f.getPath()：返回文件路径 data\temp.dat
f.getAbsolutePath()：返回绝对路径 …\data\temp.dat
f.exists()：文件是否存在
f.canWrite(), f.canRead()：文件是否可写、读
f.isFile(), f.isDirectory()：是否为文件或目录
f.lastModified(), f.length(), f.delete()：文件的最后修改日期、长度；删除文件
f.mkdir(), f.list()：创建一个目录；列出目录下所有的文件
一些方法使用：
package com.lovo;
import java.io.File;
import java.io.IOException;
import java.util.Date;
/**
* File类测试
*
*/
public class FileTest {
public static void main(String[] args) {
// 创建File对象
File file = new File("E:\\jg\\exercise_bak.txt");
// 能否读
System.out.println("能否读：" + file.canRead());
// 删除
System.out.println("删除成功：" + file.delete());
// 重新创建文件对象
file = new File("E:\\jg\\exercise_bak.txt");
// 判断文件是否存在
System.out.println("是否存在：" + file.exists());
// 目录或文件名称
System.out.println("名称：" + file.getName());
// 是否目录、文件
System.out.println("是否目录：" + file.isDirectory());
System.out.println("是否文件：" + file.isFile());
// 最后一次修改时间
System.out.println("最后一次修改时间："
+ new Date(file.lastModified()));
// 文件大小
System.out.println("文件大小：" + file.length());
// 重新创建File对象
file = new File("E:\\jg");
System.out.println("文件目录列表：");
// 返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录
String[] list = file.list();
for (String string : list) {
System.out.println(string);
}
System.out.println("*******************************");
// 返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件对象
File[] files = file.listFiles();
for (File item : files) {
if (item.isDirectory()) { // 当前File对象为目录，则遍历该目录下所有子目录与文件
System.out.println(item.getName() + " 目录下子目录与文件：");
String[] it = item.list();
for (String i : it) {
System.out.println(i);
}
System.out.println("*******************************");
continue;
}
System.out.println(item.getName() + " 文件");
}
// 重新创建File对象
file = new File("E:\\jg\\test\\demo\\test.txt");
if (!file.exists()) { // 文件不存在
// 获取文件路径
File dir = file.getParentFile();
if (!dir.exists()) { // 目录不存在，则创建路径中所有不存在的目录
dir.mkdirs();
}
try {
// 创建空文件
System.out.println("文件是否创建成功：" + file.createNewFile());
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
package com.lovo;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
/**
* 字节输入输出流测试
*
*/
public class IOTest {
public static void main(String[] args) {
StringBuffer buffer = new StringBuffer(); // 字符串缓冲
/* 输入流 */
InputStream in = null;
try {
// 1. 打开输入流
in = new FileInputStream("E:\\jg\\exercise.txt");
// 2. 读取
// byte[] b = new byte[128];
byte[] b = new byte[1024 * 4];
int len = in.read(b); // 返回读取到的字节数，返回-1表示读取到流结尾
while(len != -1){
buffer.append(new String(b, 0, len)); // 将读取到的字节解析为String追加到缓冲
len = in.read(b);
}
// System.out.println("读到" + len + "字节的数据");
System.out.println(buffer.toString());
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
// 3. 释放资源，关闭输入流
if (in != null){
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
/* 输出流 */
OutputStream out = null;
try {
File file = new File("D:\\test\\demo\\test.txt");
if (!file.getParentFile().exists()){ // 文件路径不存在，则创建路径中所有不存在的目录
file.getParentFile().mkdirs();
}
// 1. 打开输出流
out = new FileOutputStream(file);
// 2. 写
out.write(buffer.toString().getBytes());
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
// 3. 释放输出流资源
if (out != null){
try {
out.flush();
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
package com.lovo;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
/**
* 字符输入输出流测试
*
*/
public class IOTest2 {
public static void main(String[] args) {
StringBuffer buffer = new StringBuffer();
/* 输入流 */
Reader reader = null;
try {
// 1. 打开流
reader = new FileReader("E:\\jg\\exercise.txt");
// 2. 读取
char[] ch = new char[128]; // 缓冲区
int len;
do {
len = reader.read(ch);
if (len == -1)
break;
buffer.append(new String(ch, 0, len));
} while (len != -1);
System.out.println(buffer.toString());
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
// 3. 释放资源
if (reader != null) {
try {
reader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
/* 输出流 */
Writer writer = null;
try {
// 1. 打开流
writer = new FileWriter("d:\\test.txt");
// 2. 写入
writer.write(buffer.toString());
} catch (IOException e) {
e.printStackTrace();
} finally {
// 3. 释放资源
if (writer != null) {
try {
writer.flush();
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
ex:
import java.io.*;
public class FileTest{
public static void main(String[] str){
File f = new File("E:\\Workspace\\aaa.txt");
//判断是否存在该文件
if (!f.exists()){
System.out.println("file is not exist");
try {
f.createNewFile();//不存在就创建新的文件
} catch (IOException e) {
e.printStackTrace();
}
}
File f1 = new File("E:\\Workspace\\aaa1\\sdfsdf\\asdf");
if (f1.mkdir()){ //创建目录
System.out.println("yes");
}
else{
System.out.println("errors ");
}
}
}
ex2:
import java.io.*;
//浏览当前目录下的所有文件和目录
class FileDirectory{
public static void main( String[] args ) {
try {
File f1 = new File("");
String ss = f1.getAbsolutePath();
System.out.println("ss= " + ss);
File f = new File(ss);
if( f.isDirectory() ) {
//获取目录下所有的文件列表
File[] files = f.listFiles();
for( int i=0; i<files.length; i++ ) {
if( files[ i ].isDirectory() ) {
System.out.println( "<dir> " + files[ i ].getName() );
}
else {
System.out.println( files[ i ].getName() );
}
}
}
}
catch( Exception e ) {
e.printStackTrace();
}
}
}
import java.io.*;
class SuperTest{
public static void main(String args[]) {
File dir = new File("E:\\Workspace\\Java\\test20111108"); // 用File 对象表示一个目录
Filter filter = new Filter("txt"); // 生成一个名为java的过滤器
System.out.println("list java files in directory " + dir);
String[] files = dir.list(filter); // 列出目录dir下，文件后缀名为txt的所有文件
for (int i = 0; i < files.length; i++) {
File f = new File(dir, files[i]); // 为目录dir 下的文件或目录创建一个File 对象
if (f.isFile()) // 如果该对象为后缀为java的文件，则打印文件名
System.out.println("file: " + f);
else
System.out.println("sub directory " + f); // 如果是目录则打印目录名
}
}
}
class Filter implements FilenameFilter {
String extent;
Filter(String extent) {
this.extent = extent;
}
public boolean accept(File dir, String name) {
return name.endsWith("." + extent); //返回文件的后缀名
}
}
ex4:
import java.io.*;
/**
*把一个文件的所有内容写到另外一个文件中
*/
class FileStreamTest{
public static void main(String args[]) {
try {
File inFile=new File("test1.txt");
File outFile=new File("test2.txt");
FileInputStream fis=new FileInputStream(inFile);
FileOutputStream fos=new FileOutputStream(outFile);
int c;
while((c=fis.read())!=-1) //读取一个字节
{
fos.write(c);
}
fis.close();
fos.close();
}catch(FileNotFoundException e) {
System.out.println("FileStreamsTest: "+e);
}catch(IOException e) {
System.err.println("FileStreamsTest: "+e);
}
}
}
import java.io.*;
class CopyFileTest{
public static void main(String args[]) {
CopyFileTest cf = new CopyFileTest ();
cf.copyFile("test1.txt","test3.txt");
}
public boolean copyFile(String src,String des){
File srcFile,desFile;
srcFile = new File(src);
desFile = new File(des);
FileInputStream fis = null;
FileOutputStream fos = null;
try{
desFile.createNewFile();
fis = new FileInputStream(srcFile);
fos = new FileOutputStream(desFile);//覆盖
// fos = new FileOutputStream(desFile，true);//追加
int bytesRead;
byte[] buf = new byte[4 * 1024]; // 4K buffer
while((bytesRead=fis.read(buf))!=-1){
fos.write(buf,0,bytesRead);
}
fos.flush();
fos.close();
fis.close();
}catch(IOException e){
System.out.println(e);
return false;
}
return true;
}
}
如果只是在尾部追加，而不是覆盖需要调用FileOutputStream(“file”,true)就Ok了，对于字符流文件就是FileWriter(“file”,true)就OK乐。
父类过滤流：
FilterInputStream(InputStream in);
FilterOutputStream(OutputStream out);
过滤流—缓冲流
类BufferedInputStream和BufferedOutputStream继承FilterInputStream和FilterOutputStream，实现了带缓冲的过滤流，它提供了缓冲机制，把任意的I/O流“捆绑”到缓冲流上，可以提高该I/O流的读取效率，在初始化时，除了要指定所连接的I/O流之外，还可以指定缓冲区的大小。
在读写的同时对数据缓存，这样避免每次读写数据都要进行实际的物理读写操作，在用BufferdOutputStream输出时，数据先输入缓冲区，当缓冲区满的时再写入连接的输出流，可以调用flush()来清空缓冲区。
import java.io.*;
class SuperTest{
public static void main(String args[]) {
try {
File inFile = new File("test1.txt");
File outFile = new File("test4.txt");
BufferedInputStream bufFis=new BufferedInputStream(new FileInputStream(inFile),256);
BufferedOutputStream bufFos=new BufferedOutputStream(new FileOutputStream(outFile),256);
int len;
byte bArray[]=new byte[256];
do{
System.out.println("while");
len = bufFis.read(bArray);
bufFos.write(bArray,0,len);
System.out.println("len: " +len);
}while (len==256);
bufFis.close();
bufFos.close();
} catch (FileNotFoundException e) {
System.out.println("FileStreamsTest: " + e);
} catch (IOException e) {
System.err.println("FileStreamsTest: " + e);
}
}
}
过滤流—数据流
DataInputStream和DataOutputStream, 继承FilterInputStream和FilterOutputStream，可以用来与计算机无关的格式读写JAVA的基本数据类型以及String对象。
readBoolean() 读一字节，非零为真
readByte() 以8位读字节
readChar() 读Unicode字符
readInt() 读整数值
writeChar(int v) 把字符写进输出流
writeLong(long v) 把长整写进输出流
writeInt(int v) 把整数写进输出流
数据输出流可以是一个已经建立好的输入数据流对象,例如网络的连结,文件等。数据流可通过如下方式建立。
FileInputStream fis = new FileInputStream("file1.txt");
FileOutputStream fos = new FileOutputStream("file2.txt");
DataInputStream dis = new DataInputStream(fis);
DataOutputStream dos = new DataOutputStream(fos);
import java.io.*;
class DataStreamIOTest{
public static void main(String args[]) throws IOException
{
FileOutputStream fos = new FileOutputStream("a.txt");
DataOutputStream dos = new DataOutputStream(fos);
try {
dos.writeBoolean(true);
dos.writeByte((byte) 123);
dos.writeChar(‘J‘);
dos.writeDouble(3.141592654);
dos.writeFloat(2.7182f);
dos.writeInt(1234567890);
dos.writeLong(998877665544332211L);
dos.writeShort((short) 11223);
} finally {
dos.close();
}
FileInputStream fis = new FileInputStream("a.txt");
DataInputStream dis = new DataInputStream(fis);
try {
System.out.println("\t " + dis.readBoolean());
System.out.println("\t " + dis.readByte());
System.out.println("\t " + dis.readChar());
System.out.println("\t " + dis.readDouble());
System.out.println("\t " + dis.readFloat());
System.out.println("\t " + dis.readInt());
System.out.println("\t " + dis.readLong());
System.out.println("\t " + dis.readShort());
} finally {
dis.close();
}
}
}//需要注意的是必须throws IOException才可以编译通过。
字符流
例子：利用FileWriter来写文件
try
{
FileWriter fw = new FileWriter("mydata.txt");
PrintWriter out = new PrintWriter(fw);
out.print("面朝大海，");
out.println("春暖花开！");
out.println("环境美好!！");
out.close();
fw.close();
}catch(IOException e)
{
e.printStackTrace();
}
例子：字符缓冲流BufferedReader
import java.io.*;
class SuperTest{
public static void main(String args[]) throws IOException
{
File file = new File("mydata.txt");
try {
BufferedReader in = new BufferedReader(new FileReader(file));
String s;
s = in.readLine();
while ( s != null ) {
System.out.println("Read: " + s);
s = in.readLine();
}
in.close();
} catch (FileNotFoundException e1) {
System.err.println("File not found: " + file);
} catch (IOException e2) {
e2.printStackTrace();
}
}
}
例子：拷贝（FileReader和FileWriter）
try {
FileReader input = new FileReader(args[0]);
FileWriter output = new FileWriter(args[1]);
char[] buffer = new char[128];
int charsRead;
charsRead = input.read(buffer);
while ( charsRead != -1 )
{
output.write(buffer, 0, charsRead);
charsRead = input.read(buffer);
}
input.close();
output.close();
} catch (IOException e)
{
e.printStackTrace();
}
}
例子：拷贝(BufferedWriter)
try {
FileReader input = new FileReader(args[0]);
BufferedReader bufInput = new BufferedReader(input);
FileWriter output = new FileWriter(args[1]);
BufferedWriter bufOutput = new BufferedWriter(output);
String line;
line = bufInput.readLine();
while ( line != null )
{
bufOutput.write(line, 0, line.length());
bufOutput.newLine();
line = bufInput.readLine();
}
bufInput.close();
bufOutput.close();
}
catch (IOException e)
{
e.printStackTrace();
}
随机存取文件流--RandomAccessFile
1 RandomAccessFile是一种特殊的文件流，可以用它在文件的任何地方查找或者插入数据
2 RandomAccessFile同时实现了DataInput和DataOutput接口，所以可以用它来读/写文件
3构造器:
RandomAccessFile(java.io.File f,String mode)
RandomAccessFile(String file,String mode)
4 mode可以为”r”或”rw”
方法：
1 readXXX()或writeXXX()：
如ReadInt(), ReadLine(), WriteChar(), WriteDouble()等
2 int skipBytes(int n)：将指针向下移动若干字节
3 length()：返回文件长度
4 long getFilePointer()：返回指针当前位置
5 void seek(long pos)：将指针调到所需位置
import java.io.*;
import java.util.*;
class RandomAccessFileTest{
public static void main(String args[])
{
try{
File logfile=new File("mydata.txt");
if(logfile.exists())
{
RandomAccessFile raf=new RandomAccessFile(logfile,"rw");
System.out.println("leghth = " + raf.length());
raf.seek(raf.length());
for(int i=0;i<5;i++)
{
raf.writeBytes("Write "+new Date()+ "\r\n");
}
raf.seek(0);
String x=raf.readLine();
while(x!=null)
{
System.out.println(x);
x=raf.readLine();
}
raf.close();
}
}catch(IOException e){
e.printStackTrace();
}
}
}
标签：
原文地址：http://www.cnblogs.com/Spirit612/p/4448783.html
