java笔记-IO流-IO基本操作

IO(Input Output)流

1.IO流用来处理设备之间的数据传输

2.java对数据的操作是通过流的方式

3.java用于操作流的对象都在IO包中

4.流按照操作数据分为两种：字节流和字符流

5.流按照流向分为：输入流；输出流

常用基类：

1.字节流的抽象基类：

InputStream，OutputStream

2.字符流的抽象基类

Reader，Writer

创建FileWriter对象时，该对象一旦被初始化就必须明确被操作的文件，而且该文件会被创建到指定目录，如果该目录下已经有同名文件，将被覆盖，创建FileWriter的步骤就是明确数据要存放的位置。

将数据写入文件

import java.io.*;
class  FileWriterDemo
{
public static void main(String[] args) throws IOException
{
//创建FileWriter对象，该对象一旦被初始化就必须要明确被操作的文件，无空参。
//该文件会被创建到指定目录，如果该目录下已经有同名文件将会被覆盖。
//该过程就是明确数据存放的位置。存储过程可能存在异常，需try或者抛。
FileWriter fw=new FileWriter("Demo.txt");
//调用write方法将数据写到指定的文件中。
fw.write("hi cs !");
//刷新流中的数据到文件中。
//刷新流后，流可以继续使用，可以继续写入数据。
fw.flush();
//刷新数据后若不再使用，需关闭该流，执行如下操作会自动将流中的数据刷新到指定的文件中。
//关闭流后将不能再往里面写数据。
fw.close();
}
}

文件写异常捕捉

/*
文件的创建，写，关闭均有可能出现异常，需要对具体操作的语句进行异常捕捉。
*/
import java.io.*;
class  IOExceptionDemo
{
public static void main(String[] args)
{
FileWriter fw=null;
try{
//FileWriter fw=new FileWriter("Demo.txt");	//若在此处定义，则try执行完后fw作用域就没有了。需要在语句外定义。
fw=new FileWriter("Demo.txt",true);			//此处加入true表明，若Demo.txt存在则追加数据，若不存在，新建Demo.txt
fw.write("File write:\r\nIO Exception！");	//加入\r\n可以换行。
}
catch(Exception e){
System.out.println(e.toString());
}
finally{
//只有当fw不为空时才需要执行close()
if(fw!=null){
try{
//在执行close时仍有可能发生异常。
fw.close();
}
catch(Exception e){
System.out.println(e.toString());
}
}

}
}
}

读取文件

/*
文件的读操作。
*/
import java.io.*;
class  FileReaderDemo
{
public static void main(String[] args) throws IOException	//暂时在此处抛异常。
{
FileReader fr=new FileReader("FileReaderDemo.java");
//向字符数组中读字符。
char[] chs=new char[512];	//每次读取1k。
int num=0;
while((num=fr.read(chs))!=-1){
//若数据较多，最后可能装不满chs数组，所以输出时，只输出0-num的字符。
System.out.print(num+".....\n"+new String(chs,0,num));
}
fr.close();
}
}

文件复制和异常处理

import java.io.*;
class CopyFileDemo
{
public static void main(String[] args) throws IOException
{
copyFileSingle();
}
public static void copyFileSingle() throws IOException{
FileReader fr=null;
FileWriter fw=null;
try{
fr=new FileReader("CopyFileSingle.java");
fw=new FileWriter("CopyFileSingleCopy.java");
char[] ch=new char[512];
int num=0;
while((num=fr.read(ch))!=-1){
//最后读取的字符个数不一定是512个，所以从0-num
fw.write(ch,0,num);
}
fw.write("copy file!");
}
catch(IOException e){
throw new RuntimeException("读写失败："+e);
}
finally{
if(fr!=null)
try{
fr.close();
}
catch(IOException e){
throw new RuntimeException("读失败："+e);
}
if(fw!=null)
try{
fw.close();
}
catch(IOException e){
throw new RuntimeException("写失败："+e);
}
}

}
}

字符流的缓冲区

缓冲区的出现提高了对数据的读写能力，

