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

刺骨的言语ヽ痛彻心扉 2024-04-20 11:19 72阅读 0赞

## 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);
    	}
    }

#### 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());
    	}
    }

#### 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();
    		}
    	}
    }

##### 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();
    		}
    	}
    }

##### 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();
    		}
    	}
    }

#### 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.要求只输出文件后缀名为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);
    			}
    		}
    	}
    }

##### 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());
    		}
    	}
    }

##### 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());
    				}
    			}
    		}
    		
    	}
    }

### 二、IO流 ###

#### 1.理解： ####

> I - in - 输入流  
> O - out- 输出流  
> 流 - 像水流一样传输数据  
> 注意：站在程序的角度去理解输入输出
> 
> 应用场景：通过程序处理文件里的内容

#### 2.分流： ####

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

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

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

#### 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();
    	}
    }

#### 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();
    	}
    }

#### 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.文件存在的情况下，并且一个字节一个字节的读取 ####

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();
    	}
    }

#### 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();
    	}
    }

#### 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();
    	}
    }

#### 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();
    				}
    			}
    		}
    	}
    }

#### 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();
    	}
    }

#### 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();
    					}
    				}
    				
    			}
    		}
    
    	}
    }

##### 方案二 #####

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();
    	}
    }

##### 方案三 #####

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.文件不存在的情况下 ####

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

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();
    	}
    	
    }

#### 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();
    				}
    			}
    		}
    	
    	}
    }

#### 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.带有缓冲区的字节输入流使用 ####

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();
    		
    	}
    }

#### 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();
    	}
    }

### 七、字节流总结 ###

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

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字节