------- android培训、java培训、java学习型技术博客、期待与您交流！ ----------
什么是IO流
IO(Input Output)流用来处理设备之间的数据传输。
流按操作数据分为两种：字节流与字符流。
流按流向分为：输入流，输出流。
字符流的由来：
其实就是：字节流读取文字字节数据后，不直接操作而是先查指定的编码表。获取对应的文字。
在对这个文字进行操作。简单的说：字符流=字节流+编码表
字节流两个基类：
InputStream OutputStream
字符流两个基类：
Reader Writer
IO体系中的子类都以父类名作为后缀。而且子类名的前缀就是该对象的功能。
如：InputStream的子类FileInputStream。
如：Reader的子类FileReader。
对IO流的简单演示：
在硬盘上，创建一个文件并写入一些文字数据。
import java.io.*;
class FileWriterDemo
{
publicstatic void main(String[] args) throws IOException
{
//创建一个FileWriter对象。该对象一被初始化就必须要明确被操作的文件。
//而且该文件会被创建到指定目录下。如果该目录下已有同名文件，将被覆盖。
//其实该步就是在明确数据要存放的目的地。
FileWriterfw = new FileWriter("demo.txt");
//调用write方法，将字符串写入到流中。
fw.write("abcde");
//刷新流对象中的缓冲中的数据。
//将数据刷到目的地中。
//fw.flush();
//关闭流资源，但是关闭之前会刷新一次内部的缓冲中的数据。
//将数据刷到目的地中。
//和flush区别：flush刷新后，流可以继续使用，close刷新后，会将流关闭。
fw.close();
}
}
缓冲区的作用：
缓冲区的出现是为了提高流的操作效率而出现的。
所以在创建缓冲区之前，必须要先有流对象。
该缓冲区中提供了一个跨平台的换行符：newLine();
import java.io.*;
class BufferedWriterDemo
{
publicstatic void main(String[] args) throws IOException
{
//创建一个字符写入流对象。
FileWriterfw = new FileWriter("buf.txt");
//为了提高字符写入流效率。加入了缓冲技术。
//只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可。
BufferedWriterbufw = new BufferedWriter(fw);
for(intx=1; x<5; x++)
{
bufw.write("abcd"+x);
bufw.newLine();
//记住，只要用到缓冲区，就要记得刷新。
bufw.flush();
}
//其实关闭缓冲区，就是在关闭缓冲区中的流对象。
bufw.close();
}
}
重点掌握这10个流对象。
字符流：
FileReader：从文件中读入字符数据
FileWriter：向文件中写出字符数据
BufferedReader：读入字符数据的缓冲区
BufferedWriter：写出字符数据的缓冲区
InputStreamReader：字节到字符的桥梁。解码
OutputStreamWrier：字符到字节的桥梁。编码
字节流：
FileInputStream：从文件中读入字节数据
FileOutputStream：向文件中写出字节数据
BufferedInputStream：读入字节数据的缓冲区
BufferedOutputStream：写出字节数据的缓冲区
如何选择流对象？
1，明确源和目的。
源：输入流(InputStream Reader)
目的：输出流(OutputStream Writer)
2，操作的数据是否是纯文本。
是：字符流。
不是：字节流。
3，当体系明确后，通过设备来进行区分具体的对象。
源设备：
硬盘：File
键盘：System.in
内存：数组
网络：Socket流
目的设备：
硬盘：File
控制台：System.out
内存：数组
网络：Socket流
4，其他额外功能。
1，是否需要高效(加缓冲区)。
2，是否需要转换。指定编码表时，必须使用转换流
选择流对象举例：
例子1：将一个文本文件中数据存储到另一个文件中。复制文件。
源：InputStream Reader
是不是操作文本文件。
是！这时就可以选择Reader
这样体系就明确了。
接下来明确要使用该体系中的哪个对象。
明确设备：硬盘上的文件。
Reader体系中可以操作文件的对象是 FileReader
是否需要提高效率：是！。加入Reader体系中缓冲区 BufferedReader.
FileReaderfr = new FileReader("a.txt");
BufferedReaderbufr = new BufferedReader(fr);
目的：OutputStream Writer
是否是纯文本。
是！Writer。
设备：硬盘，一个文件。
Writer体系中可以操作文件的对象FileWriter。
是否需要提高效率：是！。加入Writer体系中缓冲区 BufferedWriter
FileWriterfw = new FileWriter("b.txt");
BufferedWriterbufw = new BufferedWriter(fw);
例子2：将键盘录入的数据保存到一个文件中。
这个需求中源和目的都存在，需要分别分析
源：InputStream Reader
是不是纯文本？是！Reader
设备：键盘。对应的对象是System.in.
不是选择Reader吗？System.in对应的不是字节流吗？
为了操作键盘的文本数据方便。转成字符流按照字符串操作是最方便的。
所以既然明确了Reader，那么就将System.in转换成Reader。
用了Reader体系中转换流,InputStreamReader
InputStreamReaderisr = new InputStreamReader(System.in);
需要提高效率吗？需要！BufferedReader
BufferedReaderbufr = new BufferedReader(isr);
目的：OutputStream Writer
是否是存文本？是！Writer。
设备：硬盘。一个文件。使用 FileWriter。
FileWriterfw = new FileWriter("c.txt");
需要提高效率吗？需要。
BufferedWriterbufw = new BufferedWriter(fw);
扩展：想要把录入的数据按照指定的编码表（utf-8），将数据存到文件中。
目的：OutputStream Writer
是否是存文本？是！Writer。
设备：硬盘。一个文件。使用 FileWriter。
但是FileWriter是使用的默认编码表。GBK.
但是存储时，需要加入指定编码表utf-8。而指定的编码表只有转换流可以指定。
所以要使用的对象是OutputStreamWriter。
而该转换流对象要接收一个字节输出流。而且还可以操作的文件的字节输出流。FileOutputStream
OutputStreamWriterosw = new OutputStreamWriter(new FileOutputStream("d.txt"),"UTF-8");
需要高效吗？需要。
BufferedWriterbufw = new BufferedWriter(osw);
所以，记住。转换流什么使用。字符和字节之间的桥梁，通常，涉及到字符编码转换时，
需要用到转换流。
IO异常的处理方式:
import java.io.*;
class FileWriterDemo2
{
publicstatic void main(String[] args)
{
FileWriterfw = null;
try
{
//只要一创建IO流对象就得处理异常
fw= new FileWriter("demo.txt");
fw.write("abcdefg");
}
catch(IOException e)
{
System.out.println("catch:"+e.toString());
}
//一定要在finally中关闭资源
finally
{
try
{
//关闭资源时也一定要处理异常
if(fw!=null)
fw.close();
}
catch(IOException e)
{
System.out.println(e.toString());
}
}
}
}
自定义一个MyBufferedReader类，类中包含一个跟readLine功能一致的方法。
import java.io.*;
class MyBufferedReader extends Reader
{
privateReader r;
MyBufferedReader(Readerr)
{
this.r= r;
}
//可以一次读一行数据的方法。
publicString myReadLine()throws IOException
{
//定义一个临时容器。原BufferReader封装的是字符数组。
//为了演示方便。定义一个StringBuilder容器。因为最终还是要将数据变成字符串。
StringBuildersb = new StringBuilder();
intch = 0;
while((ch=r.read())!=-1)
{
if(ch=='\r')//遇到回车的第一个字符就continue，避免返回回车符
continue;
if(ch=='\n')//遇到回车的第二个字符，表示一行读完，返回数据
returnsb.toString();
else
sb.append((char)ch);//没有遇到回车符就一直添加数据
}
if(sb.length()!=0)
returnsb.toString();
returnnull;
}
/*
覆盖Reader类中的抽象方法。
*/
publicint read(char[] cbuf, int off, int len) throws IOException
{
returnr.read(cbuf,off,len) ;
}
publicvoid close()throws IOException
{
r.close();
}
publicvoid myClose()throws IOException
{
r.close();
}
}
class MyBufferedReaderDemo
{
publicstatic void main(String[] args) throws IOException
{
//创建FileReader对象并关联文件
FileReaderfr = new FileReader("buf.txt");
//创建自定义的MyBufferedReader对象
MyBufferedReadermyBuf = new MyBufferedReader(fr);
Stringline = null;
//调用myReadLine方法，只要有数据就一直读取
while((line=myBuf.myReadLine())!=null)
{
System.out.println(line);//打印字符串
}
//关闭缓冲流，其实就是关闭资源
myBuf.myClose();
}
}
装饰设计模式：
当想要对已有的对象进行功能增强时，可以定义类，将已有对象传入，
基于已有的功能，并提供加强功能。那么自定义的该类称为装饰类。
装饰模式比继承要灵活。避免了继承体系臃肿。
而且降低了类于类之间的关系。
装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强功能。
所以装饰类和被装饰类通常是都属于一个体系中的。
读取键盘录入。
System.out:对应的是标准输出设备，控制台。
System.in:对应的标准输入设备：键盘。
通过键盘录入一行数据并打印其大写，
将字节流转成字符流在使用字符流缓冲去的readLine方法。
class TransStreamDemo2
{
publicstatic void main(String[] args) throws IOException
{
System.setIn(newFileInputStream("PersonDemo.java"));
System.setOut(newPrintStream("zzz.txt"));
//键盘的最常见写法。
BufferedReaderbufr =
newBufferedReader(new InputStreamReader(System.in));
BufferedWriterbufw = new BufferedWriter(new OutputStreamWriter(System.out));
Stringline = null;
while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;
bufw.write(line.toUpperCase());
bufw.newLine();
bufw.flush();
}
bufr.close();
}
}
------- android培训、java培训、java学习型技术博客、期待与您交流！ ----------
扫一扫
1020
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
