1 ，IO流概述
2，输出流，输入流方法的应用
3，缓冲区的应用
4，转换流的应用
5，流操作规律
java把所有传统的流类型都放在java.io包中，用以实现输入/输出功能。
1.1，输出流和输入
->输入流：只能从中读取数据，而不能向其写入数据
->输出流：只能向其写入数据，而不能从中读取数据
java的输入流主要由InputStream和Reader作为基类，而输出流则主要由OutputStream和Writer作为基类，他们都是抽象基类，无法直接创建对象。
1.2，字节流和字符流
字节流和字符流的用法几乎一样，区别在于字节流和字符流所操作的数据单元不同。
字节流主要由InputStream和OutputStream作为基类，而字符流则主要由Reader和Writer作为基类。
字符流两个基类：融合了编码表，可以指定编码表。
2，输出流，输入流方法的应用
2.1在Reader里主要有读的3个方法。
public int read() 读取单个字符
返回：如果已到达流的末尾，则返回 -1
public int read(char[] cbuf) 将字符读入数组
返回：读取的字符数，如果已到达流的末尾，则返回 -1
public abstract int read(char[] cbuf,int off,int len) 将字符读入数组的某一部分
返回：读取的字符数，如果已到达流的末尾，则返回 -1
InputStream类里还有一个 available()方法，具体用法如下
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();
}下面代码是对上述方法的简单使用：
class FileReadDemo
{
public static void main(String[] args)
{
}
public static void method_1()
{
//创建一个文件读取流对象，和指定名称的文件相关联。
//要保证该文件是已经存在的，如果不存在，会发生异常，FileNotFoundException
FileReader fr = new FileReader("demo.txt");
int ch = 0;
while((ch=fr.read())!=-1)//已到末尾返回-1
{
System.out.println("ch="+(char)ch);
}
fr.close();
}
public static void method_2()
{
FileReader fr = new FileReader("demo.txt");
char[] buf = new char[1024];//定义一个字符数组，用于存储读到的字符
int num = 0;
while((num=fr.read(buf))!=-1)
{ //无论buf数组里多少字符，长度都是1024
System.out.print(new String(buf,0,num));//new String(buf,0,num) String类的构造器，可将数组封装成字符串
}
fr.close();
}
}
注意：程序里打开的文件IO资源不属于内存里的资源，垃圾回收机制无法回收该资源，所以应该显式关闭文件IO资源。
2.2OutputStream和Writer也非常相似，两个流都提供了如下3个方法。
->void write(int c) 写入单个字符
->public void write(byte[]/char[] buf) 将字节数组 /字符数组中的数据输出到指定流中
->public void write(byte[]/char[] buf,int off,int len) 将字节数组/字符数组中从off位置开始，长度为len的字节/字符输出到输出流中。
因为字符流直接以字符作为操作单位，所以Writer可以用字符串来代替字符数组，即以String对象作为参数。Writer里还包含如下两个方法。
void write(String str);将str字符串里包含的字符输出到指定输出流中。
void write(String str,int off,int len): 将str字符串里从off位置开始，长度为len的字符输出到指定输出流中。
下面用代码来简单说明输出流的用法：
class FileWriterDemo
{
public static void main(String[] args)
{
//创建一个FileWriter对象，该对象一被初始化，就必须要明确被操作的文件
//而且该文件会被创建到指定的目录下。如果该目录下已有同名文件，将被覆盖。
//其实该步就是在明确数据要存放的目的地
FileWriter fw = new FileWriter("demo.txt");
//传递一个true参数。代表不覆盖已有的文件，并在已有文件的末尾处进行数据续写。
//FileWriter fw = new FileWriter("demo.txt",true);
//调用writer方法，将字符串写入到流中。
fw.write("asdasd");
//刷新流对象中的缓冲中的数据。
//将数据刷到目的地中、
//fw.flush();
//关闭流资源，但是关闭之前会刷新一次内部的缓冲中的数据。
//将数据刷到目的地中
//和flush区别;flush刷新后，流可以继续使用，close刷新后，会将流关闭。
fw.close();
}
}
class FileWriterDemo2
{
public static void main(String[] args)
{
FileWriter fw = null;//在代码块外创建引用才能在所有代码块中使用引用。
try
{
fw = new FileWriter("demo.txt");
fw.write("ddsffdhgjf");
}
catch (IOException e)
{
System.out.println("catch:"+e.toString());
}
finally
{
try
{
if(fw!=null)//如果没有判断，可能产生空指针异常
fw.close();//也会抛出异常
}
catch (IOException e)
{
System.out.println(e.toString());
}
}
}
}
输出流和输入流结合的简单应用：
将一个文本文件里的内容复制到另一个文件里。
class CopyTest
{
public static void main(String[] args) throws IOException
{
}
//从才盘读一个字符就往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();
}
public static void copy_2()
{
FileWriter fw = null;
FileReader fr = null;
try
{
fw = new FileWriter("SystemDemo_copy.txt");
fr = new FileReader("SystemDemo.java");
char[] buf = new char[1024];
int len = 0;
while((len=fr.read(buf))!=-1)
{
fw.write(buf,0,len);
}
}
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)
{
}
}
}
}
</pre><p><span style="font-size:18px">3，缓冲区的应用</span></p><p><span style="color:#993300">缓冲区的出现是为了提高流的操作效率而出现的。</span></p><span style="color:#993300">所以在创建缓冲区之前，必须要先有流对象。</span>BufferedWriter该缓冲区中提供了跨平台的换行符。<span style="color:#ff0000">newLine();</span><p>BufferedReader该缓冲区提供了更为高效率的读方法</p><p><span style="color:rgb(255,0,0)">readLine()</span></p><p><span style="color:#ff0000">注意：</span>当返回null时。表示读到文件末尾。readLine方法返回的时候只返回回车符之前的数据内容。并不返回回车符。</p><p></p><p><span style="font-size:14px; color:#ff0000">readLine的原理：</span></p><p><span style="white-space:pre"></span>无论是读一行，读取多个字符，其实最终都是在硬盘上一个一个读取。所以最终使用的还是read方法一次读一个的方法。</p><p><span style="white-space:pre"></span>在readLine方法里封装了一个存放字符的容器，当读到一行的时候，返回这个容器的字符。</p><p>代码实现如下：</p><p></p><p></p><p><span style="white-space:pre"></span></p><pre name="code" class="java">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=='
')
continue;
if(ch=='
')
return sb.toString();
else
sb.append((char)ch);
}
if(sb.length()!=0)//防止有的行没有换行符，则在缓冲区里的数据就不能被返回。
return sb.toString();
return null;
}通过缓冲区来进行文本文件的复制，可以提高效率。
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("写入关闭失败");
}
}
}
}BufferedReader有一个子类为LineNumeberReader 表示跟踪行号的缓冲字符输入流，
里面定义了setLineNumber(int)和getLineNumber(),他们分别可用于设置和获取当前行号。
通过字节流缓冲区复制一段MP3
<pre name="code" class="java">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("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();
}
public static void copy_2()throws IOException
{
MyBufferedInputStream bufis = new MyBufferedInputStream(new FileInputStream("c:\0.mp3"));
BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("c:\2.mp3"));
int by = 0;
while((by=bufis.myRead())!=-1)//一个一个往外取
{
bufos.write(by);//<span style="font-family: Arial, Helvetica, sans-serif;">InputStream的write是将指定字节写到输出流从缓冲区里面读，</span>只写最低8位，不然最后复制的文件大于原文件4倍
}
bufos.close();
bufis.myClose();
}
}
//自定义字节缓冲区
class MyBufferedInputStream
{
private InputStream in;
private byte[] buf = new byte[1024];
private int pos = 0,count = 0;
MyBufferedInputStream(InputStream in)
{
this.in = in;
}
//一次读一个字节，从缓冲区（字节数组）获取、
public int myRead()throws IOException//为什么返回的不是byte，被提升。由4个字节存放
//在读到8个1时为了避免和判断结束标记-1相同，可以在保留8个1的情况下，在前面补0，那就不是-1是255.在判断的时候就不会跳出while循环
{
//通过in对象读取硬盘上的数据，并存储 buf中。
if(count==0)
{
count = in.read(buf);//count为0的时候才读取数据到缓冲区
if(count<0)
return -1;
pos = 0;
byte b = buf[pos];
count--;
pos++;
return b&255;//在前面补0，保留最低8位
}
else if(count>0)//count大于0的时候，说明缓冲区还有数据，不需要读，只需要取
{
byte b = buf[pos];
count--;
pos++;
return b&255;
}
return -1;
}
public void myClose()throws IOException
{
in.close();
}
}
为什么是0kb？因为读的第一个字节是-1， MP3是2进制数据，读1个字节，读了8个2进制位，连续读了8个1，是-1. 1111-1111 -->提升为一个int类型，为4个字节。那还不是-1吗？是-1的原因是因为在8个1前面补的是1导致的 那么我只要在前面补0，既可以保留原字节数据不变，又可以避免-1的出现 怎么补0呢。 1111-1111& 00000000 00000000 00000000 1111-1111 --------------------------------------read方法在做提升，write在做强转
4，转换流的应用
转换流什么时候使用，字符和字节之间的
4.1读取键盘录入System.out:对应的是标准的输出设备，控制台。System.in：对应的是标准的输入设备，键盘。
class ReadIn
{
public static void main(String[] args) throws IOException
{
InputStream in = System.in;
int ch = 0;
StringBuilder sb = new StringBuilder();//可变长度
while(true)
{
int ch = in.read();
if(ch=='
')
continue;
if(ch=='
')
{
String s = sb.toString();
if("over".equals(s))
break;
System.out.println(s.toUpperCase());//变成大写
sb.delete(0,sb.length());//打印完一次要清空缓冲区
}
else
sb.append((char)ch);
}
in.close();
}
}
4.2转换流
以上键盘录入一行数据并打印其大写，发现其实就是一行数据的原理。也就是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);
String line = null;
while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;
//System.out.println(line.toUpperCase());
bufw.write(line.toUpperCase()+);//要刷新，数据才能出来。
bufw.newLine();//换行。
bufw.flush();
}
bufr.close();
}
}5，流操作规律
5.1通过两个明确来完成。
1，明确源和目的。
源：输入流。
目的：输出流。
2，明确操作的数据是否是纯文本。
是：用字符流。
不是：字节流
3，当体系明确后，在明确要使用哪个具体的对象。
通过设备进行区分：
源设备：内存，硬盘，键盘。
目的设备：内存，硬盘，控制台。
例子：
1，将一个文本文件中数据存储到另一个文件中，复制文件。
源：因为是源所以选择读取流，InputStream Reader
操作文本文件，所以选择Reader
设备是硬盘上的文件，所以选择FileReader
BufferedReader bufr = new BufferedReader(new FileReader("a.txt"));
目的：OutputStream Writer
操作文本文件，所以选择Writer
设备是硬盘上的文件，所以选择FileWriter
BufferedWriter bufw = new BufferedWriter(new FileWriter("b.txt"));
2,将键盘录入的数据保存到一个文件中。
源：InputStream Reader
操作纯文本 Reader
设备:键盘，对应对象时System.in
System.in对应的是字节流，为了操作键盘的文本数据方便，
转成字符流按照字符串操作是最方便的。
所以既然明确了Reader。那么将System.in转换成Reader。
用了Reader体系中转换流，InputStreamReader
InputStreamReader isr = new InputStreamReader(System.in);
加入缓冲区提高效率。
BufferedReader bufr = new BufferedReader(isr);
目的：OutputSteam Writer
操作存文本 Writer
设备：硬盘（一个文件）FileWriter
FileWriter fw = new FileWriter("w.txt");
加入缓冲区提高效率
BufferedWriter bufw = new BufferedWriter(fw);
扩展，想要把录入的数据按照指定的编码表（utf-8）,将数据存到文件中
目的：OutputSteam Writer
操作存文本 Writer
设备：硬盘（一个文件）FileWriter
但是存储时，需要加入指定编码表，而指定的编码表只有转换流可以指定。
所以要使用的对象时OutputStreamWriter.
而该转换流对象要接收一个字节输出流，而且还可以操作的文件的字节输出流，FileOutputStream
OutputStreamWriter osw = new OutputStream(new FileOutputStream("d.txt"),"utf-8");
5.2改变标准输入输出设备
System.in默认的输入设备是键盘
System .out默认的输出设备是控制台
通过System类的setIn(InputStream)和setOut(OutputStream)和改变标准输入输出设备，
比如：
System.setIn(new FileInputStream("PersonDemo.java"));
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
这样标准输入设备就是一个文件。