字节流

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