首先开篇立论 什么是IO流:设备之间的数据传输。java中对于数据的输入(input)/输出(output)操作以”流(stream)” 的方式进行,所以就叫IO流
但是在记输入/输出流之前,先记一个类:File类
File类能创建,删除,重命名文件和目录,但是不能修改(访问)文件本身的内容,要修改问价的内容还得需要输入/输出流
File对象可以作为参数传递给流的构造函数
常用的构造方法
public File(String pathname)
public File(String parent,String child) parent为父路径,child为子路径创建File对象
注释:系统路径分隔符,在UNIX中,此字段为‘/’,在Windows中,为‘\\’
举个例子
```
package ligang.com;
import java.io.File;
public class FileTset {
public static void main(String[] args) {
File file=new File("Hello World.txt ");//文件放在项目的目录文件夹下
0 File file1 =new File("D\\AAA","1.txt");//文件放在指定的“D:AAA”目录中
}
}
在写IO流之前,我先把什么叫输入(input)/输出(output)
看图
文件是由字符或字节构成的,在此基础上再分为输入流/输出流的
所有的文件类都是在这个四个基类的基础上扩展继承的
看图
FileInputStream(文件字节输入流)
FileOutputStream(文件字节输出流)
FileReader(文件字符输入流)
FileWriter(文件字符输出流)
来个例子
package ligang.com;
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.Reader;
import java.io.Writer;
import org.omg.CORBA.PUBLIC_MEMBER;
public class FileText {
public static void main(String[] args) {
//FileOutputStream文件字节输出流
File file1=new File("Hello World");//创建文件
FileOutputStream fos=null;//定义字节文件容器,刚开始为空
try {
fos=new FileOutputStream(file1);
byte [] b="i love my home i love my china".getBytes();
fos.write(b);//向文件容器中写入数据
} catch (Exception e) {
e.printStackTrace();
}
finally {
try {
fos.close();//gc进程管不了文件,所以文件得自己回收
} catch (IOException e) {
e.printStackTrace();
}
}
//FileInputStream(文件字节输入流)
File file=new File("Hello World");
//将此File类的对象作为形参传递给InputStream的构造器中
FileInputStream fis=null;
try {
fis = new FileInputStream(file);
int i;
//通过调用read()方法将文件中的数据读入
while((i=fis.read())!=-1){
System.out.print((char)i);
}
}catch (IOException e) {
e.printStackTrace();
}finally {
try {
//关闭现有的流
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
//FileWriter输入字符流
Writer w=null;
try {
w=new FileWriter("1.txt");
w.write("what's,your name?");
} catch (IOException e1) {
e1.printStackTrace();
}
finally{
try {
w.close();
} catch (IOException e) {
e.printStackTrace();
}
}
//FileReade输出字符流
Reader r = null;
try {
r = new FileReader("1.txt");
System.out.println();
int b = 0;
while ((b = r.read()) != -1) {
//输出字符
System.out.print((char)b);
}
}catch(FileNotFoundException e) {
e.printStackTrace();
}catch(IOException e) {
e.printStackTrace();
}finally {
try {
if (r != null) {
r.close();
}
}catch(IOException e) {}
}
}
}
显示结果
i love my home i love my china
what's,your name?
缓冲流
主要是为了提高效率而存在的,减少物理读取次数
主要有
BufferedInputStream
BufferedOutputStream
BufferedReader
BufferedWriter
BufferedReader提供了实用方法readLine(),可以直接读取一行,BufferWriter提供了newLine()可以写换行符。
多记点点:为什么说缓冲流会提高效率
采用BufferedInputStream对InputStream进行装饰,BufferedInputStream会将数据先读到缓存里,Java程序再次读取数据时,直接到缓存中读取,减少Java程序物理读取的次数,提高性能
采用BufferedOutputStream对FileOutputStream进行装饰,每次写文件的时候,先放到缓存了,然后再一次性的将缓存中的内容保存到文件中,这样会减少写物理磁盘的次数,提高性能
其他的同理可证^_^!!!
看代码
package ligang.com;
import java.io.*;
import org.omg.CORBA_2_3.portable.OutputStream;
public class Bufferd {
public static void main(String[] args) {
/*
* 用BufferedInputStream与BufferedOutputStream实现文件的快速复制
*/
InputStream is=null;
OutputStream os=null;
try {
BufferedInputStream fis=new BufferedInputStream(new FileInputStream("1.txt"));
BufferedOutputStream fos=new BufferedOutputStream(new FileOutputStream("1.txt.bak"));
int b = 0;
try {
while ((b =fis.read()) != -1) {
fos.write(b);
}
fos.flush();
System.out.println("文件复制完毕!!");
} catch (IOException e) {
e.printStackTrace();
}
finally {
try {
if(fos!=null)
fos.close();
if(fis!=null)
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}
/**
* 用BufferedReader与BufferedWriter实现文件的快速复制
*/
BufferedReader is1 = null;
BufferedWriter os1= null;
try {
is1= new BufferedReader(new FileReader("Hello World"));
os1= new BufferedWriter(new FileWriter("12.txt"));
String s = null;
while ((s = is1.readLine()) != null) {
os1.newLine();
os1.write(s);
//可以采用如下方法换行
os1.newLine();
}
System.out.println("文件复制完毕!");
}catch(FileNotFoundException e) {
e.printStackTrace();
}catch(IOException e) {
e.printStackTrace();
}finally {
try {
if (is1 != null) {
is1.close();
}
if (os1!= null) {
//在close前会先调用flush
os1.close();
}
}catch(IOException e) {
e.printStackTrace();
}
}
}}
简单的复制操作,一个用缓冲字节流实现,一个用缓冲字符流实现,很简单的操作,却让我摸了好久。。。。
转换流:InputStreamReader主要是将字节流输入流转换成字符输入流
OutputStreamWriter主要是将字节流输出流转换成字符输出流
举个小例子
package ligang.com;
import java.io.*;
import javax.activation.FileDataSource;
public class zhuanhuanliu {
/**
* 将字节流输入流转换成字符输入流
*/
public static void main(String[] args) {
BufferedReader fis=null;
try {
fis=new BufferedReader(
new InputStreamReader(
new FileInputStream("12.txt")));//首先取得输入字节流,再转成输入字符流,最后转换成输出字符缓冲流
String s=null;
try {
while((s=fis.readLine())!=null){
System.out.println(s);
}
} catch (IOException e) {
e.printStackTrace();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}
finally{
try {
if(fis!=null)
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 将字节流输出流转换成字符输出流
*/
BufferedWriter fis0 = null;
try {
fis0=new BufferedWriter(
new OutputStreamWriter(
new FileOutputStream("1.txt")));//首先取得字节输出流,再转成字符输出流,最后转成字符缓冲输出流
try {
fis0.write("my name is xiao ganggang");
fis0.newLine();
fis0.write("nice to me to you!");
} catch (IOException e) {
e.printStackTrace();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}
finally{
try {
if(fis0!=null)
fis0.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
System.out其实对应的就是PrintStream,默认输出到控制台,我们可以重定向它的输出,可以定向到文件,也就是执行System.out.println()不输出到屏幕,而输出到文件
举个小例子
package ligang.com;
import java.io.*;
import javax.activation.FileDataSource;
public class rou {
public static void main(String[] args) {
OutputStream os = null;
try {
os=new FileOutputStream("1.txt");
System.setOut(new PrintStream(os));`//将输出改为指定的文件`
System.out.println("世界你好,世界午安!!");
} catch (FileNotFoundException e) {
e.printStackTrace();
}finally {
try {
if (os!=null) {
os.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
也可以将屏幕的输入到文件中
举个小例子
package ligang.com;
import java.io.*;
import javax.activation.FileDataSource;
public class rou {
public static void main(String[] args) {
OutputStream os1 = null;
BufferedReader os = null;
try {
os1=new FileOutputStream("1.txt");
System.setOut(new PrintStream(os1));//将输出改为指定的文件
} catch (FileNotFoundException e1) {
e1.printStackTrace();
}
os=new BufferedReader(
new InputStreamReader(System.in));//将从键盘得到数据放到指定文件中
String s=null;
try {
while((s=os.readLine())!=null){
System.out.println(s);//这里相当与本是输出到终端的,但现在输出到os1的文件中去
if("w".equals(s))
break;
}
} catch (IOException e) {
e.printStackTrace();
}
finally {
try {
if(os!=null)
os.close();
if(os1!=null)
os1.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
还有对象流。。貌似有点多了,
对象流可以将Java对象转换成二进制写入磁盘,这个过程通常叫做序列化,并且还可以从磁盘读出完整的Java对象,而这个过程叫做反序列化。
对象流主要包括:ObjectInputStream和ObjectOutputStream
而实现序列化和反序列化,就需要实现java.io.Serializable 接口,但他没有任何方法,只是一种标记接口
我不想写了。。。
到这儿