java i/o操作

1. I/O介绍：

中I/O操作主要是指使用Java进行输入，输出操作. Java所有的I/O机制都是基于数据流进行输入输出，这些数据流表示了字符或者字节数据的流动序列。Java.io是大多数面向数据流的输入/输出类的主要软件包。此外，Java也对块传输提供支持，在核心库 java.nio中采用的便是块IO。流IO的好处是简单易用，缺点是效率较低。块IO效率很高，但编程比较复杂。 Java.io包中包含了流式I/O所需要的所有类。在java.io包中有四个基本类：InputStream、OutputStream及Reader、Writer。 Java的IO模型设计非常优秀，它使用Decorator模式，按功能划分Stream，您可以动态装配这些Stream，以便获得您需要的功能。例如，您需要一个具有缓冲的文件输入流，则应当组合使用FileInputStream和BufferedInputStream。



io流的四个基本类

java.io包中包含了流式I/O所需要的所有类。在java.io包中有四个基本类：InputStream、OutputStream及Reader、Writer类，它们分别处理字节流和字符流：

一、java io的开始：文件

public class Demo {

public static void main(String[] args){

File f = new File("e:\\file");

if(f.isDirectory()){
System.out.println(f.getPath());
}
}
}

代码中isDirectory()方法是判断文件是文件夹还是一个文件，getPath()方法是打印文件(这里指的是file文件夹)的路径。

文件删除

import java.io.File;

public class Demo11 {

public static void main(String[] args) {

File f = new File("f:\\demo.txt");

f.delete();
if(boo){
System.out.println("成功删除文件");
}
}
}

File类获取目录子目录

import java.io.File;
/**
* 获取一个目录下的所有子项
* @author Administrator
*/
public class FileDemo {
public static void main(String[] args){
/*
* 查看当前项目根目录下的所有子项
*/
File dir = new File(".");
//首先判断是否为一个目录
if(dir.isDirectory()){
//获取当前目录下的所有子项
File[] subs = dir.listFiles();
for(File sub : subs){
String name = sub.getName();
//目录是没有长度的
long length = sub.length();
System.out.println(name+":"+length);
}
}
}
}

FileFilter类

import java.io.File;
import java.io.FileFilter;

/**
* listFiles方法支持文件过滤器
*
* FileFilter接口，实现该接口需要实现抽象方法: boolean accept(File f)该方法要求我们定义过滤条件
* listFiles方法会将当前目录下满足accept方法的子项返回
* @author Administrator
*/
public class FileDemo2 {
public static void main(String[] args){
File dir = new File(".");
if(dir.isDirectory()){
//创建过滤器实例
FileFilter filter = new MyFilter();
//使用过滤器过滤子项
File[] subs  = dir.listFiles(filter);
for(File sub : subs){
System.out.println(
sub.getName());
}
}
}
}
class MyFilter implements FileFilter{
public boolean accept(File file) {
System.out.println(
"正在过滤:"+file.getName());
return file.getName().startsWith(".");
}
}

创建多级目录下的一个文件

import java.io.File;
import java.io.IOException;

/**
* 创建多级目录下的一个文件
* @author Administrator
*
*/
public class FileDemo3 {
public static void main(String[] args) throws IOException{
File file = new File(
"a"+File.separator+
"b"+File.separator+
"c"+File.separator+
"d"+File.separator+
"e"+File.separator+
"f"+File.separator+
"g"+File.separator+
"h.txt"
);
/*
* 创建文件时，应首先判断当前文件所在的
* 目录是否存在，因为若不存在，会抛出
* 异常的。
*/
/*
* File getParentFile()
* 获取当前文件或目录所在的父目录
*/
File parent = file.getParentFile();
if(!parent.exists()){
parent.mkdirs();
}
if(!file.exists()){
file.createNewFile();
System.out.println("文件创建完毕");
}

}
}

RandomAccessFile用于读写文件数据的类

mport java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;

public class RandomAccessFileDemo {
public static void main(String[] args) throws IOException{
/*
*  对项目跟目录下一个名为demo.dat
*  的文件内容进行读写
*/
RandomAccessFile raf
= new RandomAccessFile("demo.dat","rw");
//      File file = new File("demo.dat");
//      RandomAccessFile raf2= new RandomAccessFile(file,"rw");
int num = 97;
raf.write(num);
raf.close();// 使用IO后，一定要记得关闭
}
}

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
public class RandomAccessFileDemo2 {
public static void main(String[] args) throws IOException{
RandomAccessFile raf= new RandomAccessFile("demo.dat","r");
int i = raf.read();
System.out.println(i);
//再读取一个字节
i = raf.read();
System.out.println(i);
//再读取一个字节
i = raf.read();
System.out.println(i);
raf.close();
}
}

