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