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

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