IO流分类：(默认情况按照数据类型分)
        流向：(以java程序为参照物)
                输入流：读取数据
                输出流：写入数据
        数据类型：
                字节流
                        字节输入流：
                                读取数据：InputStream
                        字节输出流：
                                写入数据：OutputStream
                字符流
                        字符输入流：
                                读取数据：Reader
                        字符输出流：
                                写入数据：Writer

用系统自带的笔记本打开，读得懂的可以用字符流，读不懂就只能用字节流。

1. package com.kxg.IO;
   
2. 
   
3. import java.io.FileOutputStream;
   
4. import java.io.IOException;
   
5. 
   
6. /*
   
7. * 需求：往一个.txt文件里面写入hello,worle
   
8. *
   
9. * 往文件里面写入数据用OutputStreamhen
   
10. * 因为OutputStreamhen是抽象类，所以要用它的子类FileOutputStream
    
11. */
    
12. public class FileInputStreamDemo {
    
13.         public static void main(String[] args) throws IOException {
    
14. //                创建字节流对象
    
15.                 FileOutputStream fos = new FileOutputStream("a.txt");
    
16.                
    
17. //                调用write()方法
    
18.                 fos.write("hello,world".getBytes());
    
19.                
    
20. //                释放资源
    
21.                 fos.close();
    
22.         }
    
23. }

复制代码

创建字节流对象一共做了三件事：
        1.如果a.txt文件不存在，就创建一个a.txt文件
        2.创建fos对象
        3.把fos对象指向a.txt文件

write()方法：
        public void write(byte[] b)throws IOException
        public void write(byte[] b,int off,int len)throws IOException
        public abstract void write(int b)throws IOException
        write()方法需要传入的是字节数组，
        把需要传入的字符串转为字节数组传入就行。

close()：释放资源
        让流对象变成垃圾，可以被垃圾回收器回收
        通知系统释放跟该文件相关的资源

Write()方法：

1. package com.kxg.IO;
   
2. 
   
3. import java.io.FileOutputStream;
   
4. import java.io.IOException;
   
5. 
   
6. /*
   
7. * write()方法：
   
8. *                 public abstract void write(int b):写一个字节
   
9. *                 public void write(byte[] b)：写一个字节数组
   
10. *                 public void write(byte[] b,int off,int len):写一个字节数组的一部分
    
11. */
    
12. public class WriteDemo {
    
13.         public static void main(String[] args) throws IOException {
    
14.                 FileOutputStream fos = new FileOutputStream("a.txt");
    
15. 
    
16.                 fos.write(97);// 97底层二进制数据，通过记事本打开，记事本找到97对应的字符值就是a
    
17.                 fos.write("hello,java".getBytes());
    
18. 
    
19.                 byte[] by = { 97, 98, 99, 100 };
    
20.                 fos.write(by, 0, 2);// 包前不包后，包含0不包含2
    
21. 
    
22.                 fos.close();
    
23.         }
    
24. }

复制代码

数据换行和追加写入：

1. package com.kxg.IO;
   
2. 
   
3. import java.io.FileOutputStream;
   
4. import java.io.IOException;
   
5. import java.util.Scanner;
   
6. 
   
7. /*
   
8. * 需求：数据换行以及追加写入
   
9. */
   
10. public class WriteDemo2 {
    
11.         public static void main(String[] args) throws IOException {
    
12. 
    
13.                 // 构造方法的可以实现追加写入
    
14.                 FileOutputStream fos = new FileOutputStream("a.txt", true);
    
15. 
    
16.                 Scanner sc = new Scanner(System.in);
    
17.                 System.out.println("输入内容：");
    
18.                 String s = sc.nextLine();
    
19.                 fos.write(s.getBytes());
    
20.                 fos.write("\r\n".getBytes());
    
21. 
    
22.                 fos.close();
    
23.         }
    
24. }

复制代码

数据换行：
        不同的系统识别不同的换行符号
        windows：\r\n
        linux:\n
        MAC:\R
        常见的高级记事本所有的都可以识别。


数据追加写入：
        利用构造方法可以实现数据追加写入，每运行一次就写入一次。

读取数据：

1. package com.kxg.IO;
   
