黑马程序员——IO（缓冲区、字节流、转换流、流操作规律）

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

1.1，字符流缓冲区：BufferedReader、BufferedWriter

1，缓冲区的出现是为了提高了流的读写效率，所以在缓冲区创建前，

要先创建流对象。即先将流对象初始化到构造函数中。

2、缓冲技术原理：此对象中封装了数组，将数据存入，再一次性取出。

1.2，BufferedWriter

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

newLine();

2，写入流缓冲区BufferedWriter的使用步骤：

(1)，创建一个字符写入流对象。

FileWriter fw=newFileWriter(“buf.txt”);

(2)，为了提高字符写入流效率。加入缓冲技术。

只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可。

BufferedWriter bufw =new BufferedWriter(fw);

(3)，调用write方法写入数据到指定文件

bufw.write(“adfg”);

bufw.newLine();

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

bufw.flush();

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

bufw.close();

示例：

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

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

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

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

}
}

1.3，BufferedReader

1，该缓冲区提供了一个一次读一行的方法readLine()，方便于堆文本数据的获取当返回null时表 示读到文件末尾。

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

2，读取流缓冲区BufferedReader使用步骤：

(1）创建一个读取流对象和文件相关联

FileReader fr=newFileReader(“buf.txt”);

(2）为了提高效率，加入缓冲技术。将字符读取流对象作为参数传递给缓冲区对象的构造函数。

BufferedReader bufr=new BufferedReader(fr);

(3）调用该缓冲区提供的readLine方法一行一行读取,如果到达文件末尾，则返回null

String s=bufr.readLine();

(4）关闭流资源

bufr.close();

示例：

/*
字符读取流缓冲区：
该缓冲区提供了一个一次读一行的方法 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();
}

}

示例2：

/*
通过缓冲区复制一个.java文件。

*/
import java.io.*;

class  CopyTextByBuf
{
public static void main(String[] args)
{
BufferedReader bufr = null;
BufferedWriter bufw = null;

try
{
bufr = new BufferedReader(new FileReader("BufferedWriterDemo.java"));
bufw = new BufferedWriter(new FileWriter("bufWriter_Copy.txt"));

String line = null;

while((line=bufr.readLine())!=null)
{
bufw.write(line);
bufw.newLine();
bufw.flush();

}
}
catch (IOException e)
{
throw new RuntimeException("读写失败");
}
finally
{
try
{
if(bufr!=null)
bufr.close();
}
catch (IOException e)
{
throw new RuntimeException("读取关闭失败");
}
try
{
if(bufw!=null)
bufw.close();
}
catch (IOException e)
{
throw new RuntimeException("写入关闭失败");
}
}
}
}

1.4，自定义MyBufferedReader

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

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

来模拟一下BufferedReader

2，步骤：

(1)初始化自定义的类，加入流对象。

(2)定义一个临时容器，原BufferedReader封装的是字符数组，

此类中可定义一个StringBuilder的容器，最终可实现字符串的提取。

示例：

/*
明白了BufferedReader类中特有方法readLine的原理后，
可以自定义一个类中包含一个功能和readLine一致的方法。
来模拟一下BufferedReader
*/
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;
}

/*
覆盖Reader类中的抽象方法。

*/
public int read(char[] cbuf, int off, int len) throws IOException
{
return r.read(cbuf,off,len) ;
}

public void close()throws IOException
{
r.close();
}
public void myClose()throws IOException
{
r.close();
}
}

class  MyBufferedReaderDemo
{
public static void main(String[] args) throws IOException
{
FileReader fr = new FileReader("buf.txt");

MyBufferedReader myBuf = new MyBufferedReader(fr);

String line = null;

while((line=myBuf.myReadLine())!=null)
{
System.out.println(line);
}

myBuf.myClose();
}
}

1.5，LineNumberReader

在BufferedReader中有个直接的子类LineNumberReader，其中有特有的方法获取和设置行号：

setLineNumber();//设置初始行号

getLineNumber();//获取行号

示例：

import java.io.*;

class LineNumberReaderDemo
{
public static void main(String[] args)throws IOException
{
FileReader fr = new FileReader("PersonDemo.java");

LineNumberReader lnr = new LineNumberReader(fr);

String line = null;
lnr.setLineNumber(100);
while((line=lnr.readLine())!=null)
{
System.out.println(lnr.getLineNumber()+":"+line);
}

lnr.close();
}
}

1.6，装饰设计模式

1，当想要对已有的对象进行功能增强时，可以定义类，将已有对象传入，

基于已有的功能，并提供加强功能，那么自定义的该类称为装饰类。

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

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

2，装饰和继承的区别：

(1）装饰模式比继承要灵活。避免了继承体系的臃肿，且降低了类与类之间的关系。

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

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

(3）从继承结构转为组合结构。

示例：

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

装饰类通常会通过构造方法接收被装饰的对象。
并基于被装饰的对象的功能，提供更强的功能。

*/
class Person
{
public void chifan()
{
System.out.println("吃饭");
}
}

class SuperPerson
{
private Person p ;
SuperPerson(Person p)
{
this.p = p;
}
public void superChifan()
{
System.out.println("开胃酒");
p.chifan();
System.out.println("甜点");
System.out.println("来一根");
}
}

class  PersonDemo
{
public static void main(String[] args)
{
Person p = new Person();

//p.chifan();

SuperPerson sp = new SuperPerson(p);
sp.superChifan();

}
}

2.1，字节流:InputStream、OutputStream

1、字节流和字符流的基本操作是相同的，但字节流还可以操作其他媒体文件。

2、由于媒体文件数据中都是以字节存储的，所以，字节流对象可直接对媒体文件的数据写入到文件中，而可以不用再进行刷流动作。

3，为何不用进行刷流动作？

因为字节流操作的是字节，即数据的最小单位，不需要像字符流一样要进行转换为字节。

所以可直接将字节数据写入到指定文件中。

5、InputStream特有方法：

int available();//返回文件中的字节个数

示例：

/*
复制一个图片
思路：
1，用字节读取流对象和图片关联。
2，用字节写入流对象创建一个图片文件。用于存储获取到的图片数据。
3，通过循环读写，完成数据的存储。
4，关闭资源。

*/

import java.io.*;
class  CopyPic
{
public static void main(String[] args)
{
FileOutputStream fos = null;
FileInputStream fis = null;
try
{
fos = new FileOutputStream("c:\\2.bmp");
fis = new FileInputStream("c:\\1.bmp");

byte[] buf = new byte[1024];

int len = 0;

while((len=fis.read(buf))!=-1)
{
fos.write(buf,0,len);
}
}
catch (IOException e)
{
throw new RuntimeException("复制文件失败");
}
finally
{
try
{
if(fis!=null)
fis.close();
}
catch (IOException e)
{
throw new RuntimeException("读取关闭失败");
}
try
{
if(fos!=null)
fos.close();
}
catch (IOException e)
{
throw new RuntimeException("写入关闭失败");
}
}
}
}

2.2，字节流缓冲区：BufferedOutputStream、BufferedInputStream

1，字节流缓冲区是为了提高字节流的读写效率。

2，读写特点：

read()：会将字节byte型值提升为int型值

write()：会将int型强转为byte型，即保留二进制数的最后八位。

2，原理：将数据拷贝一部分，读取一部分，循环，直到数据全部读取完毕。

（1）先从数据中抓取固定数组长度的字节，存入定义的数组中，再通过然后再通过read()方法读取数组中的元素，存入缓冲区。

（2）循环这个动作，直到最后取出一组数据存入数组，可能数组并未填满，同样也取出包含的元素。

（3）每次取出的时候，都有一个指针在移动，取到数组结尾就自动回到数组头部，这样指针在自增。

（4）取出的时候，数组中的元素在减少，取出一个，就减少一个，直到减到0即元素取完。

（5）当文件中的全部数据都被读取出时，read()方法就返回-1。

示例：

/*
演示mp3的复制。通过缓冲区。
BufferedOutputStream
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_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();
}

//通过字节流的缓冲区完成复制。
public static void copy_1()throws IOException
{
BufferedInputStream bufis = new BufferedInputStream(new FileInputStream("c:\\0.mp3"));
BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("c:\\1.mp3"));

int by = 0;

while((by=bufis.read())!=-1)
{
bufos.write(by);
}

bufos.close();
bufis.close();

}
}

2.3，自定义读取字节流缓冲区

1，根据字节流缓冲区的原理，自定义一个字节流缓冲区。

示例：

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

/*
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位。

*/

3.1，读取键盘录入

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)
{
int ch = in.read();
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);

}
}
}

