标签：java 字节 fos bys FileOutputStream new 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
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。