2. 
   
3. import java.io.FileInputStream;
   
4. import java.io.IOException;
   
5. 
   
6. /*
   
7. * 读取数据：
   
8. *         字节输入流
   
9. *                 创建字节输入流对象
   
10. *                 用read()方法，把结果显示在控制台
    
11. *                 释放资源
    
12. *
    
13. * read()方法：
    
14. *                 public int read()：一次读一个字节
    
15. *                 public int read(byte[] b)：一次对一个字节数组
    
16. *                 public int read(byte[] b,int off,int len)：一次对一个字节数组的一部分
    
17. */
    
18. public class ReadDemo {
    
19.         public static void main(String[] args) throws IOException {
    
20.                 FileInputStream fis = new FileInputStream("a.txt");
    
21.                
    
22. //                第一次读取
    
23.                 // int i = fis.read();
    
24.                 // System.out.println(i);
    
25.                 // System.out.println((char) i);//返回的是int类型的值，需要强制转换为char
    
26.                 //
    
27. //                第二次读取
    
28.                 // i = fis.read();
    
29.                 // System.out.println(i);
    
30.                 // System.out.println((char) i);
    
31.                 // System.out.println("===================");
    
32. 
    
33.                 // while循环改进
    
34.                 int by = 0;// 初始化变量
    
35.                 // 读取到最后再往后读就是-1，不等于-1的时候全打印出来
    
36.                 while ((by = fis.read()) != -1) {
    
37.                         System.out.print((char) by);
    
38.                 }
    
39. 
    
40.                 // 释放资源
    
41.                 fis.close();
    
42.         }
    
43. }

复制代码

复制内容到新文件中去：

1. package com.kxg.IO;
   
2. 
   
3. import java.io.FileInputStream;
   
4. import java.io.FileOutputStream;
   
5. import java.io.IOException;
   
6. 
   
7. /*
   
8. * 需求：把指定文件内容复制到指定文件里面去。
   
9. *
   
10. * 数据源：
    
11. *         a.txt        --读取        --FileInputStream
    
12. *
    
13. * 目的地：
    
14. *         b.txt        --写入        --FileOutputStream
    
15. */
    
16. public class CopyDemo2 {
    
17.         public static void main(String[] args) throws IOException {
    
18.                 // 封装数据源
    
19.                 FileInputStream fis = new FileInputStream("a.txt");
    
20.                 FileInputStream fis2 = new FileInputStream("D:\\Test\\a.txt");
    
21. 
    
22.                 // 封装目的地
    
23.                 FileOutputStream fos = new FileOutputStream("b.txt");
    
24.                 FileOutputStream fos2 = new FileOutputStream("D:\\Test\\Test2\\b.txt");
    
25. 
    
26.                 int i = 0;
    
27.                 while ((i = fis.read()) != -1) {
    
28.                         fos.write(i);
    
29.                 }
    
30.                 while ((i = fis2.read()) != -1) {
    
31.                         fos2.write(i);
    
32.                 }
    
33. 
    
34.                 fis.close();
    
35.                 fos.close();
    
36.                 fis2.close();
    
37.                 fos2.close();
    
38.         }
    
39. }

复制代码

汉字的存储：

1. package com.kxg.IO;
   
2. 
   
3. import java.util.Arrays;
   
4. 
   
5. /*
   
6. * 计算机中汉字存储：
   
7. *         一个汉字分为两个字节
   
8. *                 第一个字节肯定是负数
   
9. *                 第二个字节常见是负数，可能是正数，然并卵。
   
10. */
    
11. public class HanZiDemo {
    
12.         public static void main(String[] args) {
    
13.                 String s = "汉字";
    
14.                 byte[] by = s.getBytes();
    
15.                 System.out.println(Arrays.toString(by));
    
16.         }
    
17. }

复制代码

读取一个字节数组：

1. package com.kxg.IO;
   
2. 
   
3. import java.io.FileInputStream;
   
4. import java.io.IOException;
   
5. 
   
6. /*
   
7. * 一次读取一个字节数组：
   
8. *                 int read(byte[] b)        返回值为读取了几个字节
   
9. */
   
