JAVA 字节流
作者：互联网
IO流概述和分类
IO流概述：
- IO：输入/输出（Input/Output）
- 流：是一种抽象概念，是对数据传输的总称。也就是说数据在设备间的传输称为流，流的本质是数据传输
- IO流就是用来处理设备间数据传输问题的
常见的应用：文件复制；文件上传；文件下载
IO流分类：
- 按照数据的流向
- 输入流：读数据
- 输出流：写数据
- 按照数据类型来分
- 字节流：字节输入流；字节输出流
- 字符流：字符输入流；字符输出流
一般来说，IO流的分类是按照数据类型来分的
如果数据通过Window自带的记事本软件打开，我们还可以读懂里面的内容，就使用字符流，否则使用字节流。如果不知道使用哪种类型的流，就饿使用字节流
字节流写数据
字节流抽象基类：
- InputStream：这个抽象类是表示字节输入流的所有类的超类
- OutputStream：这个抽象列是表示字节输出流的所有类的超类
- 子类名特点：子类名称都是以其父名作为子类名的后缀
FileOutputStream：文件输出流用与将数据写入File
- FileOutputStream(String name)：创建文件输出流以指定的名称写入文件
使用字节输出流写数据的步骤：
- 创建字节输出流对象（调用系统功能创建了文件，创建字节输出流对象，让字节输出流对象指向文件）
- 调用字节输出流对象的写数据方法
- 释放资源（关闭此文件输出流并释放与此流相关联的任何系统资源）
1 import java.io.FileOutputStream;
2 import java.io.IOException;
3
4 /*
5
6 字节流写数据**
7
8 字节流抽象基类：
9
10 - InputStream：这个抽象类是表示字节输入流的所有类的超类
11 - OutputStream：这个抽象列是表示字节输出流的所有类的超类
12 - 子类名特点：子类名称都是以其父名作为子类名的后缀
13
14 FileOutputStream：文件输出流用与将数据写入File
15
16 - FileOutputStream(String name)：创建文件输出流以指定的名称写入文件
17 */
18
19 public class FileOutputStreamDemo {
20 public static void main(String[] args) throws IOException {
21 //创建字节输出流对象
22 //FileOutputStream(String name)：创建文件输出流以指定的名称写入文件
23 FileOutputStream fos = new FileOutputStream("..\\hello java\\fos.txt");
24 /*
25 做了三件事：
26 调用系统功能创建了文件
27 创建了字符输出流对象
28 让字符输出流对象指向创建好的文件
29 */
30
31 //void write (int b)：将指定的字节写入此文件输出流
32 fos.write(97);//a
33 // fos.write(57);//9
34 // fos.write(55);//7
35
36 //最后都要释放资源
37 //void close():关闭此文件输出流并释放与此流相关联的任何系统资源
38 fos.close();
39
40 }
41 }
字节流输入的三种方式
1 import java.io.File;
2 import java.io.FileNotFoundException;
3 import java.io.FileOutputStream;
4 import java.io.IOException;
5
6 /*
7
8 构造方法：
9 FileOutputStream(String name)：创建文件输出以指定的名称写入文件
10 FileOutputStream(File file)：创建文件输出流以写入有指定的File对象表示的文件
11
12
13 字节流写数据的3种方法
14
15 void write(int b) 将指定的字节写入此文件输出流，
16 一次写一个字节数据
17 void write(byte[] b)将b.leangth字节从指定的字节数组写入此文件输出流，
18 一次写一个字节数组数据
19 void write(byte[] b,int off,int len)将len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流，
20 一次写一个字节数组的部分数据
21 */
22
23 public class FileOutputStreamDemo2 {
24 public static void main(String[] args) throws IOException {
25 //1:FileOutputStream(String name)：创建文件输出以指定的名称写入文件
26 FileOutputStream fos = new FileOutputStream("..\\hello java\\fos.txt");
27 //new File(name)
28 // FileOutputStream fos=new FileOutputStream(new File("..\\hello java\\fos.txt"));//相当于上面的
29
30 //2:FileOutputStream(File file)：创建文件输出流以写入有指定的File对象表示的文件
31 // File file=new File("..\\hello java\\fos.txt");
32 // FileOutputStream fos2=new FileOutputStream(file);
33 // FileOutputStream fos2=new FileOutputStream(new File("..\\hello java\\fos.txt"));//两种都可以
34
35 //void write(int b) 将指定的字节写入此文件输出流，
36 //一次写一个字节数据
37 // fos.write(97);
38 // fos.write(98);
39 // fos.write(99);
40 // fos.write(100);
41 // fos.write(101);
42 /*abcde*/
43
44 //void write(byte[] b)将b.leangth字节从指定的字节数组写入此文件输出流，
45 //一次写一个字节数组数据
46 // byte[] bys= {97,98,99,100,101};
47 //byte[] getByted():返回字符串对应的字节数组
48 byte[] bys = "abcde".getBytes();
49 // fos.write(bys);
50 /*abcde*/
51
52 //void write(byte[] b,int off,int len)将len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流，
53 //一次写一个字节数组的部分数据
54 // fos.write(bys,0,bys.length);//abcde
55 fos.write(bys, 1, 3);//bcd
56
57 //释放资源
58 fos.close();
59
60 }
61 }
字节流写数据的两个小问题
字节流写数据如何实现换行？
- 写完数据后，加换行符
- window：\r\n
- linux：\n
- mac：\r
字节流写数据如何实现追加写入？
- public FileOutputStream(String name,boolean append)
- 创建文件输出流以指定的名称写入文件。如果第二个参数为true，则字节将写入文件的末尾而不是开头
1 import java.io.FileOutputStream;
2 import java.io.IOException;
3
4 /*
5 字节流写数据的两个小问题
6
7 1.字节流写数据如何实现换行？
8 不同系统换行识别是不一样的
9 windeow:\r\n
10 linux:\n
11 mac:\r
12
13 2.字节流写数据如何实现追加写入？
14 public fileOutputStream(String name,boolean append)
15 创建文件输出流以指定的名称写入文件。
16 如果第二个参数为true，则字节将写入文件的末尾而不是开头
17 */
18
19 public class FileOutputStreamDemo3 {
20 public static void main(String[] args) throws IOException {
21 //创建字节输出流对象
22 // FileOutputStream fos=new FileOutputStream("..\\hello java\\fos.txt");
23 FileOutputStream fos = new FileOutputStream("..\\hello java\\fos.txt", true);
24
25 //写数据
26 for (int i = 0; i < 10; i++) {
27 fos.write("hello".getBytes());
28 fos.write("\r\n".getBytes());//换行
29 }
30
31 //释放资源
32 fos.close();
33
34 }
35 }
字节流写数据加入异常处理
finally：在异常处理时提供finally块来执行所有清楚操作。比如说IO流中的释放资源
特点：被finally控制的语句一定会执行，除非JVM退出
1 try{
2 可能出现异常的代码;
3 }catch(异常类名 变量名){
4 异常的处理代码;
5 }finally{
6 执行所有清楚操作;
7 }
1 import java.io.FileOutputStream;
2 import java.io.IOException;
3
4 /*
5 字节流数据加入异常处理
6 */
7 public class FileOutputStreamDemo4 {
8 public static void main(String[] args) {
9 /*
10 try {
11 FileOutputStream fos = new FileOutputStream("..\\hello java\\fos.txt");
12 fos.write("hello".getBytes());
13 fos.close();
14 } catch (IOException e) {
15 e.printStackTrace();
16 }
17 */
18
19 //加入finally来实现释放资源
20 FileOutputStream fos = null;//在外面创建fos，给初始化null
21 try {
22 // fos=new FileOutputStream("Z:\\hello java\\fos.txt");//错误地址
23 fos = new FileOutputStream("..\\hello java\\fos.txt");
24 fos.write("hello".getBytes());
25 fos.close();
26 } catch (IOException e) {
27 e.printStackTrace();
28 } finally {
29 if (null != fos) {//释放资源前对fos进行不为null的判断
30 try {
31 fos.close();//快捷键try...catch方法
32 } catch (IOException e) {
33 // TODO Auto-generated catch block
34 e.printStackTrace();
35 }
36 }
37 }
38
39 }
40 }
字节流读数据（一次读一个字节数据）
FileInputStream：从文件系统中的文件获取输入字节
- FileInputStream(String name)：通过打开与实际文件的连接俩创建一个FileInputStream，该文件由文件系统中的路径名name命名
使用字节输入流读数据的步骤：
- 创建字节输入流对象
- 调用字节输入流对象的读数据方法
- 释放资源
1 import java.io.FileInputStream;
2 import java.io.IOException;
3
4 /*
5 字节流读数据（一次读一个字节数据）**
6
7 需求：把文件fos.txt中的内容读取出来在控制台输出
8
9 FileInputStream：从文件系统中的文件获取输入字节
10
11 - FileInputStream(String name)：通过打开与实际文件的连接俩创建一个FileInputStream，该文件由文件系统中的路径名name命名
12
13 使用字节输入流读数据的步骤：
14
15 1. 创建字节输入流对象
16 2. 调用字节输入流对象的读数据方法
17 3. 释放资源
18 */
19
20 public class FileInputStreamDemo {
21 public static void main(String[] args) throws IOException {
22 //创建字节输入流对象
23 //FileInputStream(String name)
24 FileInputStream fis = new FileInputStream("..\\hello java\\fos.txt");
25 /*
26 fos.txt中的内容
27 ab
28 */
29
30 //调用字节输入流对象的读数据方法
31 //int read():从该输入流读取一个字节的数据
32
33 /*
34 //第一次读取数据
35 int i = fis.read();
36 System.out.println(i);//97
37 System.out.println((char)i);//a 强制转换
38
39 //第一次读取数据
40 i = fis.read();
41 System.out.println(i);//98
42 System.out.println((char)i);//b 强制转换
43
44 //再多读取两次
45 i = fis.read();
46 System.out.println(i);//-1 文件中没有数据了，返回-1
47 i = fis.read();
48 System.out.println(i);//-1
49 */
50
51 /*
52 //判断条件：文件末尾-1
53 int by=fis.read();
54 while(by!=-1) {
55 // System.out.println(by);
56 System.out.print((char)by);
57 by=fis.read();
58 }
59 运行结果：
60 ab
61
62 */
63
64 //优化上面的程序
65 int by;
66 /*
67 fis.read():读数据
68 by=fis.read():把读取到的数据赋值给by
69 by！=-1:判断读取到的数据是否是-1
70
71 */
72 while ((by = fis.read()) != -1) {
73 System.out.print((char) by);
74 }
75 // 运行结果：
76 // ab
77
78 //释放资源
79 fis.close();
80
81 }
82 }
案例：复制文本文件
分析：复制文本文件，就是把文件内容从一个文件中读取出来（数据源），然后写入另一个文件中（目的地）
1 import java.io.FileInputStream;
2 import java.io.FileOutputStream;
3 import java.io.IOException;
4
5 /*
6 案例：复制文本文件
7 需求：把“E:\\\itcast\\\窗里窗外.txt”复制到模块目录下的“窗里窗外.txt”
8
9 分析：复制文本文件，就是把文件内容从一个文件中读取出来（**数据源**），然后写入另一个文件中（**目的地**）
10
11 数据源：E:\\\itcast\\\窗里窗外.txt---读数据---InputStream---FileInputStream
12 目的地：..\\\hello java\\\窗里窗外.txt---写数据---OutputStream---FileOutputStream
13
14 */
15 public class CopyDemo {
16 public static void main(String[] args) throws IOException {
17 //根据数据源创建字节输入流对象
18 FileInputStream fis = new FileInputStream("E:\\itcast\\窗里窗外.txt");
19
20 //根据目的地创建字节输出流对象
21 FileOutputStream fos = new FileOutputStream("..\\hello java\\窗里窗外.txt");
22
23 //读写数据，复制文本文件（一次读取一个字节，一次写入一个字节）
24 int by;
25 while ((by = fis.read()) != -1) {
26 fos.write(by);
27 }
28
29 //释放资源
30 fos.close();
31 fis.close();
32
33 }
34 }
字节流读数据（一次读一个字节数组数据）
需求：把文件fos.txt中的内容读取出来在控制台输出
使用字节输入流读数据的步骤：
- 创建字节输入流对象
- 调用字节输入流对象的读数据方法
- 释放资源
1 import java.io.FileInputStream;
2 import java.io.IOException;
3
4 /*
5 字节流读数据（一次读一个字节数组数据）**
6
7 需求：把文件fos.txt中的内容读取出来在控制台输出
8
9 使用字节输入流读数据的步骤：
10
11 1. 创建字节输入流对象
12 2. 调用字节输入流对象的读数据方法
13 3. 释放资源
14 */
15 public class FileInputStreamDemo2 {
16 public static void main(String[] args) throws IOException {
17 //创建字节输入流对象
18 FileInputStream fis = new FileInputStream("..\\hello java\\fos.txt");
19
20 //调用字节输入流对象的读数据方法
21 //int read(byte[] b)：从该输入流读取最多 b.length个字节的数据到一个字节数组
22
23 /*
24 byte[] bys=new byte[5];
25
26 //第一次读取数据
27 int len = fis.read(bys);
28 System.out.println(len);
29 //String(byte[] bytes)
30 // System.out.println( new String(bys) );
31 System.out.println( new String(bys,0,len) );
32
33 //第二次读取数据
34 len = fis.read(bys);
35 System.out.println(len);
36 // System.out.println( new String(bys) );
37 System.out.println( new String(bys,0,len) );
38
39 //第三次读取数据
40 len = fis.read(bys);
41 System.out.println(len);
42 //String(byte[] bytes,int offset,int length)
43 System.out.println( new String(bys,0,len) );
44 // System.out.println( new String(bys) );
45
46 //再多读取两次
47 len = fis.read(bys);
48 System.out.println(len);
49 len = fis.read(bys);
50 System.out.println(len);
51
52 运行结果：
53 5
54 hello
55 5
56
57 wor
58 5
59 ld
60
61 -1
62 -1
63
64
65 */
66
67 /*
68 hello\r\n
69 world\r\n
70
71 第一次：hello
72 第二次：\r\nwor
73 第三次：ld\r\nr
74 */
75
76 byte[] bys = new byte[1024];//1024及其整数倍
77 int len;
78 while ((len = fis.read(bys)) != -1) {
79 System.out.print(new String(bys, 0, len));
80 }
81 /*
82 运行结果：
83 hello
84 world
85
86 */
87
88 //释放资源
89 fis.close();
90
91 }
92 }
复制图片
1 import java.io.FileInputStream;
2 import java.io.FileOutputStream;
3 import java.io.IOException;
4
5 /*
6 案例：复制图片
7
8 需求：把“E:\\\itcast\\\mn.jpg”复制到模块目录下的“mn.jpg”
9
10 */
11 public class CopyJpg {
12 public static void main(String[] args) throws IOException {
13 //根据数据源创建字节输入流对象
14 FileInputStream fis = new FileInputStream("E:\\itcast\\mn.jpg");
15
16 //根据目的地创建字节输出流对象
17 FileOutputStream fos = new FileOutputStream("..\\hello java\\mn.jpg");
18
19 //读写数据，复制图片（一次读取一个字节数组，一次写入一个字节数组）
20 byte[] bys = new byte[1024];
21 int len;
22 while ((len = fis.read(bys)) != -1) {
23 fos.write(bys, 0, len);
24 }
25
26 //释放资源
27 fis.close();
28 fos.close();
29
30 }
31 }
字节缓冲流
字节缓冲流：
- BufferOutputStream：该类实现缓冲输出流。通过设置这样的输出流，应用程序可以向底层输出流写入字节，而不必为写入的每个字节导致底层系统的调用（一次多写点）
- BufferedInputStream：创建BufferedInputStream将创建一个内部缓冲区数组。当从流中读取或跳过字节时，内部缓冲区将根据需要 从 所包含的输入流中重新填充，一次很多字节（一次多读点）
构造方法：
- 字节缓冲输出流：BufferedOutputStream(OutputStream out)
- 字节缓冲输入流：BufferedInputStream(InputStream in)
为什么构造方法需要的是字节流，而不是具体的文件或者路径呢？
- 字节缓冲流仅仅是提供缓冲区，而真正的读写数据还得依靠基本的字节流对象进行操作
1 import java.io.BufferedInputStream;
2 import java.io.BufferedOutputStream;
3 import java.io.FileInputStream;
4 import java.io.FileOutputStream;
5 import java.io.IOException;
6
7 /*
8 字节缓冲流：
9
10 - BufferOutputStream：该类实现缓冲输出流。通过设置这样的输出流，应用程序可以想底层输出流写入字节，而不必为写入的每个字节导致底层系统的调用
11 - BufferedInputStream：创建BufferedInputStream将创建一个内部缓冲区数组。当从流中读取或跳过字节时，内部缓冲区将根据需要从所包含的输入流中重新填充，一次很多字节
12
13 构造方法：
14
15 - 字节缓冲输出流：BufferedOutputStream(OutputStream out)
16 - 字节缓冲输入流：BufferedInputStream(InputStream in)
17
18 */
19 public class BufferStreamDemo {
20 public static void main(String[] args) throws IOException {
21 //字节缓冲输出流：BufferedOutputStream(OutputStream out)
22 // FileOutputStream fos=new FileOutputStream("..\\hello java\\bos.txt");
23 // BufferedOutputStream bos=new BufferedOutputStream(fos);
24
25 //合并成一步
26 BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("..\\hello java\\bos.txt"));
27 //写数据
28 bos.write("hello\r\n".getBytes());
29 bos.write("world\r\n".getBytes());
30 //释放资源
31 bos.close();
32
33 //字节缓冲输入流：BufferedInputStream(InputStream in)
34 BufferedInputStream bis = new BufferedInputStream(new FileInputStream("..\\hello java\\bos.txt"));
35
36 //读数据
37 /*
38 //一次读取一个字节数据
39 int by;
40 while((by=bis.read())!=-1) {
41 System.out.print((char)by);
42 }
43 */
44 //一次读取一个字节数组的数据
45 byte[] bys = new byte[1024];
46 int len;
47 while ((len = bis.read(bys)) != -1) {
48 System.out.print(new String(bys, 0, len));
49 }
50
51 //释放资源
52 bis.close();
53
54 }
55 }
案例：复制视频
1 import java.io.BufferedInputStream;
2 import java.io.BufferedOutputStream;
3 import java.io.FileInputStream;
4 import java.io.FileOutputStream;
5 import java.io.IOException;
6
7 /*
8 案例：复制视频
9 需求：把“E:\\\itcast\\\字节流复制图片.avi”复制到模块目录下的“字节流复制图片.avi”
10 思路：
11
12 1. 根据数据源创建字节输入流对象
13 2. 根据目的地创建字节输出流对象
14 3. 读写数据，复制视频
15 4. 释放资源
16
17
18 四种方式实现复制视频，并记录每种方式复制视频的时间
19 1.基本字节流一次读写一个字节 共耗时：72743毫秒
20 2.基本字节流一次读写一个字节数组 共耗时：87毫秒
21 3.字节缓冲流一次读写一个字节 共耗时：198毫秒
22 4.字节缓冲流一次读写一个字节数组 共耗时：22毫秒
23
24 */
25
26 public class CopyAviDemo {
27 public static void main(String[] args) throws IOException {
28 //记录开始时间
29 long startTime = System.currentTimeMillis();
30
31 //复制视频
32 // method1();
33 // method2();
34 // method3();
35 method4();
36
37 //记录结束时间
38 long endTime = System.currentTimeMillis();
39 System.out.println("共耗时：" + (endTime - startTime) + "毫秒");
40
41 }
42
43 //4.字节缓冲流一次读写一个字节数组
44 private static void method4() throws IOException {
45 BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\itcast\\字节流复制图片.avi"));
46 BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("..\\hello java\\字节流复制图片.avi"));
47
48 byte[] bys = new byte[1024];
49 int len;
50 while ((len = bis.read(bys)) != -1) {
51 bos.write(bys, 0, len);
52 }
53
54 bis.close();
55 bos.close();
56
57 }
58
59 //3.字节缓冲流一次读写一个字节
60 private static void method3() throws IOException {
61 BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\itcast\\字节流复制图片.avi"));
62 BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("..\\hello java\\字节流复制图片.avi"));
63
64 int by;
65 while ((by = bis.read()) != -1) {
66 bos.write(by);
67 }
68
69 bis.close();
70 bos.close();
71
72 }
73
74 //2.基本字节流一次读写一个字节数组
75 private static void method2() throws IOException {
76 FileInputStream fis = new FileInputStream("E:\\itcast\\字节流复制图片.avi");
77 FileOutputStream fos = new FileOutputStream("..\\hello java\\字节流复制图片.avi");
78
79 byte[] bys = new byte[1024];
80 int len;
81 while ((len = fis.read(bys)) != -1) {
82 fos.write(bys, 0, len);
83 }
84
85 fis.close();
86 fos.close();
87
88 }
89
90 //1.基本字节流一次读写一个字节
91 private static void method1() throws IOException {
92 //E:\\\itcast\\\字节流复制图片.avi
93 //模块目录下的字节流复制图片.avi
94 FileInputStream fis = new FileInputStream("E:\\itcast\\字节流复制图片.avi");
95 FileOutputStream fos = new FileOutputStream("..\\hello java\\字节流复制图片.avi");
96
97 int by;
98 while ((by = fis.read()) != -1) {
99 fos.write(by);
100
101 }
102
103 fos.close();
104 fis.close();
105 }
106 }
标签：java,字节,fos,bys,FileOutputStream,new,JAVA 来源： https://www.cnblogs.com/cuipengchong/p/16244213.html