一分钟看懂字节流

1、字节流

字节流是什么：

​ 一切文件数据在存储时，都是以二进制数字的形式保存，都一个一个的字节，那么传输时一样如此。所以，字节流可以传输任意文件数据。在操作流的时候，我们要时刻明确，无论使用什么样的流对象，底层传输的始终为二进制数据。

流的关闭原则：

​ 先开后关，后开先关。

2、字节输出流 OutputStream：

* public void close()：关闭此输出流并释放与此流相关联的任何系统资源。  
* public void flush()  ：刷新此输出流并强制任何缓冲的输出字节被写出。  
* public void write(byte[] b)：将 b.length字节从指定的字节数组写入此输出流。  
* public void write(byte[] b, int off, int len) ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。  
*public abstract void write(int b) ：将指定的字节输出流。

		close方法，当完成流的操作时，必须调用此方法，释放系统资源。
1
2
3
4
5
6
7

FileOutputStream类

OutputStream有很多子类，我们从最简单的一个子类开始。

java.io.FileOutputStream 类是文件输出流，用于将数据写出到文件。
    
 //创建流对象
    
    public class FileOutputStreamConstructor throws IOException {
    public static void main(String[] args) {
   	 	// 使用File对象创建流对象
        File file = new File("a.xt");
        FileOutputStream fos = new FileOutputStream(file);
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("v.txt")
    }
}
//向文件写入int类型的数据
		1 创建流对象
		2 写数据
        3 关闭资源
public class Fwrite{
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt");     
      	// 写出数据
      	fos.write(97); // 写出第1个字节
      	fos.write(98); // 写出第2个字节
      	// 关闭资源
        fos.close();
    }
}
//换行书写
public class Fwrite{
    public static void main(String[] args) throws IOException {
        // 使用文件名称创建流对象
        FileOutputStream fos = new FileOutputStream("fos.txt");  
      	// 定义字节数组
      	byte[] words = {97,98,99,100,101};
      	// 遍历数组
        for (int i = 0; i < words.length; i++) {
          	// 写出一个字节
            fos.write(words[i]);
          	// 写出一个换行, 换行符号转成数组写出
            fos.write("\r\n".getBytes());
        }
      	// 关闭资源
        fos.close();
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

3、字节输入流InputStream

public void close() ：关闭此输入流并释放与此流相关联的任何系统资源。    
public abstract int read()： 从输入流读取数据的下一个字节。 
public int read(byte[] b)： 从输入流中读取一些字节数，并将它们存储到字节数组 b中 。
    
 //当创建一个流对象时，必须传入一个文件路径。该路径下，如果没有该文件,会抛出FileNotFoundException
    
    public class FileInput throws IOException{
    public static void main(String[] args) {
   	 	// 使用File对象创建流对象
        File file = new File("adc.txt");
        FileInputStream fos = new FileInputStream(file);
      
        // 使用文件名称创建流对象
        FileInputStream fos = new FileInputStream("b.txt");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

读取字节数据：

public class FRead {
    public static void main(String[] args) throws IOException{
    /* 
    	//一次读取一字节
    	// 使用文件名称创建流对象
       	FileInputStream fis = new FileInputStream("read.txt");
      	// 读取数据，返回一个字节
        int read = fis.read();
        System.out.println((char) read);
        read = fis.read()
         System.out.println((char) read);
        read = fis.read()
        System.out.println( read);
		// 关闭资源
        fis.close();
        
     */
        //循环读取数据
      	// 使用文件名称创建流对象
       	FileInputStream fis = new FileInputStream("read.txt");
      	// 定义变量，保存数据
        int b ；
        // 循环读取
        while ((b = fis.read())!=-1) {
            System.out.println((char)b);
        }
		// 关闭资源
        fis.close();
    }
}

//使用字节数组读取
public class FRead {
    public static void main(String[] args) throws IOException{
      	// 使用文件名称创建流对象.
       	FileInputStream fis = new FileInputStream("adc.txt"); // 文件中为abcde
      	// 定义变量，作为有效个数
        int len ；
        // 定义字节数组，作为装字节数据的容器   
        byte[] b = new byte[2];
        // 循环读取
        while (( len= fis.read(b))!=-1) {
           	// 每次读取后,把数组的有效字节部分，变成字符串打印
            System.out.println(new String(b，0，len));//  len 每次读取的有效字节个数
        }
		// 关闭资源
        fis.close();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49