对应类：

BufferedWriter

BufferedRead

缓冲区要结合流才可以使用

在流的基础上对流的功能进行了增强。

字符流读缓冲区

/*
字符流读缓冲区。
该缓冲区提供了一次读取一行的操作，方便了问吧的读取，当返回空的时候读
到文件的末尾，readLine();该方法返回换行符之前的内容，不保罗换行符。
*/
import java.io.*;
class  BufferedReadDemo
{
public static void main(String[] args) throws IOException
{
FileReader fr=new FileReader("buf.txt");
BufferedReader bufread=new BufferedReader(fr);
String str=null;
while((str=bufread.readLine())!=null){
System.out.println(str);
}
bufread.close();
}
}

字符流写缓冲区

/*
在创建缓冲区之前，必须要创建流对象。
缓冲区提供了一个跨平台的换行符，newLine();
*/
import java.io.*;
class  BufferedWriterDemo
{
public static void main(String[] args) throws IOException
{
FileWriter fw=new FileWriter("buf.txt");
BufferedWriter bufwriter=new BufferedWriter(fw);
bufwriter.write("hello .");
for(int x=0;x<6;x++){
bufwriter.write("hi");
bufwriter.flush();
bufwriter.newLine();
}
}
}

通过缓冲区复制文件

/*
通过缓冲区复制文件。
*/
import java.io.*;
class CopyDemo
{
public static void main(String[] args)
{
BufferedReader bufr=null;
BufferedWriter bufw=null;
try{
//新建读写缓冲区。
bufr=new BufferedReader(new FileReader("123.mp3"));
bufw=new BufferedWriter(new FileWriter("123Copy.mp3"));
String str=null;
//一行一行的读取。
while((str=bufr.readLine())!=null){
bufw.write(str);
//添加换行符。
//bufw.newLine();
//刷现缓冲区。
bufw.flush();
}
}
catch(IOException e){
throw new RuntimeException(e);
}
//最后必须执行的语句。
finally{
try{
if(bufr!=null){
bufr.close();
}
}
catch(IOException e){
throw new RuntimeException(e);
}
try{
if(bufw!=null){
bufw.close();
}
}
catch(IOException e){
throw new RuntimeException(e);
}
}
}
}

重写BuferedRead中的ReadLine方法

/*
重写BufferedRead中的ReadLine方法。
*/
import java.io.*;

class MyBufferedReaderDemo
{
public static void main(String[] args) throws IOException
{
MyBufferedReader bufr=null;

String str=null;
try{
//新建读写缓冲区。
bufr=new MyBufferedReader(new FileReader("buf.txt"));
//一行一行的读取。
while((str=bufr.MyReadLine())!=null){
System.out.println(str);
//System.out.println("hello cs");

//str.flush();
}
}
catch(IOException e){
throw new RuntimeException(e);
}
//最后必须执行的语句。
finally{
try{
if(bufr!=null){
bufr.MyClose();
}
}
catch(IOException e){
throw new RuntimeException(e);
}
}
}
}
class MyBufferedReader
{
private FileReader fr;
//在创建对象时，直接传递参数。
MyBufferedReader(FileReader fr){
this.fr=fr;
}
public String MyReadLine()throws IOException{
int ch=0;
//使用字符缓冲区存储数据。
StringBuilder sb=new StringBuilder();
//判断是否仍有数据可读。
while((ch=fr.read())!=-1){
//判断行末尾符号
if(ch=='\r')
continue;
//判断行末尾符号
if(ch=='\n')
//读取到换行时，将字符缓冲区的数据转化为字符串。
return sb.toString();
else{
//不是行尾，则向缓冲区中追加数据。
sb.append((char)ch);
}
}
//最后判断时，文件的结尾不一定有‘\n’换行符号，此时需要在末尾判断
//字符流缓冲区中是否有数据，可根据数据流的长度判读。妙呀！！！！
if(sb.length()!=0){
return sb.toString();
}
return null;
}
public void MyClose()throws IOException{
fr.close();
}
}