JavaSE 进阶 (9) 字节流

1
2
3

int a = 10;
int [] arr = {1,2,3,4,5};
ArrayList<String> list = new ArrayList<>();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

public static void main(String[] args) throws IOException{
	//1.创建字节输出流的对象---告诉虚拟机我要往哪个文件中写数据了
	FileOutputStream fos = new FileOutputStream("D:\\a.txt");
	//FileOutputstream fos = new Fileoutputstream(new File("D:\\a.txt"));

	//2.写数据
	fos.write(97);
	
	//3.释放资源
	fos.close();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

public class OutputDemo3{
	public static void main(String[] args)throws IOException{
		FileOutputStream fos = new FileOutputStream("bytestream\\a.txt");
		fos.write(97);
		fos.write(98);
		fos.write(99);
		
		fos.close();
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

public class OutputDemo3{
	public static void main(String[] args)throws IOException{
		FileOutputStream fos = new FileOutputStream("bytestream\\a.txt");
		
		byte[] bys = {97, 98, 99};
		fos.write(bys);  //abc
		
		fos.close();
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

public class OutputDemo3{
	public static void main(String[] args)throws IOException{
		FileOutputStream fos = new FileOutputStream("bytestream\\a.txt");
		
		byte[] bys = {97, 98, 99, 100, 101, 102, 103};
		fos.write(bys, 1, 2);  //bc
		
		fos.close();
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

FileOutputStream fos = new FileOutputStream( name:"bytestream\\a.txt");

fos.write(97);
//能加一个换行\r\n
fos.write("\r\n");
fos.write(98);
//能加一个换行
fos.write(99);
//能加一个换行
fos.write(100);
//能加一个换行
fos.write(101);
//能加一个换行

fos.close();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

FileOutputStream fos = new FileOutputStream( name:"bytestream\\a.txt");

fos.write(97);
//能加一个换行\r\n
fos.write("\r\n".getBytes());
fos.write(98);
//能加一个换行
fos.write("\r\n".getBytes());
fos.write(99);
//能加一个换行
fos.write("\r\n".getBytes());
fos.write(100);
//能加一个换行
fos.write("\r\n".getBytes());
fos.write(101);
//能加一个换行
fos.write("\r\n".getBytes());

fos.close();

1

FileOutputStream fos = new FileOutputStream("bytestream\\a.txt", true);

1
2
3
4
5
6
7

try {
    FileOutputStream fos = new FileOutputStream("a.txt");
    fos.write(97);
    fos.close();
} catch (IOException e) {
    e.printStackTrace();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

public static void main(String[] args) {
 String filePath = "E:\\_89R1044.JPG";
	 //1、try外层声明资源的引用
    FileInputStream inputStream = null;
    try {
        //2、创建和具体资源的连接
        inputStream = new FileInputStream(new File(filePath));
        //3、对资源的操作
        System.out.println(inputStream.available());
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        //3、关闭流
        if (inputStream!=null){
            try {
                inputStream.close();
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

public static void main(String[] args) {
 String filePath = "E:\\_89R1044.JPG";
        //1、try中声明对资源的引用和创建具体的连接
    try(InputStream inputStream = new FileInputStream(new File(filePath));) {
        //2、对资源的操作
        System.out.println(inputStream.available());
    } catch (Exception e) {
        e.printStackTrace();
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

public static void main(String[] args) throws IOException{
	//如果文件存在，那么就不会报错。
	//如果文件不存在，那么就直接报错，
	FileInputStream fis = new FileInputStream("bytestream\\a.txt");
	
	int read = fis.read();
	//一次读取一个字节，返回值就是本次读到的那个字节数据
	//也就是字符在码表中对应的那个数字。
	//如果我们想要看到的是字符数据，那么一定要强转成char
	system.out.println((char)read);

	//释放资源
	fis.close();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

public class OutputDemo {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream( name:"bytestream\\a.txt");
        //1,文件中多个字节我怎么办?
        /*while(true){
            int i1 = fis.read();
            System.out.println(i1);
        }*/

        int b;
        while ((b = fis.read())!=-1){
            System.out.println((char) b);
        }

        fis.close();
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

public class OutputDemo {
	public static void main(String[] args)throws IOException{
		//创建了字节输入流，准备读数据。
		FileInputStream fis = new FileInputStream("C:\\it\\a.avi");
		//创建了字节输出流，准备写数据，
		FileOutputStream fos = new FileOutputStream("bytestream\\a.avi");
		
		int b;
		while((b = fis.read()) != -1){
			fos.write(b);
		}
		
		fis.close();
		fos.close();
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

public static void main(String[] args)throws IOException{
	FileInputStream fis = new FileInputStream("C:\\it\\a.avi");
	FileoutputStream fos = new FileoutputStream("bytestream\\a.avi");
	
	byte[] bytes = new byte[1024];
	int 1en;  //本次读到的有效字节个数 -- 这次读了几个字节
	
	while((len = fis.read(bytes)) != -1){
		fos.write(bytes, 0, len);
	}
	
	fis.close();
	fos.close();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

public static void main(String[] args)throws IOException{
	//利用缓冲流去拷贝文件
	
	//创建一个字节缓冲输入流
	BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bytestream\\a.avi"));
	//创建一个字节缓冲输出流
	BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bytestream\\copy.avi"));
	
	int b;
	while((b = bis.read()) != -1){
		bos.write(b);
	}

	bis.close();
	bos.close();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

public static void main(String[] args)throws IOException{
	//利用缓冲流去拷贝文件
	
	//创建一个字节缓冲输入流
	//在底层创建了一个默认长度为8192的字节数组
	BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bytestream\\a.avi"));
	//创建一个字节缓冲输出流
	//在底层创建了一个默认长度为8192的字节数组
	BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bytestream\\copy.avi"));
	
	int b;
	while((b = bis.read()) != -1){
		bos.write(b);
	}

	//方法的底层会把字节流给关闭
	bis.close();
	bos.close();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

public static void main(String[] args) throws IOException{
	//缓冲流结合数组，进行文件拷贝
	//创建一个字节缓冲输入流
	BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bytestream\\a.avi"));
	
	//创建一个字节缓冲输出流
	BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bytestream\\copy.avi"));
	
	byte[] bytes = new byte[1024];
	int len;
	while((len = bis.read(bytes)) != -1){
		bos.write(bytes, 0, len);
	}

	bis.close();
	bos.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

package other;

import java.io.ByteArrayInputStream;
import java.io.IOException;

public class MarkExample {

    public static void main(String[] args) {
        try {
            // 初始化一个字节数组，内有10个字节的数据
            byte[] bytes = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
            // 用一个ByteArrayInputStream来读取这个字节数组
            ByteArrayInputStream in = new ByteArrayInputStream(bytes);
            // 将ByteArrayInputStream包含在一个BufferedInputStream
            BufferedInputStream bis = new BufferedInputStream(in);
            // 读取字节1,2
            System.out.print(bis.read() + ",");
            System.out.print(bis.read() + ",");
            // 在此处做标记，同时设置readlimit参数为3
            System.out.println("mark");
            bis.mark(3);

            // 继续输出3，4，5，6值
            System.out.print(bis.read() + ",");
            System.out.print(bis.read() + ",");
            System.out.print(bis.read() + ",");
            System.out.print(bis.read() + ",");
            // 调用reset()方法
            System.out.println("reset");
            bis.reset();
            // 输出剩下的值
            System.out.println("");
            int c;
            while ( (c = bis.read()) != -1 ) {
                System.out.print(c + ",");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}