(42)Java学习笔记——IO流 / 字节流
IO流
用来处理设备之间的数据传输
Java对数据传输采用流的方式
Java中IO流的分类：
流向分 ：
--------| 输入流
--------| 输出流
数据类型分：
--------| 字节流
--------| 字符流 （为了方便操作文本数据）
IO流的常用基类：
字节流的抽象基类：
InputStream , OutputStream
字符流的抽象基类
Reader , Writer
由于是抽象类，所以要通过其子类来实例化。
每一种基类的子类都是以父类名作为后缀名。XXXReader , XXXWriter 等
FileOutputStream类的构造方法
FileOutputStream(File file)
FileOutputStream(String name)
字节流写数据的方式：
public void write(int b) //写一个字节
public void write(byte[ ] b) //写一个字节数组
public void wirte(byte[ ] b,int off , int len) //写一个字节数组的一部分
字节流输出流操作步骤：
A : 创建字节输出流对象
B: 写数据
C: 释放资源
范例：
package cn.itcast_01;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/*
* 需求：往一个文本文件中输入一句话"hello,io"
* 分析：
* 要往文件中写一句话，所以采用字节输出流
*/
public class IODemo {
public static void main(String[] args) throws IOException {
//创建字节输出流对象
//FileOutputStream(String name)
FileOutputStream fos = new FileOutputStream("fos.txt");
//调方法写数据
//先把字符串hello,io转字节数组
String s = "hello,io";
byte[] chs = s.getBytes();
fos.write(chs);
//释放资源（关闭输出流，释放系统资源）不关闭就可以一直使用
fos.close();
}
}
字节输出流实现数据换行
加入换行符\r\n
字节输出流实现数据的追加写入
用构造方法带第二个参数true，即可
FileOutputStream fos = new FileOutputStream("fos2.txt",true); //加入true参数，追加写入
FileOutputStream写数据加入异常处理：
范例：
package cn.itcast_01;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/*
* 加入异常处理的字节输出流操作
*
*/
public class FileOutputStreamDemo_02 {
public static void main(String[] args) {
//分开做异常处理
//创建字节流对象
FileOutputStream fos =null; //注意这个null
try {
fos = new FileOutputStream("fos3.txt");
} catch (FileNotFoundException e) {
e.printStackTrace();
}
//写入数据
try {
fos.write("java".getBytes());
} catch (IOException e) {
e.printStackTrace();
}
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}字节输入流操作步骤：
A / 创建字节流输入流对象
B/ 调用read()方法读取数据，并把数据显示在控制台
C / 释放资源
构造函数
FileInputStream(String name)
读取数据的方式：
A / int read() // 一次读取一个字节
B / int read(byte[ ] b) // 一次读取一个字节数组
范例：
package cn.itcast_02;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/*
* 字节输入流操作步骤：
A / 创建字节流输入流对象
B/ 调用read()方法读取数据，并把数据显示在控制台
C / 释放资源
读取数据的方式：
A / int read()
B / int read(byte[ ] b)
*/
public class InputStreamDemo {
public static void main(String[] args) throws IOException {
//创建字节流输入流对象
FileInputStream fis = new FileInputStream("fis.txt");
/* //调用read()方法读取数据，并把数据显示在控制台
//第一次读取
int by = fis.read();
System.out.println((char)by);
//第二次读取
int by2 = fis.read();
System.out.println((char)by2);
//第三次读取
int by3 = fis.read();
System.out.println((char)by3);
System.out.println("---------------------");
*/
/* //用循环改进，如何控制循环条件？
int by = fis.read();
while(by != -1){
System.out.print((char) by);
by = fis.read();
}
*/
//标准版代码
int by = 0;
//读取，赋值，判断
while ((by = fis.read()) != -1 ){
System.out.print((char) by);
}
//释放资源
fis.close();
}
}字节流复制文件：
单字节复制：
package cn.itcast_03;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/*
* CopyFile
* 从哪里来，到哪里去
* 范例：
* 从a.txt ------读取数据------FileInputStream
* 到 b.txt------写数据------FileOutputStream
*
*/
public class CopyFileDemo {
public static void main(String[] args) throws IOException {
//封装数据源
FileInputStream fis = new FileInputStream("f:\\a.txt");
//封装目的地
FileOutputStream fos = new FileOutputStream("g:\\b.txt");
//循环读取数据
int by = 0;
while ((by=fis.read())!= -1){
fos.write(by);
}
//释放资源
fos.close();
fis.close();
}
}
package cn.itcast_03;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/*
* 需求：把f:\\a.txt 内容复制到g:\\b.txt中
*
* 数据源：f:\\a.txt ----读取数据-----FileInputStream
* 目的地：g:\\b.txt----写入数据------FileOutputStream
*/
public class CopyFileDemo_02 {
public static void main(String[] args) throws IOException {
//封装数据源
FileInputStream fis = new FileInputStream("f:\\a.txt");
FileOutputStream fos = new FileOutputStream("g:\\b.txt");
//复制数据
byte[] bys =new byte[1024];
int len = 0;
while((len = fis.read(bys))!=-1){
fos.write(bys, 0, len);
}
//释放资源
fos.close();
fis.close();
}
}
字节流复制图片：
package cn.itcast_03;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/*
* CopyFile复制图片
* 数据源：F:\\马士兵.jpg------读取-----FileInputStream
* 数据源：g:\\msb.jpg-----写出-----FileOutputStream
*/
public class CopyFileDemo_03 {
public static void main(String[] args) throws IOException {
//封装数据源
FileInputStream fis = new FileInputStream("F:\\马士兵JAVA.jpg");
FileOutputStream fos = new FileOutputStream("g:\\msb.jpg");
//复制数据
byte[] bys = new byte[1024];
int len = 0;
while((len = fis.read(bys))!=-1){
fos.write(bys, 0, len);
}
//释放资源
fos.close();
fis.close();
}
}___________________________________
字节缓冲区流
BufferedOutputStream 字节缓冲输出流
构造方法：
BufferedOutputStream(OutputStream out)
不传递一个具体的文件或者文件路径，传递的是一个OutputStream抽象类对象。
字节缓冲区流仅仅提供缓冲区，真正的读写操作还得靠基本的流对象实现。
范例：
package cn.itcast_04;
import java.io.BufferedOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/*
* BufferedOutputStream
*
*/
public class BufferedOutputStreamDemo {
public static void main(String[] args) throws IOException {
//BufferedOutputStream(OutputStream out) 构造方法，传递的是抽象类
/* FileOutputStream fos = new FileOutputStream("bos.txt");
BufferedOutputStream bos = new BufferedOutputStream(fos);*/
//简单写法：
BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream("bos.txt"));
//写数据
bos.write("hello".getBytes());
//释放资源
bos.close();
}
}BufferedInputStream 字节缓冲输入流
构造方法：
BufferedInputStream(InputStream in)
不传递一个具体的文件或者文件路径，传递的是一个InputStream抽象类对象。
字节缓冲区流仅仅提供缓冲区，真正的读写操作还得靠基本的流对象实现。
范例：
package cn.itcast_04;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/*
* BufferedInputStream
*/
public class BufferedInputStreamDemo {
public static void main(String[] args) throws IOException {
//BufferedInputStream(InputStream in)
BufferedInputStream bis = new BufferedInputStream(
new FileInputStream("bos.txt"));
//读取数据
byte[] bys = new byte[1024];
int len = 0;
while((len = bis.read(bys))!= -1){
System.out.print(new String(bys,0,len));
}
//释放资源
bis.close();
}
}