黑马程序员——>第十九天<io流(BufferedWriter-装饰设计模式-流操作规律)>

-------android培训、java培训、期待与您交流-------
01io流(BufferedWriter)

缓冲区的出现是为了提高流的操作效率而出现的。

所以在创建缓冲区之前，必须要先有流对象。

该缓冲区中提供了一个跨平台的换行符。

newLine();   只有在缓冲区中有

相对应的缓冲区对象

BufferedWriter

BufferedReader

缓冲区要结合流才可以使用
在流的基础上对流的功能进行了增强

构造方法没有空参数，必须要有参数：缓冲区的出现时为了提高流的读写效率，既然时为了提高效率，那它出现之前就要先有流。  假设流对象就是水流，为了利用水流搞一个蓄水池，让水流的蓄水池里，流满了清空一次，再往里边流，如果这边根本就没有水流，你搞蓄水池就没有意义   所以在创建缓冲区之前，必须要先有流对象。

 

import java.io.*;

class  BufferedWriterDemo
{
public static void main(String[] args) throws IOException
{
//创建一个字符写入流对象。
FileWriter fw = new FileWriter("buf.txt");

//为了提高字符写入流效率。加入了缓冲技术。
//只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可。
BufferedWriter bufw = new BufferedWriter(fw);

for(int x=1; x<5; x++)
{
bufw.write("abcd"+x);
bufw.newLine();
bufw.flush();   //写一次刷一次，当停电了，目标中还有数据
}

//记住，只要用到缓冲区，就要记得刷新。
//bufw.flush();

//其实关闭缓冲区，就是在关闭缓冲区中的流对象。
bufw.close();

}
}

02io流(BufferedReader)

字符读取流缓冲区：

该缓冲区提供了一个一次读一行的方法 readLine，方便于对文本数据的获取。

当返回null时，表示读到文件末尾。

readLine方法返回的时候只返回回车符之前的数据内容。并不返回回车符。

文本以行形式存在  一行一行读是最方便的

import java.io.*;

class  BufferedReaderDemo
{
public static void main(String[] args) throws IOException
{
//创建一个读取流对象和文件相关联。
FileReader fr = new FileReader("buf.txt");

//为了提高效率。加入缓冲技术。将字符读取流对象作为参数传递给缓冲对象的构造函数。
BufferedReader bufr = new BufferedReader(fr);

String line = null;

while((line=bufr.readLine())!=null)
{
System.out.print(line);   //缓冲区的操作方式  一行一行读是最方便的
}

bufr.close();
}

}

 
03io流(readLine)

readLine方法的原理：

  无论是读一行，获取读取多个字符。其实最终都是在硬盘上一个一个读取。所以最终使用的还是read方法一次读一个的方法

 readLine方法要比read方法高效很多
04io流(MyBufferedReader)

/*

明白了BufferedReader类中特有方法readLine的原理后，

可以自定义一个类中包含一个功能和readLine一致的方法。

来模拟一下BufferedReader

模拟缓冲区的特点

*/

realine方法的出现，是在增强read方法的功能， 将被增强的对象传给增强类。  因为filereader对象中只有读一个的方法，而MyBufferedReader把这个对象接收进来后，对这个对象的方法进行增强，又提供一个基于它的读一行的方法。MyBufferedReader其实就是对filereader对象的增强，这种方式我们也把它称为一种设计模式叫做：装饰设计模式

import java.io.*;
class MyBufferedReader extends Reader
{

private Reader r;
MyBufferedReader(Reader r) // 一初始化就有一个流对象进来    将被增强的对象传给增强类。
{
this.r = r;
}

//可以一次读一行数据的方法。
public String myReadLine()throws IOException
{
//定义一个临时容器。原BufferReader封装的是字符数组。
//为了演示方便。定义一个StringBuilder容器。因为最终还是要将数据变成字符串。
StringBuilder sb = new StringBuilder();
int ch = 0;
while((ch=r.read())!=-1)
{
if(ch=='\r')
continue;
if(ch=='\n')
return sb.toString(); //将缓冲区里存放的数据变成字符串返回来
else
sb.append((char)ch);   //读到缓冲区里来，要进行强转
}

if(sb.length()!=0)
return sb.toString();
return null;
}

当文件中有四行字符串，而最后一行没有回车符，这时复制出来的就只有三行。