使用RandomAccessFile完成复制操作

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
public class RandomAccessFileDemo3 {
public static void main(String[] args) throws IOException{
/*
* 1:创建一个RandomAccessFile用于读取待复制的文件
* 2:创建一个RandomAccessFile用于将原文件的中数据写入该文件
* 3:循环从原文件中读取每一个字节并写入目标文件中
* 4:关闭两个RandomAccessFile
*/
long start = System.currentTimeMillis();
RandomAccessFile src= new RandomAccessFile("src.jpg","r");
RandomAccessFile des= new RandomAccessFile("copy.jpg","rw");
int d = -1;
while( (d = src.read()) != -1 ){
des.write(d);
}
System.out.println("拷贝完毕");
src.close();
des.close();
long end = System.currentTimeMillis();
System.out.println("耗时:"+(end-start)+"ms");
}
}

使用RandomAccessFile批量写出一组字节

import java.io.IOException;
import java.io.RandomAccessFile;
public class RandomAccessFileDemo4 {
public static void main(String[] args) throws IOException{
RandomAccessFile raf= new RandomAccessFile("test.txt","rw");
String str = "我爱北京天安门";
/* String的getBytes()方法:将当前字符串按照当前系统默认的字符集转换为对应的字节。*/
byte[] buf = str.getBytes("gbk");
raf.write(buf);
raf.close();
}
}

使用RandomAccessFile读取一个字节数组的数据

import java.io.IOException;
import java.io.RandomAccessFile;
import java.util.Arrays;
public class RandomAccessFileDemo5 {
public static void main(String[] args) throws IOException{
RandomAccessFile raf= new RandomAccessFile("test.txt","r");
/*int read(byte[] buf)一次尝试从文件中读取buf数组length个字节并从该数组的第一个位置处起存放实际读取到的字节。返回值为实际读取到的字节数*/
byte[] buf = new byte[50];
int len = raf.read(buf);
System.out.println(len);
System.out.println(Arrays.toString(buf));
/*从字节数组转换为对应的字符串*/
String str = new String(buf,"GBK");
System.out.println(str.trim());
raf.close();
}
}

使用RandomAccessFile基于缓存形式复制文件

import java.io.IOException;
import java.io.RandomAccessFile;
public class RandomAccessFileDemo6 {
public static void main(String[] args) throws IOException{
RandomAccessFile src= new RandomAccessFile("src.jpg","r");
RandomAccessFile des= new RandomAccessFile("copy.jpg","rw");
long start = System.currentTimeMillis();
byte[] buf = new byte[1024*10];
int len = -1;
/*int read(byte[] buf)若返回值为-1,表示没有数据可读了*/
while((len = src.read(buf))!=-1){
/*void write(byte[] b,int offset,int len)该方法的作用是将给定的字节数组中offset处开始，连续len个字节写出*/
des.write(buf,0,len);
}
long end = System.currentTimeMillis();
System.out.println("耗时:"+(end-start));
src.close();
des.close();
}
}

使用RandomAccessFile向文件中写入基本类型数据

import java.io.IOException;
import java.io.RandomAccessFile;
public class RandomAccessFileDemo7 {
public static void main(String[] args) throws IOException{
RandomAccessFile raf= new RandomAccessFile("raf.dat","rw");
int num = Integer.MAX_VALUE;
//连续写4个字节，将int值写出
raf.writeInt(num);
raf.writeDouble(1.4);
raf.writeLong(1234l);
raf.close();
}
}

使用RandomAccessFile读取基本类型数据

import java.io.IOException;
import java.io.RandomAccessFile;
public class RandomAccessFileDemo8 {
public static void main(String[] args) throws IOException{
RandomAccessFile raf= new RandomAccessFile("raf.dat","r");
int i = raf.readInt();
System.out.println(i);
double d = raf.readDouble();
System.out.println(d);
long l = raf.readLong();
System.out.println(l);
raf.close();
}
}

查看RandomAccessFile的指针位置

