——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-
概述：
1.IO流用来处理设备之间的数据传输。
2.java对数据的操作是通过流的方式。
3.java中用于操作流的对象都在io包中。
4.按流操作分为：字节流和字符流。
5.按流分为：输入流和输出流
IO流常用基类：
字节流抽象基类：InputStream 和 OutputStream
字符流抽象类：Read 和 Writer
第一话：字符流
字符流最常见的体现形式:
文件
Writer类和方法摘要：
Writer类写入字符流的抽象类。子类必须实现的方法仅有 write(char[], int, int)、flush() 和 close()。但是，多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能。
//将指定字符添加到此writer
Writer append()
//关闭此流，但要先刷新它
abstract void close()
//刷新该流的缓冲
abstract void flush()
//写入字符数组
void write(char[] cbuf )
//写入当字符
void write(int c)
//写入字符串
void write(String str)
//写入字符串的某一部分
void write(String str, int off, int len) FileWriter类：
FileWriter类用来写入字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是可接受的。要自己指定这些值，可以先在 FileOutputStream 上构造一个 OutputStreamWriter。
构造方法：
//根据给定的 File 对象构造一个 FileWriter 对象
FileWriter(File file)
//根据给定的 File 对象构造一个 FileWriter 对象
FileWriter(File file, boolean append)
//根据给定的文件名构造一个 FileWriter 对象
FileWriter(String fileName) package IO;
import java.io.*;
public class IoTest {
public static void main(String[] args) throws IOException
{
/*创建一个FileWriter对象，该对象一被初始化就必须要明确被操作的文件。而且该文件会被创建到指定目录下。如果该目录下已有同名文件，则将其覆盖*/
FileWriter w = new FileWriter("Demo.txt");//存在IO异常要记得抛
//调用write方法，将字符串写入到流中
w.write("dafdsf");
//刷新流对象中缓冲的数据，不刷新则无法写入到文件
w.flush();
w.flush();//连续调用flush不会报错
//关闭流，这是经常忘记的事情，关闭后不能write
w.close(); //close之前已经包含一次flush
//w.write("dfad");//出现异常：Stream close
}
}结果：
在当前目录创建了Demo.txt文件，文件的内容为dafdsf
Read类和方法摘要：
Read类用于读取字符流的抽象类。子类必须实现的方法只有 read(char[], int, int) 和 close()。但是，多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能。
//关闭该流并释放与之关联的所有资源
abstract void close()
//读取单个字符
int read()
//将字符读入数组
int read(char[] cbuf)
//试图将字符读入指定的字符缓冲区
int read(CharBuffer target) FileReader类：
用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的。要自己指定这些值，可以先在 FileInputStream 上构造一个 InputStreamReader。FileReader用于读取字符流。要读取原始字节流，请考虑使用 FileInputStream
构造方法：
//在给定从中读取数据的 File 的情况下创建一个新 FileReader
FileReader(File file)
//在给定从中读取数据的文件名的情况下创建一个新 FileReader
FileReader(String fileName)
读取方式1：单个字节读取
package IO;
import java.io.*;
public class FileRead {
public static void main(String[] args)throws IOException
{
//创建一个文件读取流对象，和指定名称的文件相关联
//要保证该文件是已经存在的，如果不存在，会发生异常FileNotFundException
FileReader fr = new FileReader("copyAt.txt");
//调用读取流对襄的read方法，返回该字符的ASCII码
int ch1 = fr.read();
System.out.println("ch1="+ch1);
int ch2 = fr.read();
System.out.println("ch2="+ch2);
fr.close();
//System.out.println(fr.read());//出异常Stream close
}
}结果：
打印出该目录下的copyAt.txt的第一个字节ASCII码和第二个字节ASCII码
读取方式2：用数组作为
package IO;
import java.io.*;
public class FileRead2 {
public static void main(String[] args)throws IOException
{
FileReader fr = new FileReader("copyAt.txt");
//定义一个字符数组用来存放读取的字符
char[] buf = new char[1024];
int num = 0;
//while循环直到读到的文件末尾返回-1
while((num = fr.read(buf)) != -1)
{
System.out.println(new String(buf, 0, buf.length)); //输出buf中字符
}
fr.close();
}
}
BufferedWriter类：
缓冲区的出现是为了提高流的操作，所以在创建对象之前必须要先有对象该缓冲区，BufferedWriter类提供了跨平台的换行符
newLine().
BufferedReader类：
该缓冲区提供了一个一次读取一行的方法readLine()，方便于对文件数据的获取。当返回null时，表示读到文件末尾。值得注意的是readLine()只返回回车符之前的数据内容，并不返回回车符。
根据read原理来创建一个读一行的方法：
package IO;
import java.io.*;
public class MyReadLine {
public static void main(String[] args)
{
FileReader fr = null;
BufferedReader br = null;
try
{
fr = new FileReader("copyAt.txt");
//定义一个缓冲区
br = new BufferedReader(fr);
}//异常处理
catch(IOException e)
{
e.toString();
}
try
{
System.out.println(myReadLine(fr));
}catch(IOException e)
{}
}
public static String myReadLine(FileReader fr) throws IOException
{
FileReader myfr = fr;
StringBuilder sb = null;
//定义String容器来装字符
sb = new StringBuilder();
char c;
while(( c = (char) myfr.read()) != -1)
{
if(c == '\r')
continue;
if(c == '\n')//过滤空格
return sb.toString(); //按下空格代表读取一行结束
else
sb.append(c);//将字符加入到字符容器
//System.out.println(c);
}
if(sb.length()>0)
sb.toString();
myfr.close();
return sb.toString();
}
}
第二话：字节流
字节流的常见表现形式：
音频，图片
InputStream类和常见方法摘要：
InputStream抽象类是表示字节输入流的所有类的超类。
需要定义 InputStream 子类的应用程序必须总是提供返回下一个输入字节的方法。
//返回此输入流下一个方法调用可以不受阻塞地从此输入流读取（或跳过）的估计字节数
int available()
//关闭此输入流并释放与该流关联的所有系统资源
void close()
//从输入流中读取数据的下一个字节
abstract int read()
//从输入流中读取一定数量的字节，并将其存储在缓冲区数组b中
int read(byte[] b)
//将输入流中最多len个数据字节读入byte数组
int read(byte[] b, int off, int len) OutputStream类和常见方法摘要:
OutputStream抽象类是表示输出字节流的所有类的超类。输出流接受输出字节并将这些字节发送到某个接收器。需要定义 OutputStream 子类的应用程序必须始终提供至少一种可写入一个输出字节的方法.
//关闭此输出流并释放与此流有关的所有系统资源
void close()
//刷新此输出流并强制写出所有缓冲的输出字节
void flush()
//将 b.length 个字节从指定的 byte 数组写入此输出流
void write(byte[] b)
//将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流
void write(byte[] b, int off, int len)
//将指定的字节写入此输出流
abstract void write(int b) BufferedInputStream类和方法摘要：
BufferedInputStream 为另一个输入流添加一些功能，即缓冲输入以及支持 mark 和 reset 方法的能力。在创建 BufferedInputStream 时，会创建一个内部缓冲区数组。在读取或跳过流中的字节时，可根据需要从包含的输入流再次填充该内部缓冲区，一次填充多个字节。mark 操作记录输入流中的某个点，reset 操作使得在从包含的输入流中获取新字节之前，再次读取自最后一次 mark 操作后读取的所有字节。
//返回可以从此输入流读取（或跳过）、且不受此输入流接下来的方法调用阻塞的估计字节数
int available()
//关闭此输入流并释放与该流关联的所有系统资源
void close()
//参见 InputStream 的 read 方法的常规协定
int read()
int read(byte[] b, int off, int len) BufferedOutputStream类和常见方法摘要：
BufferedOutputStream类实现缓冲的输出流。通过设置这种输出流，应用程序就可以将各个字节写入底层输出流中，而不必针对每次字节写入调用底层系统。
//刷新此缓冲的输出流
void flush()
//将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此缓冲的输出流
void write(byte[] b, int off, int len)
//将指定的字节写入此缓冲的输出流
void write(int b) 用字节流复制.avi文件：
package IO;
import java.io.*;
public class CopyPicture {
public static void main(String[] args)
{
try
{
//找到文件用字节流形式读取，如果文件不存在则报错
FileInputStream fis = new FileInputStream("C:\\Users\\Administrator\\Desktop\\1.avi");
//指定字节流的存储文件
FileOutputStream fos = new FileOutputStream("1.avi");
//定义字节流读取缓冲区
BufferedInputStream bis = new BufferedInputStream(fis);
//定义字节流存储缓冲区
BufferedOutputStream bos = new BufferedOutputStream(fos);
int b;
//读到结束返回-1，结束读取
while((b = bis.read()) != -1)
{
将存储缓冲区的字节写入目标文件
bos.write(b);
}
}
catch(IOException e)
{
}
System.out.println("finish!!!!!!!!!!!!!");
}
}
第三话：字符转换流
注意：
System.in 是 InputStream类型的
System.out 是PrintStream类型的
InputStreamReader类和常见方法摘要：
InputStreamReader 是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集。
//关闭该流并释放与之关联的所有资源
void close()
//返回此流使用的字符编码的名称
String getEncoding()
//读取单个字符
int read()
//将字符读入数组中的某一部分
int read(char[] cbuf, int offset, int length) OutputStreamWriter类和方法摘要：
OutputStreamWriter 是字符流通向字节流的桥梁：可使用指定的 charset 将要写入流中的字符编码成字节。它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集。
//关闭此流，但要先刷新它
void close()
//刷新该流的缓冲
void flush()
//返回此流使用的字符编码的名称
String getEncoding()
//写入字符数组的某一部分
void write(char[] cbuf, int off, int len)
//写入单个字符
void write(int c)
//写入字符串的某一部分
void write(String str, int off, int len) 写给程序吧按下enter键时将键盘输入的字符打印在控制台上，当输入over时结束程序。
package IO;
import java.io.*;
public class OutWrite {
public static void main(String[] args) throws IOException
{
//设置字节输入流为键盘
InputStream In = System.in;
//用字节装换流将字节转换成字符，读取键盘输入字节
InputStreamReader isr = new InputStreamReader(In);
//将字符存储在字符缓冲区中
BufferedReader br = new BufferedReader(isr);
//设置输出目标为控制台
OutputStream out = System.out;
//用字符装换流将字节装换为字符，
OutputStreamWriter osw = new OutputStreamWriter(out);
//用字符存储缓冲区存储字符
BufferedWriter bw = new BufferedWriter(osw);
String s = null;
while(true)
{ //调用BufferedReader的readLine方法，读取一行
s = br.readLine();
bw.write(s);
//调用BufferedWriter的newLine方法实现跨平台换行
bw.newLine();
bw.flush();
}
}
}