黑马程序员__IO知识点总结2

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

IO（Input Output）流：

IO流用来处理设备之间的数据传输，java对数据的操作是通过流的方式，java用于操作流的对象都在IO包中

流按操作数据分为两种：字节流与字符流。

字节流的抽象基类：InputStream（读），OutputStream（写）

字符流的抽象基类：Reader，Writer

流按流向分为：输入流，输出流。

国际码表：unicode（无论什么字符，2个字节，16个2进制位）------升级-----utf—8

中 国：GB2312----扩容----GBK

FileWriter：专门用于才做文件的子类对象，后缀名是父类名，前缀是其功能！

FileWriter fw = new FileWriter("demo.txt");

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

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

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

fw.flush();

刷新流对象中的缓冲中的数据。

将数据刷到目的地中。

fw.close();

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

将数据刷到目的地中。

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

FileWriter("demo.txt",true); 传递一个true参数，代表不覆盖已有的文件。并在已有文件的末尾处进行数据续写。

FileReader fr = new FileReader("demo.txt");

创建一个文件读取流对象，和指定名称的文件相关联。

要保证该文件是已经存在的，如果不存在，会发生异常FileNotFoundException

read():一次读一个字符。而且会自动往下读。

作为整数读取的字符—读取的字符的个数，范围在 0 到 65535 之间 (0x00-0xffff)，如果已到达流的末尾，则返回 -1 。

Eg：读取相应文件

import java.io.*;

class FileReaderDemo3

{

public static void main(String[] args)throws IOException

{

FileReader fr=new FileReader("file1.txt");

char[] chs=new char[3];

int num=0;

while((num=fr.read(chs))!=-1)

{

System.out.print(new String(chs,0,num));

}

}

}

Eg：复制一个文本文件：

import java.io.*;

class Copytest2

{

public static void main(String[] args)

{

FileWriter fw=null;

FileReader fr=null;

try

{

fw=new FileWriter("filecopy3.txt");

fr=new FileReader("FileWriterDemo.java");

char[] chs=new char[1024];

int num=0;

while((num=fr.read(chs))!=-1)

{

fw.write(chs,0,num);//读到几个数据写几个数据

}

}

catch(IOException e)

{

throw new RuntimeException(“读写失败”);

}

finally

{

try

{

if(fw!=null)

fw.close();

}

catch(IOException e)

{

throw new RuntimeException();

}

try

{

if(fr!=null)

fr.close();

}

catch(IOException e)

{

throw new RuntimeException();

}

}

}

}

字符流缓冲区（原理就是封装了数组）：

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

对应类BufferedReader【后缀父类，前缀功能】和BufferedWriter，缓冲区要结合流才可以使用，在流的基础上对流的功能进行了加强。

缓冲区的出现是为了提高流的操作效率而出现的，所以在创建缓冲区之前，必须要先有流对象！

只要用到缓冲区，就要记得刷新。

其实关闭缓冲区，就是关闭缓冲区中的流对象。

BufferedWriter：newLine（）：跨平台的换行符

BufferedReader：readLine（）：一下读一行；若读完返回的是null；

readLine（ ）方法返回的时候只返回回车符之前的数据内容，并不返回回车符!

装饰设计模式：当想要对已有的对象进行功能增强时，可以定义类，将已有的对象传入，基于已有的功能，并提供加强功能，那么自定义的该类称为装饰类。

MyReader//专门用于读取数据的类。

|--MyTextReader

|--MyBufferTextReader

|--MyMediaReader

|--MyBufferMediaReader

|--MyDataReader

|--MyBufferDataReader

class MyBufferReader

{

MyBufferReader(MyTextReader text)

{}

MyBufferReader(MyMediaReader media)

{}

}

上面这个类扩展性很差。

找到其参数的共同类型。通过多态的形式。可以提高扩展性。

class MyBufferReader extends MyReader

{

private MyReader r;

MyBufferReader(MyReader r)

{}

}

MyReader//专门用于读取数据的类。

|--MyTextReader

|--MyMediaReader

|--MyDataReader

|--MyBufferReader

以前是通过继承将每一个子类都具备缓冲功能。

那么继承体系会复杂，并不利于扩展。

现在优化思想。单独描述一下缓冲内容。

将需要被缓冲的对象。传递进来。也就是，谁需要被缓冲，谁就作为参数传递给缓冲区。

这样继承体系就变得很简单。优化了体系结构。

装饰模式比继承要灵活。避免了继承体系臃肿。

而且降低了类于类之间的关系。

装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强功能。

所以装饰类和被装饰类通常是都属于一个体系中的。

LineNumberReader（带着行号读取）：setLineNumber（ ），getLineNumber（）；

字节流：InputStream，OutputStream

public static void readFile_3()throws IOException

{

FileInputStream fis = new FileInputStream("fos.txt");

// int num = fis.available();

byte[] buf = new byte[fis.available()];//定义一个刚刚好的缓冲区。不用再循环了，但是要慎用，小心发生内存溢出！

fis.read(buf);

System.out.println(new String(buf));

fis.close();

}

public static void readFile_2()throws IOException//定义数组缓冲区

{

FileInputStream fis = new FileInputStream("fos.txt");

byte[] buf = new byte[1024];

int len = 0;

while((len=fis.read(buf))!=-1)

{

System.out.println(new String(buf,0,len));

}

fis.close();

}