import java.io.IOException;
import java.io.RandomAccessFile;
public class RandomAccessFileDemo {
public static void main(String[] args) throws IOException{
RandomAccessFile raf= new RandomAccessFile("raf.dat","rw");
/*
* long getFilePointer()
* 获取当前RAF的指针位置
*/
long p = raf.getFilePointer();
System.out.println(p);//0
raf.write(97);//写一个字节
System.out.println(raf.getFilePointer());//1
raf.writeInt(1);//连续写4个字节
System.out.println(raf.getFilePointer());//5
/*
* 若想从文件的某个地方读取字节
* 需要先将指针移动到这个位置
* void seek(long position)
*/
raf.seek(0);
//通过raf读取一个字节
int n = raf.read();
System.out.println(n);
System.out.println(raf.getFilePointer());//1
raf.close();
}
}

import java.io.IOException;
import java.io.RandomAccessFile;
/**
* int skipBytes(int n)
* 该方法会尝试跳过n个字节，返回值为实际
* 跳过的字节数
*/
public class RandomAccessFileDemo2 {
public static void main(String[] args) throws IOException{
RandomAccessFile raf= new RandomAccessFile("raf.dat","r");//跳过1个字节
raf.skipBytes(1);
int i = raf.readInt();
System.out.println(i);
raf.close();
}
}

字节流InputStream/OutputStream

1. InputStream抽象类

InputStream 为字节输入流，它本身为一个抽象类，必须依靠其子类实现各种功能，此抽象类是表示字节输入流的所有类的超类。 继承自InputStream 的流都是向程序中输入数据的，且数据单位为字节（8bit）；

InputStream是输入字节数据用的类，所以InputStream类提供了3种重载的read方法.Inputstream类中的常用方法：

　　（1） public abstract int read( )：读取一个byte的数据，返回值是高位补0的int类型值。若返回值=-1说明没有读取到任何字节读取工作结束。

　　（2） public int read(byte b[ ])：读取b.length个字节的数据放到b数组中。返回值是读取的字节数。该方法实际上是调用下一个方法实现的

　　（3） public int read(byte b[ ], int off, int len)：从输入流中最多读取len个字节的数据，存放到偏移量为off的b数组中。

　　（4） public int available( )：返回输入流中可以读取的字节数。注意：若输入阻塞，当前线程将被挂起，如果InputStream对象调用这个方法的话，它只会返回0，这个方法必须由继承InputStream类的子类对象调用才有用，

　　（5） public long skip(long n)：忽略输入流中的n个字节，返回值是实际忽略的字节数, 跳过一些字节来读取

　　（6） public int close( ) ：我们在使用完后，必须对我们打开的流进行关闭.

　　


- 1） FileInputStream把一个文件作为InputStream，实现对文件的读取操作

- 2） ByteArrayInputStream：把内存中的一个缓冲区作为InputStream使用

- 3） StringBufferInputStream：把一个String对象作为InputStream

- 4） PipedInputStream：实现了pipe的概念，主要在线程中使用

- 5） SequenceInputStream：把多个InputStream合并为一个InputStream

2．OutputStream抽象类

　　OutputStream提供了3个write方法来做数据的输出，这个是和InputStream是相对应的。

　　1. public void write(byte b[ ])：将参数b中的字节写到输出流。

　　2. public void write(byte b[ ], int off, int len) ：将参数b的从偏移量off开始的len个字节写到输出流。

　　3. public abstract void write(int b) ：先将int转换为byte类型，把低字节写入到输出流中。

　　4. public void flush( ) : 将数据缓冲区中数据全部输出，并清空缓冲区。

　　5. public void close( ) : 关闭输出流并释放与流相关的系统资源。

　　


　　

- 1) ByteArrayOutputStream：把信息存入内存中的一个缓冲区中

- 2) FileOutputStream：把信息存入文件中

- 3) PipedOutputStream：实现了pipe的概念，主要在线程中使用

- 4) SequenceOutputStream：把多个OutStream合并为一个

流结束的判断：方法read()的返回值为-1时；readLine()的返回值为null时。

3. 文件输入流： FileInputStream类

FileInputStream可以使用read()方法一次读入一个字节，并以int类型返回，或者是使用read()方法时读入至一个byte数组，byte数组的元素有多少个，就读入多少个字节。在将整个文件读取完成或写入完毕的过程中，这么一个byte数组通常被当作缓冲区，因为这么一个byte数组通常扮演承接数据的中间角色。



作用：打开文件，从文件读数据到内存的类。

使用方法(1)

File fin=new File(“d:/abc.txt”);

FileInputStream in=new FileInputStream( fin);

使用方法(2)

FileInputStream in=new FileInputStream(“d: /abc.txt”);

程序举例：将fos.dat程序的内容显示在显示器上

import java.io.FileInputStream;
import java.io.IOException;

