• File类和IO流的字节流（1）

    File类和IO流的字节流（1）

    一、File类

    1.File，是文件和目录路径名的抽象表示

    2.File只关注文件本身的信息(文件名、可读、可写)，而不能操作文件里面的内容

    3.File类 – 表示文件或文件夹，不能对文件里的数据进行操作

    4.对文件里的数据进行操作的是：IO流

    1.File类的常用方法

    import java.io.File;
import java.text.SimpleDateFormat;

public class Test01 {

	public static void main(String[] args) {
		
		//创建File对象
		File file = new File("D:\\图库\\海底世界.jpg");
		
		System.out.println("获取文件名：" + file.getName());
		System.out.println("获取文件大小(字节)：" + file.length());
		System.out.println("获取是否可读：" + file.canRead());
		System.out.println("获取是否可写：" + file.canWrite());
		System.out.println("获取是否隐藏：" + file.isHidden());
		
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy--MM--dd HH--mm--ss");
		String dateTime = sdf.format(file.lastModified());
		System.out.println("获取最后的修改时间：" + dateTime);
	}
}

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

    2.研究绝对路径和相对路径

    绝对路径：指定了盘符的具体路径

    相对路径：相对于此项目下的路径

    import java.io.File;

public class Test02 {

	public static void main(String[] args) {
		//创建File对象
		File file = new File("IO笔记.txt");
		//相对路径：IO笔记.txt
		System.out.println("相对路径：" + file.getPath());
		//绝对路径： F:\2211workspace\MyDay22\IO笔记.txt
		System.out.println("绝对路径： " + file.getAbsolutePath());
	}
}


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

    3.通过程序，判断指定路径的文件是否存在，如果不存在，则创建该文件下面按各种情况来解决该问题

    1.目录已存在的情况
    import java.io.File;
import java.io.IOException;

public class Test01 {

