IO流（Input Output）
IO流用来处理设备之间的数据传输
java对数据的操作是通过流的方式。
java用于操作流的对象都在IO包中
流分类：
按操作数据：字节流（bit）字符流
按流向：
输入流，输出流
因为编码表的存在，使得计算机可以识别各自的文字。
中文：GB2312 扩容：GBK《汉字编码》
国际标准码表：unicode码表 优化UTF_8 ;
在unicode码表中，所有的字符都用两个字节表示；
UTF_8 :对unicode的优化；
字节流的抽象基类：InputStream OutoutSteam;
字符流的抽象基类：Reader Writer；
注：由上面四个类派生出来的子类名称都是以其父类名作为子类名的后缀；
如：InputStream的子类FileInputStream
如：Reader的子类FileReader
java.io通过数据流、序列化和文件系统提供系统输入和输出。
软件包 java.io 的描述通过数据流、序列化和文件系统提供系统输入和输出。 除非另有说明，否则向此包的任何类或接口中的构造方法或方法传递 null 参数时，都将抛出 NullPointerException。
字节流：
Writer：输出；
java.io
类 Writerjava.lang.Object
java.io.Writer
public abstract class Writer
extends Objectimplements Appendable, Closeable, Flushable
写入字符流的抽象类。子类必须实现的方法仅有 write(char[], int, int)、flush() 和 close()。但是，多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能。
字段：
protected Objectlock
用于同步针对此流的操作的对象。
Writerappend(char c)
将指定字符添加到此 writer。 Writerappend(CharSequence csq)
将指定字符序列添加到此 writer。 Writerappend(CharSequence csq, int start, int end)
将指定字符序列的子序列添加到此 writer.Appendable。abstract voidclose()
关闭此流，但要先刷新它。abstract voidflush()
刷新该流的缓冲。 voidwrite(char[] cbuf)
写入字符数组。abstract voidwrite(char[] cbuf, int off, int len)
写入字符数组的某一部分。 voidwrite(int c)
写入单个字符。 voidwrite(String str)
写入字符串。 voidwrite(String str, int off, int len)
写入字符串的某一部分。
既然IO流是用于操作数据的，对数据最重要的形式就是文件。
那么就以文件为主进行演示。
java.io
类 FileWriterjava.lang.Object
java.io.Writer
java.io.OutputStreamWriter
java.io.FileWriter
public class FileWriter
extends OutputStreamWriter用来写入字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是可接受的。要自己指定这些值，可以先在 FileOutputStream 上构造一个 OutputStreamWriter。
FileWriter 用于写入字符流。要写入原始字节流，请考虑使用 FileOutputStream。
构造方法：
FileWriter(String fileName)
根据给定的文件名构造一个 FileWriter 对象。
FileWriter(String fileName, boolean append)
根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象。
创建一个流对象，该对象一初始化就必须要明确被操作的文件。
package tset1;
import java.io.*;
public class Demo {
public static void main(String[] args) throws Exception {
// 创建一个FileWriter对象，该对象在初始化时要明确被操作的文件。
// 如果该文件已经存在则创建一个新文件进行覆盖，如果没有则创建一个文件。
// 其实该步就是数据要存放的目的地。
FileWriter fw = new FileWriter( “D:\java\Pro\demo.txt”);
// 将字符串写到流中。《可以理解为将数据写到缓冲区中》
fw.write( “yangyoubiao”);
// 刷新流对象中的缓冲中的数据
// 将数据刷到目的地中
fw.flush();
// 继续将数据写入流中。
fw.write( “\n\n2015.3.12”);
// 刷新缓冲区，然后关闭流资源。
fw.close();
}
}
/*
Io 异常的处理方式。
*/
import java.io.*;
public class Demo {
public static void main(String[] args) {
// 在外部建立对象，在内部建立引用[ fw];
// 在声明但未实例化时，需要让 fw指向为null;
FileWriter fw = null;
try { // 当找不到路径的时候，抛出异常，文件里间不成功。
fw = new FileWriter( “H:\java\Pro\demo.txt”);
fw.write( “yangyoubiao”);
} catch (IOException e) {
System. out.println( e.toString());
} finally {
try {
// 如果fw 建立不成功则关闭操作也不存在；
if ( fw != null)
fw.close();
} catch (IOException e) {
System. out.println( e.toString());
}
}
}
}
FileWriter(String fileName, boolean append)
根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象。
参数：fileName – 一个字符串，表示与系统有关的文件名。append – 一个 boolean 值，如果为 true，则将数据写入文件末尾处，而不是写入文件开始处。
即：构造函数中append为真，则不覆盖原文件，而是在原文件中续写。
import java.io.*;
public class Demo {
//测试使用，没有对IO异常进行catch；
public static void main(String[] args) throws IOException{
FileWriter fw= new FileWriter( “D:\java\Pro\demo.txt”,true );
fw.write(“yangyoubiao”);
//在Mircosoft中回车符是由\r\n 两个字符表示的；
//在liux中\n
fw.write(“\r\n\t2015.12.3”);
fw.close();
}
}
字节流：Reader《读，输入》
java.io
类 Readerjava.lang.Object
java.io.Reader
public abstract class Reader
extends Objectimplements Readable, Closeable用于读取字符流的抽象类。子类必须实现的方法只有 read(char[], int, int) 和 close()。但是，多数子类将重写此处定义的一些方法，以提供更高的效率和/或其他功能。
字段摘要protected Objectlock
用于同步针对此流的操作的对象。
构造方法摘要protectedReader()
创建一个新的字符流 reader，其重要部分将同步其自身的 reader。protectedReader(Object lock)
创建一个新的字符流 reader，其重要部分将同步给定的对象。
方法摘要abstract voidclose()
关闭该流并释放与之关联的所有资源。《没有刷新下，就直接关闭》 voidmark(int readAheadLimit)
标记流中的当前位置。 booleanmarkSupported()
判断此流是否支持 mark() 操作。 intread()
读取单个字符。
返回：作为整数读取的字符，范围在 0 到 65535 之间 (0x00-0xffff)，如果已到达流的末尾，则返回 -1 intread(char[] cbuf)
将字符读入数组。
返回：读取的字符数，如果已到达流的末尾，则返回 -1abstract intread(char[] cbuf, int off, int len)
将字符读入数组的某一部分。 intread(CharBuffer target)
试图将字符读入指定的字符缓冲区。 booleanready()
判断是否准备读取此流。 voidreset()
重置该流。 longskip(long n)
跳过字符。
java.io
类 FileReader
public class FileReader
extends InputStreamReader用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的。要自己指定这些值，可以先在 FileInputStream 上构造一个 InputStreamReader。
读取文件的字符 方法1：
import java.io.*;
public class Demo {
public static void main(String[] args) throws IOException {
// 创建一个文件流读取对象，和指定名称的文件相关联；
// 要保证该文件是已经存在的，如果不存在，会发生异常FileNotFoundException
FileReader fr = new FileReader( “D:\java\Pro\demo.txt”);
// 调用读取流对象的read方法
// 读取一个字符。
int ch = 0;
while ( true) {
ch = fr.read();
if ( ch == -1)
break;
else
System.out.print(( char) ch);
}
fr.close();
}
}
读取文件的字符 方法2：
import java.io.*;
public class Demo {
public static void main(String[] args) throws IOException {
FileReader fr = new FileReader( “D:\java\Pro\demo.txt”);
// 定义一个字符数组，用于存储读取的字符。
// 该read（char[] ）返回的是读到的字符个数。
// 如果数组已经存满，文件还没有读取完毕，此时停止读取字符；
// 一般定义的空间大小为1024的整数倍;一个字符两个字节；
char[] buf = new char[1024];
int num = 0;
for (; ( num = fr.read( buf)) != -1;) {
System. out.print( new String( buf, 0, num));
}
fr.close();
}
}
package tset1;
/*
复制原理：就是将目标文件 数据存储到目的文件中
：目标文件demo.tet
:目的文件demo1. txt
过程：
1：创建目的文件
2：定义读取流，并和目标文件关联
3：通过不断的读写完成数据复制。
4：关闭资源
实现方法：
1：一个字节一个字节复制。
2：利用数组复制。
*/
import java.io.*;
public class Demo {
public static void main(String[] args) {
FileWriter fw = null;
FileReader fr = null;
try {
fw = new FileWriter( “D:\java\Pro\demo1.txt”);
fr = new FileReader( “D:\java\Pro\demo.txt”);
char[] ch = new char[1024];
int num;
for (; ( num = fr.read( ch)) != -1;) {
fw.write( ch, 0, num);
fw.flush();
}
} catch (IOException e) {
System. out.println( e.toString());
throw new RuntimeException( "读写失败");
} finally {
if ( fw != null)
try {
fw.close();
} catch (IOException e) {
System. out.println( e.toString());
}
if ( fr != null)
try {
fr.close();
} catch (IOException e) {
System. out.println( e.toString());
}
}
}
/*
* public static void main(String[] args) throws IOException { FileWriter
* fw=new FileWriter("D:\\java\\Pro\\demo1.txt"); FileReader fr = new
* FileReader("D:\\java\\Pro\\demo.txt"); int ch ; for(;(ch=fr.read())!=-1;)
* { fw.write( ch); } fw.close(); fr.close(); }
*/
}
××××××××××××××××××××××××××××××××××××××××××××××××××
××××××××××××××××××××××××××××××××××××××××××××××××××
××××××××××××××××××××××××××××××××××××××××××××××××××
字符流的缓冲区
：缓冲区的出现提高了对数据的读写效率。
对应类：
BUfferedWriter
BuffereReader
缓冲区要结合流才可以使用
在流的基础上对流的功能进行了增强。
java.io
类 BufferedWriter
public class BufferedWriter
extends Writer将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
可以指定缓冲区的大小，或者接受默认的大小。在大多数情况下，默认值就足够大了。
构造函数：
BufferedWriter(Writer out)
创建一个使用默认大小输出缓冲区的缓冲字符输出流。
voidnewLine()
写入一个行分隔符。行分隔符字符串由系统属性 line.separator 定义，并且不一定是单个新行 (‘\n’) 符。
package tset1;
/*
缓冲区的出现是为了提高流的操作效率而出现的。
所以在创建缓冲区之前，必须要先有流对象。
*/
import java.io.*;
public class Demo {
public static void main(String[] args) throws IOException{
//创建一个字符写入流对象
FileWriter fw= new FileWriter( “D:\java\Pro\demo.txt”);
//为了提高字符写入流效率，加入缓冲技术。
//只需要将 要被提高效率的流对象作为参数传递给缓冲区的构造函数即可
BufferedWriter bufw= new BufferedWriter( fw);
bufw.write( “yangyoubiao”);
//只要用到缓冲区，就要刷新纪录
bufw.flush();
//关闭缓冲区，就是关闭缓冲区中的流对象；
bufw.newLine();
bufw.write( “yangyoubiao”);
//缓冲区在内存中
//为什么每次写过之后就调用flush
//如果不用flush，万一其中停电了怎么办？
bufw.flush();
bufw.close();
// 所以这一句不在需要fw.close();
}
}
java.io
类 BufferedReader
java.lang.Object
java.io.Reader
java.io.BufferedReader
public class BufferedReader
extends Reader
从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。
StringreadLine()
读取一个文本行。
返回：包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null
public class Demo {
public static void main(String[] args) throws IOException {
FileReader fr = new FileReader( “D:\java\Pro\demo.txt”);
// 为了提高效率，加入缓冲技术，将字符流读取对象作为参数给缓冲区对象的构造函数。
BufferedReader burd = new BufferedReader( fr);
String line = null;
while (( line = burd.readLine()) != null) {
System. out.println( line);
}
burd.close();
}
}
import java.io.*;
public class Demo {
public static void main(String[] args) {
BufferedReader bffr = null;
BufferedWriter bffw = null;
try {
bffr = new BufferedReader( new FileReader(“D:\java\Pro\demo.txt” ));
bffw = new BufferedWriter(
new FileWriter(“D:\java\Pro\demo1.txt” ));
String str = null;
// readLine方法只返回回车符之前的数据内容。并不返回回车符。
for (; ( str = bffr.readLine()) != null;) {
bffw.write( str);
bffw.newLine();
bffw.flush();
}
} catch (IOException e) {
throw new RuntimeException( “读写失败”);
} finally {
if ( bffr != null)
try {
bffr.close();
} catch (IOException e) {
throw new RuntimeException( “读失败”);
}
if ( bffw != null)
try {
bffw.close();
} catch (IOException e) {
throw new RuntimeException( “写失败”);
}
}
}
}