public class FisDemo {
public static void main(String[] args) throws IOException{
FileInputStream fis= new FileInputStream("fos.dat");
int i = fis.read();
System.out.println(i);//97
byte[] buf = new byte[21];
int len = fis.read(buf);
String str = new String(buf,"UTF-8");
System.out.println(str);
fis.close();
}
}

4.文件输出流:FileOutputStream类

　 作用：用来处理以文件作为数据输出目的数据流，或者说是从内存区读数据入文件

FileOutputStream类用来处理以文件作为数据输出目的数据流。

　　创建一个文件流对象有两种方法：

　　方式1：

　　 File f=new File (“d:/myjava/write.txt “);

FileOutputStream out= new FileOutputStream (f);

　　方式2：

　　FileOutputStream out=new FileOutputStream(“d:/myjava/write.txt “);

　　方式3：构造函数将 FileDescriptor()对象作为其参数。

　　FileDescriptor() fd=new FileDescriptor();

　　FileOutputStream f2=new FileOutputStream(fd);

　　方式4：构造函数将文件名作为其第一参数，将布尔值作为第二参数。

　　FileOutputStream f=new FileOutputStream(“d:/abc.txt”,true);

　　注意： （1）文件中写数据时，若文件已经存在，则覆盖存在的文件；

　　（2）的读/写操作结束时，应调用close方法关闭流。

程序举例：使用键盘输入一段文章，将文章保存在文件fos.dat中

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class FosDemo {
public static void main(String[] args) throws IOException{
FileOutputStream fos= new FileOutputStream("write.txt");
fos.write(97);
String str = "天安门上太阳升";
byte[] buf = str.getBytes("UTF-8");
fos.write(buf);
fos.close();
}
}

5. FileInputStream流和FileOutputStream的应用

package day02;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopyDemo {
public static void main(String[] args) throws IOException{
FileInputStream fis= new FileInputStream("src.jpg");
FileOutputStream fos= new FileOutputStream("copy2.jpg");
byte[] buf = new byte[10240];
int len = -1;
while((len=fis.read(buf))!=-1){
fos.write(buf,0,len);
}
System.out.println("复制完毕");
fis.close();
fos.close();
}
}

6. 缓冲输入输出流 BufferedInputStream/ BufferedOutputStream

计算机访问外部设备非常耗时。访问外存的频率越高，造成CPU闲置的概率就越大。为了减少访问外存的次数，应该在一次对外设的访问中，读写更多的数据。为此，除了程序和流节点间交换数据必需的读写机制外，还应该增加缓冲机制。缓冲流就是每一个数据流分配一个缓冲区，一个缓冲区就是一个临时存储数据的内存。这样可以减少访问硬盘的次数,提高传输效率。

BufferedInputStream:当向缓冲流写入数据时候，数据先写到缓冲区，待缓冲区写满后，系统一次性将数据发送给输出设备。

BufferedOutputStream :当从向缓冲流读取数据时候，系统先从缓冲区读出数据，待缓冲区为空时，系统再从输入设备读取数据到缓冲区。

1）将文件读入内存：

将BufferedInputStream与FileInputStream相接

FileInputStream in=new FileInputStream( “file1.txt ” );

BufferedInputStream bin=new BufferedInputStream( in);

2）将内存写入文件：

将BufferedOutputStream与 FileOutputStream相接

FileOutputStreamout=new FileOutputStream(“file1.txt”);

BufferedOutputStream bin=new BufferedInputStream(out);

3）键盘输入流读到内存

将BufferedReader与标准的数据流相接

InputStreamReader sin=new InputStreamReader (System.in) ；

BufferedReader bin=new BufferedReader(sin);

例子：

BufferedOutputStream

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class BosDemo {
public static void main(String[] args) throws IOException{
FileOutputStream fos= new FileOutputStream("bos.txt");
BufferedOutputStream bos= new BufferedOutputStream(fos);
String str = "伟大领袖毛主席";
byte[] buf = str.getBytes("UTF-8");
bos.write(buf);
/* 强制将当前缓冲流中的缓冲区中的数据全部写出，无论缓冲区是否被装满*/
bos.flush();
bos.close();//close时，也会自动调用一次flush
}
}

BufferedInputStream/ BufferedOutputStream加速文件拷贝

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopyDemo2 {
public static void main(String[] args)throws IOException {
FileInputStream fis= new FileInputStream("src.AVI");
BufferedInputStream bis= new BufferedInputStream(fis);
FileOutputStream fos= new FileOutputStream("copy2.AVI");
BufferedOutputStream bos= new BufferedOutputStream(fos);
int d = -1;
while ((d = bis.read()) != -1) {
bos.write(d);
}
System.out.println("复制完毕");
/* 关闭流时，只关闭最外层的高级流即可*/
bis.close();
bos.close();
}
}