	public static void main(String[] args) throws IOException {
		
		File file = new File("file01\\gl.txt");
		
		if (!file.exists()) {//判断文件是否存在
			//创建文件
			file.createNewFile();
		}
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    2.有一个层级的目录不存在的情况
    import java.io.File;
import java.io.IOException;

public class Test02 {

	public static void main(String[] args) throws IOException {
		
		File file = new File("file\\gl.txt");
		//file01
		File parentFile = file.getParentFile();
		
		if (!parentFile.exists()) {//判断文件夹是否存在
			//创建一层文件夹
			parentFile.mkdir();
		}
		
		if (!file.exists()) {//判断文件是否存在
			//创建文件
			file.createNewFile();
		}
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    3.有多个层级的目录不存在的情况
    import java.io.File;
import java.io.IOException;
public class Test03 {

	public static void main(String[] args) throws IOException {
		
		File file = new File("file01\\file02\\file03\\gl.txt");
		//file01\\file02\\file03
		File parentFile = file.getParentFile();
		
		if (!parentFile.exists()) {//判断文件夹是否存在
			//创建多层文件夹
			parentFile.mkdirs();
		}
		
		if (!file.exists()) {//判断文件是否存在
			//创建文件
			file.createNewFile();
		}
	}
}


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

    4.输出指定目录下的所有文件信息（只考虑当前目录，不考虑子目录）

    import java.io.File;

public class Test01 {

	public static void main(String[] args) {
		
		File file = new File("F:\\2211workspace");
		
		//解决方案1：
		//获取到该文件夹下所有的文件名
		//String[] list = file.list();
		//for (String str : list) {
		//	System.out.println(str);
		//}
		
		//解决方案2：
		//获取到该文件夹下所有的File对象
		File[] listFiles = file.listFiles();
		for (File f : listFiles) {
			System.out.println(f.getName() + "---" + f.canRead());
		}
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    1.要求只输出文件后缀名为java的文件
    import java.io.File;

public class Test02 {

	public static void main(String[] args) {
		
		File file = new File("F:\\2211workspace\\MyDay06");
		
		//解决方案1：
		//获取到该文件夹下所有的文件名
	//	String[] list = file.list();
	//	for (String str : list) {
	//		if (str.endsWith(".class")) {
	//			System.out.println(str);
	//		}
	//	}
		
		//解决方案2：
		//获取到该文件夹下所有的File对象
		File[] listFiles = file.listFiles();
		for (File f : listFiles) {
			String name = f.getName();
			if (f.isFile() && name.endsWith(".java")) {
				System.out.println(name);
			}
		}
	}
}

    • 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
    2.根据API的过滤器来完成该功能
    import java.io.File;
import java.io.FilenameFilter;

public class Test03 {

	public static void main(String[] args) {
		
		File file = new File("F:\\2211workspace\\MyDay06");
		
		File[] listFiles = file.listFiles(new FilenameFilter() {
			
			@Override
			public boolean accept(File dir, String name) {
				
				//dir -- new File("C:\\飞秋共享");
				//name -- 遍历的文件名
				
				//创建File对象 -- C:\\飞秋共享\\遍历的文件名
				
				File f = new File(dir, name);
				
				if (f.isFile() &&  name.endsWith(".java")) {
					return true;
				}
				return false;
			}
		});
		
		for (File f : listFiles) {
			System.out.println(f.getName());
		}
	}
}

    • 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
    3.需求继续跟进，列出当前目录及子目录中jpg的文件信息（递归）
    import java.io.File;
public class Test04 {

	public static void main(String[] args) {
		
		File file = new File("D:\\图库");
		
		scannerFile(file,".jpg");
	}
	
	public static void scannerFile(File file, String suffix) {

		File[] listFiles = file.listFiles();
		
		for (File f : listFiles) {
			if (f.isDirectory()) {//文件夹
				scannerFile(f, suffix);
			}else if (f.isFile()) {//文件
				String name = f.getName();
				if (name.endsWith(suffix)) {
					System.out.println(name + "--" + f.getAbsolutePath());
				}
			}
		}
		
	}
}



    • 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

    二、IO流

    1.理解：

    I - in - 输入流
    O - out- 输出流
    流 - 像水流一样传输数据
    注意：站在程序的角度去理解输入输出

    应用场景：通过程序处理文件里的内容

    2.分流：

    ​ 按照方向分：输入流、输出流
    ​ 按照单位分：字节流、字符流
    ​ 按照功能分：基础流/节点流、处理流
    ​ 注意：处理流往往包含了基础流，让流的功能更加强大

    计算机存储单位：
1024B  = 1Kb
1024kb = 1KB
1024Mb = 1Gb
1024Gb = 1Tb
1024Tb = 1Pb

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    三、利用文件字节输出流 向文件写入数据

    1.文件存在的情况下

    import java.io.FileOutputStream;
import java.io.IOException;

public class Test01 {

	public static void main(String[] args) throws IOException {
		//1.创建流对象
		FileOutputStream fos = new FileOutputStream("ggc.txt");
		
		//2.写入数据
		//fos.write(97);
		//fos.write("abcdef".getBytes());//写入字节数组
		  fos.write("abcdef".getBytes(), 1,3);//写入字节数组、偏移量、长度
		
		//3.关闭资源
		fos.close();
	}
}


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

    2.文件不存在的情况下

    经验：所有的输出流，当文件不存在时都会创建文件

    3.在末尾追加内容

    import java.io.FileOutputStream;
import java.io.IOException;

public class Test02 {

	public static void main(String[] args) throws IOException {
		
		//1.创建流对象+ 在末尾追加内容
		FileOutputStream fos = new FileOutputStream("ggc.txt",true);
		
		//2.写入数据
		fos.write("abcdefgh".getBytes());//写入字节数组
		
		//3.关闭资源
		fos.close();
	}
}


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

    4.积极处理异常

    import java.io.FileNotFoundException;
/**
 * 知识点：利用文件字节输出流 向文件写入数据
 * 
 * 需求：利用文件字节输出流 向文件写入数据
 * 		1）文件存在的情况下
 * 		2）文件不存在的情况下
 * 			经验：所有的输出流，当文件不存在时都会创建文件
 * 		3）在末尾追加内容
 */
import java.io.FileOutputStream;
import java.io.IOException;

public class Test03 {

	public static void main(String[] args)  {
		
		//1.创建流对象+ 在末尾追加内容
		FileOutputStream fos = null;
		try {
			//1.创建流对象+ 在末尾追加内容
			fos = new FileOutputStream("ggc.txt",true);
			//2.写入数据
			fos.write("abcdefgh".getBytes());//写入字节数组
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			//3.关闭资源
			if (fos != null) {
			
			try {
				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
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44

    四、利用文件字节输入流 读取文件里的数据

    1.文件存在的情况下，并且一个字节一个字节的读取

    import java.io.FileInputStream;
import java.io.IOException;

public class Test04 {

	public static void main(String[] args) throws IOException {
		//1.创建流对象
		FileInputStream fis = new FileInputStream("ggc.txt");
		
		//2.读取数据
		//read() -- 读取一个字节，如果读取到文件末尾则返回-1
		int read = fis.read();
		System.out.println((char)read);
		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();
	}
}


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

    2.一个字节一个字节循环读取

    import java.io.FileInputStream;
import java.io.IOException;

public class Test05 {

	public static void main(String[] args) throws  IOException{
	//1.创建流对象
	FileInputStream fis = new FileInputStream("ggc.txt");
	//2.读取数据
	//read() -- 读取一个字节，如果读取到文件末尾则返回-1
	int read;
	while ((read = fis.read()) != -1) {
		System.out.println((char)read);
	}
	//3.关闭资源
	fis.close();
	}
}


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

    3.文件不存在的情况下

    经验：所有的输入流，当文件不存在都会报FileNotFoundException(文件文找到异常)

    4.指定字节数组的循环读取

    import java.io.FileInputStream;
import java.io.IOException;

public class Test06 {

	public static void main(String[] args) throws IOException {
		//1.创建流对象
		FileInputStream fis = new FileInputStream("ggc.txt");
		
		//2.读取数据
		//read(bs) -- 读取bs数组长度的数据，将数据存入到bs中并返回有效字节数，如果读取到文件末尾则返回-1
		byte[] bs = new byte[1024];
		int len;
		while ((len = fis.read(bs)) != -1) {
			//将bs字节数组转换为字符串，从第0个下标开始转换len个长度的字节数据
			System.out.println(new String(bs,0,len));
		}
		//3.关闭资源
		fis.close();
	}
}


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

    5.积极处理异常

    import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class Test07 {

	public static void main(String[] args)  {
		
		FileInputStream fis = null; 
	    try {
	    	//1.创建流对象
			fis = new FileInputStream("ggc.txt");
			//2.读取数据
			//read(bs) -- 读取bs数组长度的数据，将数据存入到bs中并返回有效字节数，如果读取到文件末尾则返回-1
			byte[] bs = new byte[1024];
			int len;
			while ((len = fis.read(bs)) != -1) {
				//将bs字节数组转换为字符串，从第0个下标开始转换len个长度的字节数据
				System.out.println(new String(bs,0,len));
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			//3.关闭资源
			if(fis != null){
				try {
					fis.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
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37

    6.拷贝文本文件

    思路：读取源文件，写入目标文件

    import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Copy01 {

	public static void main(String[] args) throws IOException {
		
		FileInputStream fis = new FileInputStream("IO笔记.txt");
		FileOutputStream fos = new FileOutputStream("copy.txt");
		
		int read;
		while ((read = fis.read()) != -1) {
			fos.write(read);
		}
		
		fis.close();
		fos.close();
	}
}


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

    7.拷贝视频文件

    读取源文件，写入目标文件

    方案一
    import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Copy02 {

	public static void main(String[] args){
		
		FileInputStream fis = null;
		FileOutputStream fos = null;
		try {
			fis = new FileInputStream("测试视频.mp4");
			fos = new FileOutputStream("copy.mp4");
			
			byte[] bs = new byte[2048];
			int len;
			while ((len = fis.read(bs)) != -1) {
				fos.write(bs,0,len);
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			if (fis != null) {
				try {
					fis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
				if (fos != null) {
					try {
						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
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    方案二
    import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Copy03 {

	public static void main(String[] args) throws IOException {
		
		FileInputStream fis = new FileInputStream("测试视频.mp4");
		FileOutputStream fos = new FileOutputStream("copy.mp4");
		
		byte[] bs = new byte[2048];
		int len;
		while ((len = fis.read(bs)) != -1) {
			fos.write(bs,0,len);
		}
		
		fis.close();
		fos.close();
	}
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    方案三
    import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Copy04 {

	public static void main(String[] args){
		
		try (FileInputStream fis = new FileInputStream("测试视频.mp4");
			FileOutputStream fos = new FileOutputStream("copy.mp4");){
			
			byte[] bs = new byte[1024];
			int len;
			while((len = fis.read(bs)) != -1){
				fos.write(bs, 0, len);
			}
			
		} 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
    • 23

    五、利用带有缓冲区的字节输出流 向文件写入数据

    1.文件存在的情况下

    2.文件不存在的情况下

    经验：所有的输出流，当文件不存在时都会创建文件

    import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Test01 {

	public static void main(String[] args) throws IOException {
		
		//1.创建流的对象
		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("ggc.txt"));
		
		//2.写入数据
		bos.write("abcdefgh".getBytes());
		
		//3.关闭资源
		bos.close();
	}
	
}


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

    3.在末尾追加内容

    经验：考虑基础流的构造方法

    4.积极处理异常

    import java.io.BufferedOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Test02 {

	public static void main(String[] args){
		
		BufferedOutputStream bos = null;
		try {
			//1.创建流的对象
			bos = new BufferedOutputStream(new FileOutputStream("ggc.txt"));
			//2.写入数据
			bos.write("abcdefgh".getBytes());
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			//3.关闭资源
			if (bos != null) {
			
				try {
					bos.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
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34

    5.研究带有缓冲区的字节输出流为什么效率高？

    效率高：减少了程序与硬盘交互的次数

    import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Test03 {

	public static void main(String[] args) throws  IOException{
		
		//fos与文件交互了3次
		FileOutputStream fos = new FileOutputStream("ggc.txt");
		fos.write("abc".getBytes());//写入文件
		fos.write("def".getBytes());//写入文件
		fos.write("ghi".getBytes());//写入文件
		fos.close();
		
		//bos与文件交互了1次
		
				//创建带有缓冲区的字节输出流 --- 默认缓冲区为：byte[] buf = new byte[8192];
//		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("ggc.txt"));		bos.write("abc".getBytes());//写入缓冲区
//		bos.write("def".getBytes());//写入缓冲区
//		bos.write("ghi".getBytes());//写入缓冲区
//		bos.flush();//将数组中的数据全部刷新到文件中（就算不刷新，关闭流的时候也刷新了）
//		bos.close();//将数组中的数据全部写入文件中
		
		//创建带有缓冲区的字节输出流 --- 自定义缓冲区为：byte[] buf = new byte[2048];
		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("ggc.txt"),2048);
		bos.write("zxc".getBytes());//写入缓冲区
		bos.write("sdf".getBytes());//写入缓冲区
		bos.write("ryy".getBytes());//写入缓冲区
		bos.flush();//将数组中的数据全部刷新到文件中（就算不刷新，关闭流的时候也刷新了）
		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

    六、利用带有缓冲区的字节输入流 读取文件中的数据

    1.带有缓冲区的字节输入流使用

    import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class Test04 {

	public static void main(String[] args) throws IOException {
		
		
		//1.创建流对象 -- 默认缓冲区：byte[] buf = new byte[8192];
//		BufferedInputStream bis = new BufferedInputStream(new FileInputStream("hhy.txt"));
		
		//1.创建流对象 -- 自定义缓冲区：byte[] buf = new byte[2048];
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream("ggc.txt"),2048);
		//2.读取数据
		byte[] bs = new byte[1024];
		int len;
		while ((len = bis.read(bs)) != -1) {
			System.out.println(new String(bs, 0, len));
		}
		//3.关闭资源
		bis.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

    2.拷贝视频文件

    import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Copy {

	public static void main(String[] args) throws IOException {
		
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream("测试视频.mp4"));
		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.mp4"));
		
		byte[] bs = new byte[1024];
		int len;
		while ((len = bis.read(bs)) != -1) {
			bos.write(bs, 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

    七、字节流总结

    应用场景：处理二进制文件（图片、音频、视频）

    abstract class InputStream --- 字节输入流的基类（抽象类）
abstract class OutputStream -- 字节输出流的基类（抽象类）

class FileInputStream extends InputStream --- 文件字节输入流
class FileOutputStream extends OutputStream - 文件字节输出流

class FilterInputStream extends InputStream --- 过滤器字节输入流
class FilterOutputStream extends OutputStream - 过滤器字节输出流

class BufferedInputStream extends FilterInputStream --- 带有缓冲区的字节输入流
class BufferedOutputStream extends FilterOutputStream - 带有缓冲区的字节输出流
缓冲区大小为：8192字节

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
  • 相关阅读:
    部署MongoDB复制集群（最全）
    第3章业务功能开发(用户登录)
    【王道】计算机网络应用层(五)
    Pybind11和CMake构建python扩展模块环境搭建
    微软Edge浏览器与WebRTC：实现下一代网络通信
    【JS】Chapter13-构造函数&数据常用函数
    Whisper + NemoASR + ChatGPT 实现语言转文字、说话人识别、内容总结等功能
    Win11的两个实用技巧系列之电脑死机解决办法
    hutool工具导出excel代码示例
    Linux 安装 ElasticSearch
  • 原文地址：https://blog.csdn.net/GL280599ZL/article/details/127624974