4.1，转换流：InputStreamReader、OutputStreamWriter

1，转换流的：字符流与字节流之间的桥梁，方便了字符流与字节流之间的操作

2，InputStreamReader：字节流通向字符流的桥梁

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

3，OutputStreamWriter：字符流通向字节流的桥梁

BufferedWriter out=new BufferedWriter(new OutputStreamWriter(System.out));

示例：

通过刚才的键盘录入一行数据并打印其大写，发现其实就是读一行数据的原理。
也就是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);

//键盘的最常见写法。
BufferedReader bufr =
new BufferedReader(new InputStreamReader(System.in));

//      OutputStream out = System.out;
//      OutputStreamWriter osw = new OutputStreamWriter(out);
//      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();
}

bufr.close();

}
}

5.1,流操作规律

通过三个明确来完成：

1，明确源和目的。

源：输入流。InputStream Reader

目的：输出流。OutputStream Writer。

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

是：字符流。

不是：字节流。

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

通过设备来进行区分：

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

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

示例：

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

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

练习：将一个文本数据打印在控制台上。要按照以上格式自己完成三个明确。

*/

class  TransStreamDemo2
{
public static void main(String[] args) throws IOException
{
System.setIn(new FileInputStream("PersonDemo.java"));

System.setOut(new PrintStream("zzz.txt"));

//键盘的最常见写法。
BufferedReader bufr =
new BufferedReader(new InputStreamReader(System.in));

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

bufr.close();

}
}

6.1，系统属性信息存入文本

获取系统信息：

Properties pro = System.getProperties();

将信息输出到指定输出流中

pro.list(PrintStream out);

将输出流中数据存入指定文件中

new PrintStream(“systeminfo.txt”);

示例：

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

6.2，通过System类的setIn，setOut方法可以对默认设备进行改变

System.setIn(newFileInputStream(“PersonDemo.txt”));//将源改成文件PersonDemo.txt。

System.setOut(newFileOutputStream(“abc.txt”));//将目的改成文件abc.txt

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