字节流的缓冲区：BufferedInputStream和BufferedOutputStream

自定义字节流缓冲区：

import java.io.*;

class MyBufferedInputStream

{

private InputStream in;

private byte[] buf = new byte[1024*4];

private int pos = 0,count = 0;

MyBufferedInputStream(InputStream in)

{

this.in = in;

}

//一次读一个字节，从缓冲区(字节数组)获取。

public int myRead()throws IOException

{

//通过in对象读取硬盘上数据，并存储buf中。

if(count==0)

{

count = in.read(buf);

if(count<0)

return -1;

pos = 0;

byte b = buf[pos];

count--;

pos++;

return b&255;

}

else if(count>0)

{

byte b = buf[pos];

count--;

pos++;

return b&0xff;

}

return -1;

}

public void myClose()throws IOException

{

in.close();

}

}

读取转换流：

InputStreamReader：字节流转字符流

获取键盘录入对象。

InputStream in = System.in;

将字节流对象转成字符流对象，使用转换流。InputStreamReader

InputStreamReader isr = new InputStreamReader(in);

为了提高效率，将字符串进行缓冲区技术高效操作。使用BufferedReader

BufferedReader bufr = new BufferedReader(isr);

键盘的最常见写法。

BufferedReader bufr =

new BufferedReader(new InputStreamReader(System.in));

OutputStreamWriter：

流总结：

通过三个明确来完成。

1，明确源和目的。

源：输入流。InputStream Reader

目的：输出流。OutputStream Writer。

2，操作的数据是否是纯文本。

是：字符流。

不是：字节流。

3，当体系明确后，在明确要使用哪个具体的对象。

通过设备来进行区分：

源设备：内存，硬盘。键盘

目的设备：内存，硬盘，控制台。

1，将一个文本文件中数据存储到另一个文件中。复制文件。

源：因为是源，所以使用读取流。InputStream Reader

是不是操作文本文件。

是！这时就可以选择Reader

这样体系就明确了。

接下来明确要使用该体系中的哪个对象。

明确设备：硬盘。上一个文件。

Reader体系中可以操作文件的对象是 FileReader

是否需要提高效率：是！。加入Reader体系中缓冲区 BufferedReader.

FileReader fr = new FileReader("a.txt");

BufferedReader bufr = new BufferedReader(fr);

目的：OutputStream Writer

是否是纯文本。

是！Writer。

设备：硬盘，一个文件。

Writer体系中可以操作文件的对象FileWriter。

是否需要提高效率：是！。加入Writer体系中缓冲区 BufferedWriter

FileWriter fw = new FileWriter("b.txt");

BufferedWriter bufw = new BufferedWriter(fw);

练习：将一个图片文件中数据存储到另一个文件中。复制文件。要按照以上格式自己完成三个明确。

--------------------------------------

2，需求：将键盘录入的数据保存到一个文件中。

这个需求中有源和目的都存在。

那么分别分析

源：InputStream Reader

是不是纯文本？是！Reader

设备：键盘。对应的对象是System.in.

不是选择Reader吗？System.in对应的不是字节流吗？

为了操作键盘的文本数据方便。转成字符流按照字符串操作是最方便的。

所以既然明确了Reader，那么就将System.in转换成Reader。

用了Reader体系中转换流,InputStreamReader

InputStreamReader isr = new InputStreamReader(System.in);

需要提高效率吗？需要！BufferedReader

BufferedReader bufr = new BufferedReader(isr);

目的：OutputStream Writer

是否是存文本？是！Writer。

设备：硬盘。一个文件。使用 FileWriter。

FileWriter fw = new FileWriter("c.txt");

需要提高效率吗？需要。

BufferedWriter bufw = new BufferedWriter(fw);

**************

扩展一下，想要把录入的数据按照指定的编码表（utf-8），将数据存到文件中。

目的：OutputStream Writer

是否是存文本？是！Writer。

设备：硬盘。一个文件。使用 FileWriter。

但是FileWriter是使用的默认编码表。GBK.

但是存储时，需要加入指定编码表utf-8。而指定的编码表只有转换流可以指定。

所以要使用的对象是OutputStreamWriter。

而该转换流对象要接收一个字节输出流。而且还可以操作的文件的字节输出流。FileOutputStream

OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("d.txt"),"UTF-8");

需要高效吗？需要。

BufferedWriter bufw = new BufferedWriter(osw);

所以，记住。转换流什么使用。字符和字节之间的桥梁，通常，涉及到字符编码转换时，

需要用到转换流。

异常的日志信息：

import java.io.*;

import java.util.*;

import java.text.*;

class ExceptionInfo

{

public static void main(String[] args)throws IOException

{

try

{

int[] arr = new int[2];

System.out.println(arr[3]);

}

catch (Exception e)

{

try

{

Date d = new Date();

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

String s = sdf.format(d);

PrintStream ps = new PrintStream("exeception.log");

ps.println(s);

System.setOut(ps);

}

catch (IOException ex)

{

throw new RuntimeException("日志文件创建失败");

}

e.printStackTrace(System.out);

}

}

}

//log4j：专门用来创建日志信息！

---------------------- android培训、 java培训、期待与您交流！ ----------------------详细请查看： http://edu.csdn.net/heima