7. 字符流Writer/Reader

Java中字符是采用Unicode标准，一个字符是16位，即一个字符使用两个字节来表示。为此，JAVA中引入了处理字符的流。

1. Reader抽象类

用于读取字符流的抽象类。子类必须实现的方法只有 read(char[], int, int) 和 close()。但是，多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能。



1) FileReader :与FileInputStream对应

主要用来读取字符文件，使用缺省的字符编码，有三种构造函数：

　　 (1）将文件名作为字符串 ：FileReader f=new FileReader(“c:/temp.txt”);

　　 (2）构造函数将File对象作为其参数。

　　 File f=new file(“c:/temp.txt”);

　　 FileReader f1=new FileReader(f);

　　 (3) 构造函数将FileDescriptor对象作为参数

　　 FileDescriptor() fd=new FileDescriptor()

　　 FileReader f2=new FileReader(fd);

2) CharArrayReader：与ByteArrayInputStream对应

　　3) StringReader : 与StringBufferInputStream对应

　　4) InputStreamReader

　　 从输入流读取字节，在将它们转换成字符:Public inputstreamReader(inputstream is);

　　5) FilterReader: 允许过滤字符流 protected filterReader(Reader r);

　　6) BufferReader :接受Reader对象作为参数，并对其添加字符缓冲器，使用readline()方法可以读取一行。 Public BufferReader(Reader r);

2. Writer抽象类

写入字符流的抽象类。子类必须实现的方法仅有 write(char[], int, int)、flush() 和 close()。但是，多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能。 其子类如下：



3 .InputStream与Reader差别 OutputStream与Writer差别

InputStream和OutputStream类处理的是字节流，数据流中的最小单位是字节(8个bit)

Reader与Writer处理的是字符流，在处理字符流时涉及了字符编码的转换问题

import java.io.*;
public class EncodeTest {
private static void readBuff(byte [] buff) throws IOException {
ByteArrayInputStream in =new ByteArrayInputStream(buff);
int data;
while((data=in.read())!=-1)   System.out.print(data+"  ");
System.out.println();     in.close();     }

public static void main(String args[]) throws IOException {
System.out.println("内存中采用unicode字符编码：" );
char   c='好';
int lowBit=c&0xFF;     int highBit=(c&0xFF00)>>8;
System.out.println(""+lowBit+"   "+highBit);
String s="好";
System.out.println("本地操作系统默认字符编码：");
readBuff(s.getBytes());
System.out.println("采用GBK字符编码：");
readBuff(s.getBytes("GBK"));
System.out.println("采用UTF-8字符编码：");
readBuff(s.getBytes("UTF-8"));      }
}

Reader类能够将输入流中采用其他编码类型的字符转换为Unicode字符，然后在内存中为其分配内存

Writer类能够将内存中的Unicode字符转换为其他编码类型的字符，再写到输出流中。

BufferedReader缓冲字符输入流可以以行为单位读取字符串

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class BufferReaderDemo {
public static void main(String[] args) throws IOException{
FileInputStream fis= new FileInputStream("pw.txt");
InputStreamReader isr= new InputStreamReader(fis,"UTF-8");
BufferedReader br= new BufferedReader(isr);
String str = null;
while((str=br.readLine())!=null){
System.out.println(str);
}
br.close();
}
}

InputStreamReader字符输入流用于读取字符数据的流

package day03;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
public class ISRDemo {
public static void main(String[] args)throws IOException{
FileInputStream fis= new FileInputStream("osw.txt");

InputStreamReader isr= new InputStreamReader(fis,"UTF-8");
int d = -1;
while((d = isr.read())!=-1){
char c = (char)d;
System.out.print(c);
}
isr.close();
}
}

OutStream

FileInputStream和FileOutputStream

FileInputStream

import java.io.FileInputStream;
import java.io.IOException;
/**
* FileInputStream 节点流用于从文件中读取字节的流
*/
public class FisDemo {
public static void main(String[] args) throws IOException{
FileInputStream fis= new FileInputStream("fos.dat");
int i = fis.read();
System.out.println(i);//97

byte[] buf = new byte[21];
int len = fis.read(buf);
String str = new String(buf,"UTF-8");
System.out.println(str);

fis.close();
}
}

学习地址：http://blog.csdn.net/hguisu/article/details/7418161

http://blog.csdn.net/yczz/article/details/38761237