字节流
IO 用于在设备间进行数据传输的操作
1.分类：
字节流
|-- 字节输入流
InputStream
int read(): 一次读取一个字节
int read(byte[] bys): 一次读取一个字节数组
|--FileInputStream
|--BufferedInputStream
|-- 字节输出流
OutputStream
void write(int by): 一次写一个字节
void write(byte[] bys,int index,int len): 一次写一个字节数组的一部分
|--FileOutputStream
|--BufferedOutputStream
字符流
|-- 字符输入流
Reader
int read(): 一次读取一个字符
int read(char[] chs): 一次读取一个字符数组
|--InputStreamReader
|--FileReader
|--BufferedReader
String readLine(): 一次读取一个字符串
|-- 字符输出流
Writer
void write(int ch): 一次写一个字符
void write(char[] chs,int index,int len): 一次写一个字符数组的一部分
|--OutputStreamWriter
|--FileWriter
|--BufferedWriter
void newLine(): 写一个换行符
void write(String line): 一次写一个字符串
注意：
a:如果我们没有明确说明按照什么分，默认按照数据类型分。
b: 除非文件用 windows 自带的记事本打开我们能够读懂， 才采用字符流， 否则建议使用字节流。
2.FileOutputStream 写出数据
A:操作步骤
a:创建字节输出流对象
b: 调用 write() 方法
c:释放资源
B:API
构造方法
FileOutputStream(File file)
FileOutputStream(File file ，booleanappend) FileOutputStream(String name)
FileOutputStream(String name ，booleanappend) ；
如果第二个参数为 true ，则将字节写入文件末尾处，而不是写入文件开始处。
成员方法
public void write(int b): 写一个字节
public void write(byte[] b): 写一个字节数组
public void write(byte[] b,int off,int len) :写一个字节数组的一部分
public void close(); 关闭此文件输出流并释放与此流有关的所有系统资源。
C:代码体现：
// 创建字节输出流对象
// FileOutputStream(File file)
// File file = new File("fos.txt");
// FileOutputStream fos = new FileOutputStream(file);
// FileOutputStream(String name)
FileOutputStream fos = newFileOutputStream("fos.txt");
/*
*创建字节输出流对象了做了几件事情：
*A: 调用系统功能去创建文件
*B: 创建 fos 对象
*C: 把 fos 对象指向这个文件
*/
// 写数据
fos.write( fos.write("hello,IO".getBytes());
fos.write( fos.write(""java"".getBytes());
// 释放资源
// 关闭此文件输出流并释放与此流有关的所有系统资源。
fos.close();
/*
*为什么一定要 close() 呢 ?
*A: 让流对象变成垃圾，这样就可以被垃圾回收器回收了
*B: 通知系统去释放跟该文件相关的资源
*/
//java.io.IOException: Stream Closed
//fos.write("java".getBytes());加入异常处理的代码：
FileOutputStream fos = null ;
try {
// fos = new FileOutputStream("z:\\fos4.txt");
fos = newFileOutputStream("fos4.txt""fos4.txt");
fos .write("java" .getBytes());
} catch (FileNotFoundException e ) { e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
// 如果 fos 不是 null ，才需要 close() if ( fos != null ) {
// 为了保证 close() 一定会执行，就放到这里了
try {
fos .close();
} catch (IOException e) { e.printStackTrace();
}
}
}
C:要注意的问题
a:创建字节输出流对象做了几件事情 ?
1.调用系统功能去创建文件 2. 创 建 fos 对 象C: 把fos 对象指向这个文件
b: 为什么要 close()?
1. 让流对象变成垃圾，这样就可以被垃圾回收器回收了
2.通知系统去释放跟该文件相关的资源
c:如何实现数据的换行 ?
写入换行符号即可
fos.write("\r\n".getBytes());
d: 如何实现数据的追加写入 ?
new FileOutputStream("fos3.txt", true);
3.FileInputStream 读取数据
A:操作步骤
1.创建字节输入流对象 2.调用 read() 方法 3.释放资源
B： API
构造方法
FileOutputStream(File file) FileOutputStream(String name)
成员方法
int read(): 一次读取一个字节
int read(byte[] b): 一次读取一个字节数组
代码：复制
FileInputStream fis = newFileInputStream( "fos.txt" );
// 方式 1
int by = 0;
while ((by=fis.read())!=-1) {
System. out .print(( char ) by );
}
// 方式 2
byte [] bys = newbyte [1024];
int len = 0;
while ((len=fis.read(bys))!=-1) {
System. out .print( new String( bys ,0, len ));
}
fis.close();
案例:
// 高效字节流一次读写一个字节数组：
publicstaticvoid method4(String srcString, String destString) throws IOException { BufferedInputStream bis = newBufferedInputStream( new FileInputStream (srcString));
newBufferedOutputStream(new FileOutputStream(destString));
byte [] bys = newbyte [1024];
int len = 0;
while ((len = bis.read(bys)) != -1) { bos.write(bys, 0, len);
}
bos.close();
bis.close();
}
// 高效字节流一次读写一个字节：
publicstaticvoid method3(String srcString, String destString) throws IOException {
BufferedInputStream bis = newBufferedInputStream( new FileInputStream( srcString));
BufferedOutputStream bos = newBufferedOutputStream( new FileOutputStream(destString));
int by = 0;
while ((by = bis.read()) != -1) { bos.write(by);
}
bos.close();
bis.close();
}// 基本字节流一次读写一个字节数组
publicstaticvoid method2(String srcString, String destString) throws IOException {
FileInputStream fis = new FileInputStream(srcString); FileOutputStream fos = new FileOutputStream(destString); byte [] bys = newbyte [1024];
int len = 0;
while ((len = fis.read(bys)) != -1) { fos.write(bys, 0, len);
}
fos.close();
fis.close();
}// 基本字节流一次读写一个字节
publicstaticvoid method1(String srcString, String destString) throws IOException {
FileInputStream fis = new FileInputStream(srcString); FileOutputStream fos = new FileOutputStream(destString); int by = 0;
while ((by = fis.read()) != -1) { fos.write(by);
}
fos.close();
fis.close();
}4.字节缓冲区流
通过定义数组的方式确实比以前一次读取一个字节的方式快很多， 所以， 看来有一个缓冲区还是非常好的。
既然是这样的话，那么， java 开始在设计的时候，它也考虑到了这个问题，就专门提供了带缓冲区的字节类。
这种类被称为：缓冲区类 (高效类 )
A:BufferedOutputStream B:BufferedInputStream
