黑马程序员 java_IO流笔记(一)

-------android培训 、java培训、期待与您交流！
----------



IO流常用基类

1 字节流的抽象基类

inputStream,OutputStream.

2 字符流的抽象基类

ReaderWriter

注意 由这四个类派生出来的子类名称都是以其父类

作为子类名的后缀

如 InputStream的子类FileInputStream

Reader 的子类FileReader

IO程序的书写

导入IO包中的类

进行IO异常处理

在finally中对流进行关闭

思考

1有了垃圾回收机制为什么还要调用close方法进行关闭

一说 流不但在内存中分配了空间，也在操作系统中占有了资源回收机制是从内存中回收不适用的对象，但对操作系统分配的资源是无能为力的。 所以要调用close方法来通知OS来释放这个资源 就是java已经垃圾回收了这个刘，但是系统根本就不知道什么时候关闭这个刘，所以我们要手动的去关闭。

一说 java的垃圾回收是用户没有办法控制的，它会在不确定的时候出发，而且java不保证在整个程序运行期一定会出发垃圾回收，所以对于流，socket等之类的资源用完之后一定要关闭，而且垃圾回收机制对于socket thread之类的对象及时引用计数器为0了，只要在活动的情况下，也不会被回收。

2为什么IO异常一定要处理。

如果不异常处理，当读到一个文件的时候出现了错误，那么后面的也就会执行不到了，所以一定要异常处理。

字符流

字符流继承体系简图

创建字符流对象，建立数据存放文件

创建一个FileWriter对象，该对象以初始化就必须要明确被操作的文件

该文件被创建到了指定目录下，如果该目录下已有同名文件，将被覆盖。

其实该步就是在明确数据存放的目的地。

FileWriter fw = new FileWriter(“Test.txt”);

调用流对象写入方法，将数据写入流

fw.write(“text”);

关闭资源并将流中的数据清空到文件中

fw.close();

关闭流资源，但是关闭之前会刷新一次内部的缓冲中的数据将数据刷到目的地中。

和 flush区别，flush刷新后流可以继续使用，close刷新后将流关闭

(就是在调用fw.write("aa")写不进去数据了。)。

java本身不能往文件里面写数据的，要调用系统中的内容来写入，

调用完了之后要释放出来，就是用close。

不写close方法会有什么结果

流没办法关闭， 不能将流中的数据刷到文件中

如果想在原有文件上继续加入新的数据呢

FileWriter fw = new FileWriter(“Test.txt”,true);//代表从一个文件的末尾处追加

fw.writer(“newdata”);

fw.close();

FileWriter fw = null;
try{
fw = new FileWriter("Test.txt"); //写入文件的位置
fw.write("text"); //写入内容
}
catch (IOException e){
System.out.println(e.toString());
}
finally{
If(fw!=null)
try{
fw.close(); //写入完成关闭
}
catch (IOException e){
System.out.println(e.toString());
}
}

字符流 读取文件

建立一个流对象，将已存在的一个文件加载进流

FileReaderfr= new FileReader(“Test.txt”);

创建一个临时存放数据的数组

Char[] ch = new char[1024];

调用流对象的读取方法将流中的数据读入到数组中

fr.read(ch);

思考

在加载文件时候是否是将文件全部加载进流

不是比如迅雷在下载的时候就是多线程下载，每个线程只加载一部分

为什么要定义数组，要定义多大呢

用来处理接收的字节流数据，定义为字节的整数倍

import java.io.*;
class FileReaderDemo
{
public static void main(String[] args)
{
// 创建一个文件流对象，和指定名称的文件相关联
//要保证该文件的已经存在的，如果不存在会发生异常FileNotFoundException
//System.out.println("Hello World!");
//调用读取流对象的read方法
FileReader fr = null;
try
{
fr =  new FileReader("demo.txt");
// read()方法 一次读一个字符，而且会自动往下读。
int ch = 0;
while ((ch=fr.read())!=-1)
{
System.out.println("ch="+(char)ch);
}

/* while (true)
{

int ch = fr.read();
if(ch==-1)
break;
System.out.println("ch="+(char)ch);
}
*/

}
catch (IOException e)
{
System.out.println(e.toString());

}
finally
{
try
{
if(fr!=null)
fr.close();
}
catch (IOException e)
{
System.out.println(e.toString());

}
}
}
}