  读一个存一个，只有读到/n时才往回返，可是到了最后一行没有了回车符，这行数据存进去了，但是没有返回来。

这时可以做一个动作if(sb.length()!=0)  代表缓冲区中有数据   判断缓冲区中如果有数据，就把剩下的数据返回来return sb.toString();

   

05io流(装饰设计模式)

装饰设计模式：

当想要对已有的对象进行功能增强时，

可以定义类，将已有对象传入，基于已有的功能，并提供加强功能。

那么自定义的该类称为装饰类。

装饰类通常会通过构造方法接收被装饰的对象。

并基于被装饰的对象的功能，提供更强的功能。

06io流(装饰和继承的区别)

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

 |--MyTextReader 继承体系

  |--MyBufferTextReader   加入缓冲技术进行增强

 |--MyMediaReader

  |--MyBufferMediaReader

 |--MyDataReader

  |--MyBufferDataReader

class MyBufferReader   //定义一个缓冲区，要增强谁，谁需要缓冲区，就把谁传进来
{
MyBufferReader(MyTextReader text)  //将被提高效率的传进来就可以了MyTextReader text
{}
MyBufferReader(MyMediaReader media)
{} // 这样如果再多一个子类还要重新定义还要一直改
}

上面这个类扩展性很差。  进行优化

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

class MyBufferReader extends MyReader    //它最主要的方式是缓冲reader   里边定义的也是(更强)读取行为(代表它也是myreader的一个子类)
{
private MyReader r; // 由继承结构变为 组合结构  (你中有我)
MyBufferReader(MyReader r)   //带缓冲技术的reader
{}
} //建立一个父类类型，既能传MyTextReade还能传MyMediaReader，后期再出现一个子类，MyReader r还能接收

 

体系就发生了变化

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

 |--MyTextReader  

 |--MyMediaReader

 |--MyDataReader

 |--MyBufferReader   对于这种方式  我们起个名字叫装饰  它里边没有自己的东西，都是基于前面的进行功能增强

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

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

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

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

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

 

装饰设计模式的特点

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

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

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

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

 07io流(字节流File读写操作)

/*

字符流：

FileReader

FileWriter。

BufferedReader

BufferedWriter

字节流：

FileInputStream  FileOutputStream   基类

BufferednputStream         BufferedOutputStream

需求，想要操作图片数据。这时就要用到字节流。

复制一个图片

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();

}

 

字节流可以操作很多媒体文件，比如现在想要操作一个电影，电影大概有1.+g。也就是说available返回来的数据比较大，要是在内存中new出来这么大的数组出来，内存就爆了。  虚拟机启动默认是64m，它在分配空间时就分配了64m的空间，如果你拷贝一个dvd，一g多，new一个1g大小的数组就超出容量了。  这时会发生内存溢出

  所以这种方法要慎用   数据没有超过太大的话可以用这种方式
df8b

public static void readFile_2()throws IOException  //存起来 一次打印出来
{
FileInputStream fis = new FileInputStream("fos.txt");

byte[] buf = new byte[1024];  //每次定义一个数组，因为不知道数组有多大 所以定义成1024
int len = 0;   //因为不知道数组有多大，所以要进行循环
while((len=fis.read(buf))!=-1)
{
System.out.println(new String(buf,0,len));
}

fis.close();

}

如果太大的话还是以这个为主  1024的整数倍，这个是最合适的，最折中，最优化，

 

字符流其实一样走的字节，但是它需要将字节临时存起来，一个中文有两个字节，读一个字节后，不能立刻操作(你半个中文怎么操作)，然后再读一个字节，将字节临时存起来后查表去。查完表找一个字符，用临时存储。字符流底层用的也是字节流的缓冲区，  字符缓冲区中有一个数组是在临时存储数据的。所以字符流得要有刷新动作

  而如果你直接使用字节流来操作，没有使用具体指定的缓冲区，它是不需要缓冲的。不管你是什么类型的数据，都以字节来操作，碰到一个字节操作一次，所以它可以直接把这些字节一步一步的都写到目的地里边去，所以字节流是不需要刷新的。
   到了缓冲区后才到刷新这个机制 

  
08io流(拷贝图片)

/*

复制一个图片

思路：

1，用字节读取流对象和图片关联。

2，用字节写入流对象创建一个图片文件。用于存储获取到的图片数据。

3，通过循环读写，完成数据的存储。

4，关闭资源。

*/
问：用字符流可以复制吗？

