流：流分为字节流（以字节为单位）和字符流（以字符为单位）。字节流和字符流又有一个共性，两个都有输入流和输出。本章主要讲解字节流。
字节输出流：使用字节输出流必须用到一个类，这个类是所有输出流的基类：OutputStream。
下面介绍一下OutputStream类的所有方法：
·public abstract void write(int b) throws IOException：
【向指定的文件中写入内容，每次写入一个字节，因为字节可以自动转换成int类型，但是这里需要使用到循环写入】
·public void write(byte[] b) throws IOException
【将内容转换成字节数组，之后再写入】
·public void write(byte[] b, int off, int len) throws IOException
【将字节数组的部分输出，off表示输出的内容的起始下标，len表示输出的长度】
·public void close() throws IOException
【关闭流，避免浪费资源】
public void flush() throws IOException
【刷新此输出流并强制写出所有缓冲的输出字节。】
示例：要想使用字节输出流还需要实现OutputStream的子类，这个子类java中已近给我们提供了：FileOutputStream
package com.zhaoqian.outputstream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
public class Demo2 {
private static final String LINE_SEPARATOR = System.getProperty("line.separator");
public static void main(String[] args) throws Exception {
File f = new File("D:"+File.separator+"Demo"+File.separator+"test.txt");
if (!f.getParentFile().exists()) {
f.getParentFile().mkdirs();
f.createNewFile();
}
// 要写入文件中的内容，换行输出
String str = LINE_SEPARATOR+"这是一个测试java字节输出流的文件";
// 实例化一个流对象
OutputStream os = new FileOutputStream(f,true); // 如果不加true进行追加的化，后的内容会覆盖前面的内容
//将字符串转换成字节数组
byte[] by = str.getBytes();
// 第一种写入方法
for(byte b:by){
os.write(b);
}
// 第二种方法,写入一个字节数组的内容(把所有内容存放在字节数组中)
// os.write(by);
// 第三种写法：部分写入
// os.write(by, 0, 5);
// 刷新数据
os.flush();
// 关闭资源
os.close();
}
}
上面是java中字节输出流，下面是字节输入流，和字节输出流一样，输出流也有一个基类：InputStream.所有的输入流都是继承了这个类。
而要实现字节输入流也需要实现InputStream的子类，这个子类同样java中提供了:FileInputStream:
下面先介绍一下InputStream的常用的方法:
·public abstract int read() throws IOException：
【将文件中的内容读取出来，每次读取一个字节，会自动将byte转换成int返回，如果没有数据返回-1】
·public int read(byte[] b) throws IOException：
【每次读取一个字节数组长度的内容，返回的是读取到的长度，如果没有数据返回-1】
·public int read(byte[] b, int off, int len) throws IOException：
【将内容读取到数组的部分元素，off表示起始下标，len表示长度，返回的是读取到的长度，如果没有数据返回-1】
示例：
package com.zhaoqiang.inputstream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
public class Demo2 {
public static void main(String[] args) throws Exception {
File f = new File("D:"+File.separator+"Demo"+File.separator+"test.txt");
if (!f.getParentFile().exists()) {
f.getParentFile().mkdirs();
f.createNewFile();
}
// 实例化一个字节输入流对象
InputStream is = new FileInputStream(f);
byte[] by = new byte[2];
int len = 0;
test2(is, by);
// test1(is);
}
private static void test2(InputStream is, byte[] by) throws IOException {
int len;
StringBuffer sb = new StringBuffer();
while((len = is.read(by)) != -1){
sb.append(new String(by,0,len));
// System.out.println(new String(by,0,len));
}
System.out.println(sb);
is.close();
}
private static void test1(InputStream is) throws IOException {
// 定义一个字节数组.用于接受读取到的字节,数组长度必须大于或等于所读内容的字节数
//byte[] by = new byte[1024];
// 一个自己数组和文件字节大小一样，不建议这样使用.因为一个文件过大，内存容易溢出
byte[] by = new byte[is.available()];
int temp = 0;
int index = 0;
while((temp = is.read()) != -1){
by[index++] = (byte)temp;
}
// 将一个字节数组转换成字符串输出
// System.out.println(new String(by));
System.out.println(new String(by,0,index));
is.close();
}
}
IO中异常处理示例：
package com.zhaoqiang.inputstream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
public class Demo3 {
/*
* 异常处理
* */
public static void main(String[] args) {
File file = new File("D:"+File.separator+"Demo"+File.separator+"test.txt");
if (!file.getParentFile().exists()) {
file.getParentFile().mkdirs();
try {
file.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
}
OutputStream os = null;
try {
os = new FileOutputStream(file);
os.write("测试数据".getBytes());
} catch (IOException e) {
// e.printStackTrace();
System.out.println(e.toString());
throw new RuntimeException("文件创建错误");
}finally{
// 关闭资源时候发生了IO异常
if (os == null) {
System.out.println("文件创建失败");
}else{
try {
// 这个地方的情况必须是文件创建成功之后
os.close();
} catch (IOException e) {
throw new RuntimeException("底层出错");
}
}
}
}
}
示例：通过字节流复制文件
package com.zhaoqiang.inputstream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
public class Demo4 {
/*
* 用字节流复制一个文件
* */
public static void main(String[] args) throws IOException {
// 源文件
File file = new File("D:"+File.separator+"Demo"+File.separator+"1.jpg");
// 目的地
File fe = new File("F:"+File.separator+"Demo"+File.separator+"11.jpg");
// 创建流
OutputStream os = new FileOutputStream(fe);
InputStream in = new FileInputStream(file);
// 使用输入流的读取方式读取字节，并将字节写入到目的中
int len = 0;
byte[] by = new byte[1024];
// 读一个写一个
while((len = in.read(by))!=-1){
os.write(by);
}
// 关闭资源
in.close();
os.close();
}
}
上面的代码解释图形：