注意

定义文件路径是，可以使用/或者\\ 在创建一个文件时，如果目录下有同名文件将被覆盖

在读取文件时，必须不走帐该文件已存在，否则出现异常

练习Copy一个文本文件。

将C盘一个文本文件复制到D盘。

复制的原理：

其实就是将C盘下的文件数据存储到D盘的一个文件中。

步骤：

1，在D盘创建一个文件。用于存储C盘文件中的数据。

2，定义读取流和C盘文件关联。

3，通过不断的读写完成数据存储。

4，关闭资源。

import java.io.*;

class CopyText
{
public static void main(String[] args) throws IOException
{
copy_2();
}

public static void copy_2()
{
FileWriter fw = null;
FileReader fr = null;
try
{
//开两个流
fw = new FileWriter("SystemDemo_copy.txt");//目的为该类所在的文件（本地文件） 复制后的文件名SystemDemo_copy.txt
fr = new FileReader("SystemDemo.java");//本地源文件名SystemDemo.java

char[] buf = new char[1024];//数组存储方式 在内存里开一数组

int len = 0;

while((len=fr.read(buf))!=-1)//把fr.read()写入流中的数据整到数组里面
{
fw.write(buf,0,len);//只放有数据的长度 fr.writ()把数组中的数据整到写入流中
}
}
catch (IOException e)
{
throw new RuntimeException("读写失败");

}
finally
{
//流越多关的就越多，上面建立了一个输入流一个读出流下面就得分别关俩
if(fr!=null)
try
{
// 把读出流关了
fr.close();
}
catch (IOException e)
{
}
if(fw!=null)
try
{
//把写入流中的数据刷到指定文件里面，并把写入流关掉
fw.close();
}
catch (IOException e)
{
}
}
}

//从C盘读一个字符，就往D盘写一个字符。
public static void copy_1()throws IOException
{
//创建目的地。
FileWriter fw = new FileWriter("RuntimeDemo_copy.txt");

//与已有文件关联。
FileReader fr = new FileReader("RuntimeDemo.java");

int ch = 0;

while((ch=fr.read())!=-1)
{
fw.write(ch);
}

fw.close();
fr.close();

}

}

字符流的缓冲区

缓冲区的出现提高了对数据的读写效率

对应类

BufferdWriter

BufferedReader

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

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

演示Mp3的复制，通过缓冲区

BufferedOutStream

BufferedInputStream

import java.io.*;
class	CopyMp3
{
public static void main(String[] args) throws IOException //因为调用了带有抛出异常的函数所以要声明
{
long start= System.currentTimeMillis();//当前的毫秒数
copy_2();							   // 执行通过缓冲区复制
long end = System.currentTimeMillis(); //执行完之后当前的毫秒数
System.out.println((end-start)+"毫秒");//函数执行时间。
}
//通过字节流的缓冲区完成复制
public static void copy_1()throws IOException
{

BufferedInputStream bufis = new BufferedInputStream(new FileInputStream("1.mp3"));  //FileInputStream读硬盘之后存放在缓冲区中
BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("2.mp3"));
int by =0;
while ((by=bufis.read())!=-1)
{
bufos.write(by);//write方法其实含有一个强制下转的操作 获取字节就是int型最后8位存入，才不至于在上面转int型之后会出现四倍于原文件大小
}
bufis.close();
bufos.close();

}
public static void copy_2()throws IOException
{
MyBufferedInputStream bufis = new MyBufferedInputStream(new FileInputStream("1.mp3"));  //用自己编写的读方法
BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("cop2.mp3"));
int by =0;
while ((by=bufis.myRead())!=-1)
{
bufos.write(by);
}
bufis.myClose();
bufos.close();
}
}

-------android培训 、java培训、期待与您交流！
----------