  字符流是可以复制的，但是复制完的图片很遗憾你可能打开看不了，因为图片数据读完后，读一段数据就要去查表，到编码表里找到对应的数字给查出来，如果能找到对应的数字，那码没变，如果没找到那个数字，会拿个类似于相似代码(就是走的编码表的未知数据区域)，所以你生成新图片的编码和老图片的编码是不一样的。(字节码是会变化的)   所以不要去拿字符流去拷贝媒体文件

09io流(自定义字节流的缓冲区-read和write的特点)

思想：抓一批数据进来，进内存，一个一个从内存中取，取光了再抓一批，再一个一个取

自定义缓冲区原理：在缓冲区中定义一个数组(以数组为缓存区，StringBuilder最后返回的是字符串，要保证原数据)，  这个数组就是我们自定义的一个缓冲区。通过底层的流对象，从mp3这个硬盘上，抓一批数据，一个一个读，存到数组中来，通过FileInputStream中的read(buf)方法。数组有多大，就存多少。紧跟着通过BufferedInputStream的read方法从缓存区里边取一个(而不是从硬盘上取)。在往里边装数据时就可以返回来数据的长度。要想将数组里的数据往外取要通过指针(因为read方法，读完一个会去读下一个(就是因为里边有数组的指针在操作，读一次，指针就在自增))，取光后，就代表着第一次往数组中装的数据取完了。然后再从硬盘上抓一批数据再进数组。如果后面就剩下不满足1024个数据，也得抓进来，这时返回来的就不是1024了，那么怎么代表取光了呢？

    这里有一个1024是第一次往数组里存的字节的个数，那么通过下面的指针在取数组，当取一个以后，就代表着1024中有一个被取走了。那么可以让长度1024--  当1024->0的时候就代表着这个数组中的数据被取光了。全取光后第二次往数组里存元素，存完后将指针归0，再一个一个挨个去取。等1024又减到0后又往里边进。如果最后一次只有234个字节，当234取完后，就代表着数据取完了。再取就成-1了。

1.定义数组

2.定义指针

3.定义计数器  -- 就是计数器  计数器减到0后再抓一批数据进来

这里边有两个变量

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         //对外提供一个方法   调用read方法，
{
//通过in对象读取硬盘上数据，并存储buf中。
if(count==0)
{
count = in.read(buf);   //用count记录住数组中的个数     往里边抓一批数据
if(count<0)  //调用read方法了  所以要抛异常
return -1;
pos = 0;    //每次装完后pos要归0
byte b = buf[pos];    //取0角标元素   抓完后取数组中的第一个元素

count--;  // 个数就少一个
pos++;      //  角标自增
return b&255;
}
else if(count>0)  //不需要装数据  只要取就行了
{
byte b = buf[pos];

count--;
pos++;
return b&0xff;//255的十六进制
}
return -1;

}
public void myClose()throws IOException
{
in.close();
}
}
public static void copy_2()throws IOException
{
MyBufferedInputStream bufis = new MyBufferedInputStream(new FileInputStream("c:\\9.mp3"));
BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("c:\\3.mp3"));

int by = 0;

//System.out.println("第一个字节:"+bufis.myRead());

while((by=bufis.myRead())!=-1)  // 提升
{
bufos.write(by);    //强转
}

bufos.close();
bufis.myClose();
}
new FileInputStream//读硬盘
MyBufferedInputStream//存起来
while((by=bufis.myRead())!=-1)  //自己的read方法一个一个往外取

b&255的原因！

11111111-111111110000000000101001001010100101010010101001010

byte: -1  --->  int : -1;

00000000 00000000 00000000 11111111  255

11111111 11111111 11111111 11111111

11111111  -->提升了一个int类型 那不还是-1吗？是-1的原因是因为在8个1前面补的是1导致的。

那么我只要在前面补0，即可以保留原字节数据不变，又可以避免-1的出现。

怎么补0呢？

 11111111 11111111 11111111 11111111                       

&00000000 00000000 00000000 11111111

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

 00000000 00000000 00000000 11111111

0000-0001

1111-1110

000000001

1111-1111  -1
结论：

字节流的读一个字节的read方法为什么返回值类型不是byte，而是int。

因为有可能会读到连续8个二进制1的情况，8个二进制1对应的十进制是-1.

那么就会数据还没有读完，就结束的情况。因为我们判断读取结束是通过结尾标记-1来确定的。

所以，为了避免这种情况将读到的字节进行int类型的提升。