10. public class CopyDemo3 {
    
11.         public static void main(String[] args) throws IOException {
    
12.                 // 封装数据源
    
13.                 FileInputStream fis = new FileInputStream("a.txt");
    
14. 
    
15.                 // 定义一个字节数组
    
16.                 byte[] by = new byte[5];// 一般为1024或者它的倍数
    
17. 
    
18.                 // 第一次读取
    
19.                 // int i = fis.read(by);
    
20.                 // System.out.println(Arrays.toString(by));// 字节数组转为字符数组
    
21.                 // System.out.println(new String(by));// 字节数组转为字符串
    
22.                 // 每一次读取都会替换上一次相同索引的字节，换行符也会被读取。
    
23. 
    
24.                 // 第二次读取
    
25.                 // i = fis.read(by);
    
26.                 // System.out.println(new String(by));
    
27. 
    
28.                 int i = 0;
    
29.                 while ((i = fis.read(by)) != -1) {
    
30.                         System.out.println(new String(by));
    
31.                 }
    
32.                 // 释放资源
    
33.                 fis.close();
    
34.         }
    
35. }

复制代码

一次读取一个字节数组复制内容：

1. package com.kxg.IO;
   
2. 
   
3. import java.io.FileInputStream;
   
4. import java.io.FileOutputStream;
   
5. import java.io.IOException;
   
6. 
   
7. /*
   
8. * 需求：一次读取一个字节数组复制文件
   
9. *                
   
10. */
    
11. public class CopyDemo4 {
    
12.         public static void main(String[] args) throws IOException {
    
13.                 // 封装数据源
    
14.                 FileInputStream fis = new FileInputStream("a.txt");
    
15.                 FileInputStream fis2 = new FileInputStream("D:\\Test\\a.txt");
    
16. 
    
17.                 // 封装目的地
    
18.                 FileOutputStream fos = new FileOutputStream("b.txt");
    
19.                 FileOutputStream fos2 = new FileOutputStream("D:\\Test\\Test2\\b.txt");
    
20. 
    
21.                 byte[] by = new byte[1024];
    
22.                 int i = 0;
    
23.                 while ((i = fis.read(by)) != -1) {
    
24.                         fos.write(by, 0, i);
    
25.                 }
    
26.                 while ((i = fis2.read(by)) != -1) {
    
27.                         fos2.write(by, 0, i);
    
28.                 }
    
29. 
    
30.                 fis.close();
    
31.                 fos.close();
    
32.                 fis2.close();
    
33.                 fos2.close();
    
34.         }
    
35. }

复制代码

不错，赞一个

不错，学习了

字节缓冲区流：

1. package com.kxg.Buffer;
   
2. 
   
3. import java.io.BufferedInputStream;
   
4. import java.io.BufferedOutputStream;
   
5. import java.io.FileInputStream;
   
6. import java.io.FileOutputStream;
   
7. import java.io.IOException;
   
8. /*
   
9. * 缓冲区类(高效类)：
   
10. *
    
11. *         BufferedInputStream类：读
    
12. *                 public BufferedInputStream(InputStream in)：
    
13. *         BufferedOuputStream类：写
    
14. *                 public BufferedOutputStream(OutputStream out)：
    
15. * 构造方法参数问题：
    
16. *                 字节缓冲区流仅仅提供缓冲区，为高效而设计，真正做读写操作的还是基本的流对象实现。
    
17. */
    
18. 
    
19. public class BufferDemo {
    
20.         public static void main(String[] args) throws IOException {
    
21.                 BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
    
22.                                 "a.txt"));
    
23.                 BufferedOutputStream bos = new BufferedOutputStream(
    
24.                                 new FileOutputStream("b.txt"));
    
25. 
    
26.                 // int i;
    
27.                 // while ((i = bis.read()) != -1) {
    
28.                 // bos.write(i);
    
29.                 // }
    
30.                
    
31.                 byte[] by = new byte[1024];
    
32.                 int len=0;
    
33.                 while ((len = bis.read(by)) != -1) {
    
34.                         bos.write(by);
    
35.                 }
    
36. 
    
37.                 bis.close();
    
38.                 bos.close();
    
39.         }
    
40. }

复制代码