并在保留原字节数据的情况前面了补了24个0，变成了int类型的数值。

而在写入数据时，只写该int类型数据的最低8位。

10io流(读取键盘录入)

读取键盘录入

System.out:对应的是标准输出设备，控制台。

System.in:对应的标准输入设备：键盘。

需求：

通过键盘录入数据。

当录入一行数据后，就将该行数据进行打印。

如果录入的数据是over，那么停止录入。

import java.io.*;
class  ReadIn
{
public static void main(String[] args) throws IOException
{
InputStream in = System.in;
StringBuilder sb = new StringBuilder();// 因为你要敲回车就打印，相当于将数据先存起来，所以要定义一个缓存区

while(true)  //不知道循环多少次  就用true   读一行的代码原理
{
int ch = in.read();  //读取一个字节   调用read会抛出io异常
if(ch=='\r')
continue;
if(ch=='\n')
{
String s = sb.toString();  // 将缓存区中的数据变成字符串
if("over".equals(s))
break;
System.out.println(s.toUpperCase());   //变成大写打印
sb.delete(0,sb.length());   //清空缓存区   否则字符串会越来越长
}
else
sb.append((char)ch);

}
}
}

进行键盘录入时，要想停止，输入ctrl+c就可以了   相当于输入-1，但是你手动是不能输入-1的。

11io流(读取转换流)  

字节通向字符的桥梁

字符流：

FileReader

FileWriter。

BufferedReader

BufferedWriter

字节流：

FileInputStream

FileOutputStream

BufferedInputStream

BufferedOutputStream

 

通过刚才的键盘录入一行数据并打印其大写，发现其实就是读一行数据的原理。

也就是readLine方法。

能不能直接使用readLine方法来完成键盘录入的一行数据的读取呢？

readLine方法是字符流BufferedReader类中的方法。

而键盘录入的read方法是字节流InputStream的方法。

那么能不能将字节流转成字符流在使用字符流缓冲去的readLine方法呢？

import java.io.*;

class  TransStreamDemo
{
public static void main(String[] args) throws IOException
{
//获取键盘录入对象。
InputStream in = System.in;

//将字节流对象转成字符流对象，使用转换流。InputStreamReader
InputStreamReader isr = new InputStreamReader(in);

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

BufferedReader bufr = new BufferedReader(isr);

String line = null;   //一次读一行

while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;
System.out.println(line.toUpperCase());
}

bufr.close();

}
}

12io流(写入转换流)  

字符通向字节的桥梁

 

import java.io.*;

class  TransStreamDemo
{
public static void main(String[] args) throws IOException
{
//获取键盘录入对象。
//InputStream in = System.in;

//将字节流对象转成字符流对象，使用转换流。InputStreamReader
//InputStreamReader isr = new InputStreamReader(in);

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

//BufferedReader bufr = new BufferedReader(isr);
//键盘录入的最常见写法。
BufferedReader bufr =
new BufferedReader(new InputStreamReader(System.in));  //源
//  OutputStream out = System.out;    输出流
//  OutputStreamWriter osw = new OutputStreamWriter(out);  将输出语句对象变成字符流对象
//     字符输出流里边有缓冲区，如果不写下面几句   后面的osw.wrete  在控制台上没现象出现
//  BufferedWriter bufw = new BufferedWriter(osw);   对功能增强
BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));//  目的
String line = null;

while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;
bufw.write(line.toUpperCase());
bufw.newLine();  //  换行
bufw.flush(); //  刷新就可以了

//osw.wrete(line.toUpperCase());    //字符流对象可以直接操作字符串
}

bufr.close();

}
}

13io流(流操作规律-1)

import java.io.*;

1,

源：键盘录入。

目的：控制台。

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

源：键盘。

目的：文件。

3，需求：想要将一个文件的数据打印在控制台上。

源：文件。

目的：控制台。

流操作的基本规律：

最痛苦的就是流对象有很多，不知道该用哪一个。

通过三个明确来完成。

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);

 

14io流(流操作规律-2)

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);

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

 需要用到转换流。

15io流(改变标准输入输出设备)

16io流(异常的日志信息)

17io流(系统信息)

import java.util.*;
import java.io.*;
class  SystemInfo
{
public static void main(String[] args) throws IOException
{
Properties prop = System.getProperties();   //和流相结合    把内存中的数据展现在控制台上

//System.out.println(prop);
prop.list(new PrintStream("sysinfo.txt"));
}
}

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