Day23

Day23

一,file类

1.1file类的初识

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

public class Test01 {
	/**
	 * 知识点：File类
	 * File，是文件和目录路径名的抽象表示
	 * File只关注文件本身的信息，而不能操作文件里面的内容
	 * 
	 * File类 -- 表示文件或文件夹，不能对文件里的数据进行操作
	 * 对文件里的数据进行操作的是：IO流
	 * 
	 * 需求1：通过程序，获取已知文件的以下信息
	 */
	public static void main(String[] args) {
		
		//创建File对象
		File file = new File("C:\\Users\\何小宝\\Desktop\\hhy.txt");
		
		System.out.println("获取文件名：" + file.getName());
		System.out.println("获取绝对路径：" + file.getAbsolutePath());
		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获取绝对路径与相对路径

import java.io.File;

public class Test02 {
	/**
	 * 知识点：相对路径 和 绝对路径
	 * 
	 * 绝对路径：在计算机内的具体路径（盘符:\文件夹\文件夹\...）
	 * 相对路径：相对于当前项目下的路径
	 */
	public static void main(String[] args) {
		
		//创建File对象
		File file = new File("hhy.txt");
		
		System.out.println("获取相对路径：" + file.getPath());
		System.out.println("获取绝对路径：" + file.getAbsolutePath());
		
	}
}

1.3创建文件

import java.io.File;
import java.io.IOException;

public class Test01 {
	/**
	 * 知识点：File类
	 * 
	 * 需求2:通过程序，判断指定路径的文件是否存在，如果不存在，则创建该文件
		下面按各种情况来解决该问题
			1)目录已存在的情况
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		
		File file = new File("file01\\hhy.txt");
		
		//文件不存在
		if(!file.exists()){
			//创建文件
			file.createNewFile();
		}
		
	}
}

1.4创建单级文件夹

import java.io.File;
import java.io.IOException;

public class Test02 {
	/**
	 * 知识点：File类
	 * 
	 * 需求2:通过程序，判断指定路径的文件是否存在，如果不存在，则创建该文件
		下面按各种情况来解决该问题
			1)目录已存在的情况
			2)有一个层级的目录不存在的情况
	 */
	public static void main(String[] args) throws IOException {
		
		//D:\2308workspace\Day23\file01\hhy.txt
		File file = new File("file01\\hhy.txt");
		
		//获取父路径 - D:\2308workspace\Day23\file01
		File parentFile = file.getParentFile();
		//判断目录路径是否存在
		if(!parentFile.exists()){
			//创建一层目录
			parentFile.mkdir();
		}
		
		//判断文件是否存在
		if(!file.exists()){
			//创建文件
			file.createNewFile();
		}
	}
}

1.5创建多级文件夹

import java.io.File;
import java.io.IOException;

public class Test03 {
	/**
	 * 知识点：File类
	 * 
	 * 需求2:通过程序，判断指定路径的文件是否存在，如果不存在，则创建该文件
		下面按各种情况来解决该问题
			1)目录已存在的情况
			2)有一个层级的目录不存在的情况
			3)有多个层级的目录不存在的情况
	 */
	public static void main(String[] args) throws IOException {
		
		//D:\2308workspace\Day23\file01\file02\file03\hhy.txt
		File file = new File("file01\\file02\\file03\\hhy.txt");
		
		//获取父路径 - D:\2308workspace\Day23\file01\file02\file03
		File parentFile = file.getParentFile();
		//判断目录路径是否存在
		if(!parentFile.exists()){
			//创建多层目录
			parentFile.mkdirs();
		}
		
		//判断文件是否存在
		if(!file.exists()){
			//创建文件
			file.createNewFile();
		}
		
	}
}

1.6输出指定文件夹下的所有信息

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

public class Test01 {
	/**
	 * 知识点：File类
	 * 
	 * 需求3:输出指定目录下的所有文件信息
	 */
	public static void main(String[] args) {
		
		File file = new File("D:\\2023");
		
		//获取当前目录下所有的文件名，并返回数组
//		String[] list = file.list();
//		for (String str : list) {
//			System.out.println(str);
//		}
		
		//获取当前目录下所有的文件对象，并返回数组
		File[] listFiles = file.listFiles();
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		for (File f : listFiles) {
			System.out.println(f.getName() + " -- " + sdf.format(f.lastModified()));
		}
	}
}

1.7输出指定文件夹下指定后缀的文件信息

import java.io.File;

public class Test02 {
	/**
	 * 知识点：File类
	 * 
	 * 需求3:输出指定目录下的所有文件信息
	 * 		1)要求只输出文件后缀名为txt的文件
	 */
	public static void main(String[] args) {
		
		File file = new File("D:\\2023");
		
		//获取当前目录下所有的文件对象，并返回数组
		File[] listFiles = file.listFiles();
		for (File f : listFiles) {
			String name = f.getName();
			
			//判断f是文件对象 并且 后缀以.txt结尾
			if (f.isFile() && name.endsWith(".txt")) {
				System.out.println(name);
			}
		}
		
	}
}

1.8输出指定文件夹下指定后缀的文件信息并过滤

import java.io.File;

public class Test04 {
	/**
	 * 知识点：File类
	 * 
	 * 需求3:输出指定目录下的所有文件信息
	 * 		1)要求只输出文件后缀名为txt的文件
	 * 		2)根据API的过滤器来完成该功能
	 * 		3)需求继续跟进，列出当前目录及子目录中符合该条件的文件信息（递归）
	 */
	public static void main(String[] args) {
		
		File file = new File("D:\\2023");
		
		search(file, ".jpg");
	}
	
	public static void search(File file,String suffix){
		
		File[] listFiles = file.listFiles();
		
		for (File f : listFiles) {
			if(f.isDirectory()){//文件夹
				search(f, suffix);
				
			}else if(f.isFile()){//文件
				String name = f.getName();
				if(name.endsWith(suffix)){
					System.out.println(name + " -- " + f.getAbsolutePath());
				}
			}
		}
	}
}

1.9列出当前目录下与子目录下所有符合条件的文件信息

import java.io.File;

public class Test04 {
	/**
	 * 知识点：File类
	 * 
	 * 需求3:输出指定目录下的所有文件信息
	 * 		1)要求只输出文件后缀名为txt的文件
	 * 		2)根据API的过滤器来完成该功能
	 * 		3)需求继续跟进，列出当前目录及子目录中符合该条件的文件信息（递归）
	 */
	public static void main(String[] args) {
		
		File file = new File("D:\\2023");
		
		search(file, ".jpg");
	}
	
	public static void search(File file,String suffix){
		
		File[] listFiles = file.listFiles();
		
		for (File f : listFiles) {
			if(f.isDirectory()){//文件夹
				search(f, suffix);
				
			}else if(f.isFile()){//文件
				String name = f.getName();
				if(name.endsWith(suffix)){
					System.out.println(name + " -- " + f.getAbsolutePath());
				}
			}
		}
	}
}

二,IO流

1,字节流

1.1文件字节输出流

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

public class Test01 {
	/**
	 * 知识点：利用文件字节输出流 向文件写入数据
	 * 
	 * 	1.文件存在的情况
	 */
	public static void main(String[] args) throws IOException {
		
		//1.创建流对象
		FileOutputStream fos = new FileOutputStream("io.txt");
		
		//2.写入数据
		//fos.write(97);//写入Unicode码
		//fos.write("123abcdef".getBytes());//写入字节数组
		fos.write("123abcdef".getBytes(), 3, 6);//写入字节数组,偏移量，写入长度
		
		//3.关闭资源
		fos.close();
	}
}

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

public class Test02 {
	/**
	 * 知识点：利用文件字节输出流 向文件写入数据
	 * 
	 * 	1.文件存在的情况
	 *  2.文件不存在的情况
	 *  	经验：所有的输出流，当文件不存在时会创建文件
	 */
	public static void main(String[] args) throws IOException {
		
		//1.创建流对象
		//FileOutputStream fos = new FileOutputStream("io.txt");
        //1.创建流对象(在末尾追加内容)
		FileOutputStream fos = new FileOutputStream("io.txt",true);
		//2.写入数据
		fos.write("123abcdef".getBytes());//写入字节数组
		
		//3.关闭资源
		fos.close();	
	}
}

1.2文件字节输出流–处理异常

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

public class Test04 {
	/**
	 * 知识点：利用文件字节输出流 向文件写入数据
	 * 
	 * 	1.文件存在的情况
	 *  2.文件不存在的情况
	 *  	经验：所有的输出流，当文件不存在时会创建文件
	 *  3.在文件末尾追加
	 *  	经验：考虑基础流的构造方法
	 *  4.处理异常
	 */
	public static void main(String[] args) {
		
		
		FileOutputStream fos = null;
		try {
			//1.创建流对象(在末尾追加内容)
			fos = new FileOutputStream("io.txt",true);
			
			//2.写入数据
			fos.write("123abcdef".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.3文件字节输入流

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

public class Test05 {
	/**
	 * 知识点：利用文件字节输入流 读取文件里的内容
	 * 
	 * 1.文件存在的情况
	 */
	public static void main(String[] args) throws IOException {
		
		//1.创建流对象
		FileInputStream fis = new FileInputStream("io.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((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);
		
		//3.关闭资源
		fis.close();	
	}
}

//循环读取
import java.io.FileInputStream;
import java.io.IOException;

public class Test06 {
	/**
	 * 知识点：利用文件字节输入流 读取文件里的内容
	 * 
	 * 1.文件存在的情况
	 */
	public static void main(String[] args) throws IOException {
		
		//1.创建流对象
		FileInputStream fis = new FileInputStream("io.txt");
		
		//2.读取数据 - 一个字节一个字节的循环读取
		int read;
		while((read = fis.read()) != -1){
			System.out.println((char)read);
		}
		
		//3.关闭资源
		fis.close();
		
	}
}

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

public class Test07 {
	/**
	 * 知识点：利用文件字节输入流 读取文件里的内容
	 * 
	 * 1.文件存在的情况
	 */
	public static void main(String[] args) throws IOException {
		
		//1.创建流对象
		FileInputStream fis = new FileInputStream("io.txt");
		
		//2.读取数据 - 1024个字节1024个字节的循环读取
		//read(bs)：每次读取bs长度的数据并把数据存入bs数组中，返回读取到的有效字节数，如果读取到文件末尾则返回-1
		byte[] bs = new byte[1024];//[49,50,51,97,98,99,0,0,0,0,0,0,0]
		int len;
		while((len = fis.read(bs)) != -1){
			
			System.out.println(new String(bs, 0, len));
		}
		
		//3.关闭资源
		fis.close();	
	}
}

1.4文件字节输入流–处理异常

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

public class Test08 {
	/**
	 * 知识点：利用文件字节输入流 读取文件里的内容
	 * 
	 * 1.文件存在的情况
	 * 2.文件不存在的情况
	 * 		经验：所有的输入流，当文件不存在时都会报错 -- FileNotFoundException
	 * 3.处理异常
	 */
	public static void main(String[] args){
		
		
		FileInputStream fis = null;
		try {
			//1.创建流对象
			fis = new FileInputStream("io.txt");
			
			//2.读取数据
			byte[] bs = new byte[1024];
			int len;
			while((len = fis.read(bs)) != -1){
				
				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.5拷贝文件

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) {
		
		
		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 (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} 	
	}
}

1.6带缓冲区的字节输出流与输出流—拷贝文件

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

public class Test01 {
	/**
	 * 知识点：利用带缓冲区的字节输出流向文件写入数据
	 */
	public static void main(String[] args) throws IOException {
		
		//1.创建流对象 -- 默认缓冲区大小8192
		//BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("io.txt"));
		
		//1.创建流对象 -- 自定义缓冲区大小1024*1024*5
		//BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("io.txt"), 1024*1024*5);
		
		//1.创建流对象 (在末尾追加)
		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("io.txt",true));
		
		//2.写入数据 -- 将数据写入到缓冲区数组里
		bos.write("123abcdef".getBytes());
		
		//3.关闭资源
		bos.close();
	}
}

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

public class Test02 {
	/**
	 * 知识点：利用带缓冲区的字节输入流 读取文件里的数据
	 */
	public static void main(String[] args) throws IOException {
		
		//1.创建流对象 -- 默认缓冲区大小8192
		//BufferedInputStream bis = new BufferedInputStream(new FileInputStream("io.txt"));
		
		//1.创建流对象 -- 自定义缓冲区大小2048
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream("io.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();
	}
}

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

public class Copy {
	/**
	 * 知识点：拷贝文件
	 * 
	 * 思路：读取源文件，写入到目标文件
	 */
	public static void main(String[] args) {
		
		
		BufferedInputStream bis = null;
		BufferedOutputStream bos = null;
		
		try {
			bis = new BufferedInputStream(new FileInputStream("水野朝阳.mp4"));
			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);
			}
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if(bis != null){
				try {
					bis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(bos != null){
				try {
					bos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

2,字符流

2.1字符输出转换流,字符输入转换流,拷贝文件

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

public class Test01 {
	/**
	 * 知识点：利用字符输出转换流 向文件写入数据
	 */
	public static void main(String[] args) throws IOException {
		
		//1.创建流对象（使用默认的编码格式）
		//OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("io.txt"));
		
		//1.创建流对象（使用自定义的编码格式）-- 推荐
		//OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("io.txt"),"GBK");
		
		//1.创建流对象（使用自定义的编码格式）+ 文件末尾追加 -- 推荐
		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("io.txt",true),"GBK");
		
		//2.写入数据
		//osw.write(97);//写入Unicode码
		
		//char[] cs = {'1','2','3','a','b','c','木','头','人'};
		//osw.write(cs);//写入字符数组
		//osw.write(cs, 3, 6);//写入字符数组，偏移量，写入长度
		
		//osw.write("123abc木头人");//写入字符串
		osw.write("123abc木头人", 3, 6);//写入字符串，偏移量，写入长度
		
		//3.关闭资源
		osw.close();
	}
}

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

public class Test03 {
	/**
	 * 知识点：利用字符输入转换流 读取文件里的数据
	 */
	public static void main(String[] args) throws IOException {
		
		//1.创建流对象(使用自定义的编码格式) -- 推荐
		InputStreamReader isr = new InputStreamReader(new FileInputStream("io.txt"),"GBK");
		
		//2.读取数据
		char[] cs = new char[1024];
		int len;
		while((len = isr.read(cs)) != -1){
			System.out.println(new String(cs,0,len));
		}
		
		//3.关闭资源
		isr.close();
	}
}

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;

public class Copy {
	/**
	 * 知识点：拷贝文件
	 */
	public static void main(String[] args) throws UnsupportedEncodingException, IOException {
		
		InputStreamReader isr = new InputStreamReader(new FileInputStream("小说.txt"), "GBK");
		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("copy.txt"), "GBK");
		
		char[] cs = new char[1024];
		int len;
		while((len = isr.read(cs)) != -1){
			osw.write(cs, 0, len);
		}
		
		isr.close();
		osw.close();
	}
}

2.2文件字符输出流,文件字符输入流,拷贝文件

import java.io.FileWriter;
import java.io.IOException;

public class Test01 {
	/**
	 * 知识点：利用文件字符输出流 向文件写入数据
	 */
	public static void main(String[] args) throws IOException {
		
		//1.创建流对象
		//FileWriter fw = new FileWriter("io.txt");
		
		//1.创建流对象 + 在文件末尾追加
		FileWriter fw = new FileWriter("io.txt",true);
		
		//2.写入数据
		fw.write("123abc木头人");//写入字符串
		
		//3.关闭资源
		fw.close();
	}
}

import java.io.FileReader;
import java.io.IOException;

public class Test02 {
	/**
	 * 知识点：利用文件字符输入流 读取文件里的数据
	 */
	public static void main(String[] args) throws IOException {
		
		//1.创建流对象
		FileReader fr = new FileReader("io.txt");
		
		//2.读取数据
		char[] cs = new char[1024];
		int len;
		while((len = fr.read(cs)) != -1){
			System.out.println(new String(cs, 0, len));
		}
		
		//3.关闭资源
		fr.close();
	}
}

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.UnsupportedEncodingException;

public class Copy {
	/**
	 * 知识点：拷贝文件
	 */
	public static void main(String[] args) throws UnsupportedEncodingException, IOException {
		
		FileReader fr = new FileReader("小说.txt");
		FileWriter fw = new FileWriter("copy.txt");
		
		char[] cs = new char[1024];
		int len;
		while((len = fr.read(cs)) != -1){
			fw.write(cs, 0, len);
		}
		
		fr.close();
		fw.close();
		
	}
}

2.3带缓冲区字符输出流,带缓冲区字符输入流,拷贝文件

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class Test01 {
	/**
	 * 知识点：利用带缓冲区字符输出流 向文件写入数据
	 */
	public static void main(String[] args) throws IOException {
		
		//1.创建流对象(FileOutputStream -> OutputStreamWriter -> BufferedWriter)
		//BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("io.txt"), "GBK"));
		
		//1.创建流对象(FileWriter -> BufferedWriter)
		BufferedWriter bw = new BufferedWriter(new FileWriter("io.txt",true));
		
		//2.写入数据
		bw.write("123abc木头人");//写入字符串
		
		//3.关闭资源
		bw.close();
	}
}

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class Test02 {
	/**
	 * 知识点：利用带缓冲区字符输出流 读取文件里的数据
	 */
	public static void main(String[] args) throws IOException {
		
		//1.创建流对象(FileInputStream -> InputStreamReader -> BufferedReader)
		BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("io.txt"), "GBK"));
		
		//2.读取数据
		char[] cs = new char[1024];
		int len;
		while((len = br.read(cs)) != -1){
			System.out.println(new String(cs, 0, len));
		}
		
		//3.关闭资源
		br.close();
	}
}

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.UnsupportedEncodingException;

public class Copy01 {
	/**
	 * 知识点：拷贝文件
	 */
	public static void main(String[] args) throws UnsupportedEncodingException, IOException {
		
		BufferedReader br = new BufferedReader(new FileReader("小说.txt"));
		BufferedWriter bw = new BufferedWriter(new FileWriter("copy.txt"));
		
		char[] cs = new char[1024];
		int len;
		while((len = br.read(cs)) != -1){
			bw.write(cs, 0, len);
		}
		
		br.close();
		bw.close();
		
	}
}

//逐行拷贝
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.UnsupportedEncodingException;

public class Copy02 {
	/**
	 * 知识点：拷贝文件
	 */
	public static void main(String[] args) throws UnsupportedEncodingException, IOException {
		
		BufferedReader br = new BufferedReader(new FileReader("小说.txt"));
		BufferedWriter bw = new BufferedWriter(new FileWriter("copy.txt"));
		
		String readLine;
		while((readLine = br.readLine()) != null){
			bw.write(readLine);
			bw.newLine();//换行
		}
		
		br.close();
		bw.close();
	}
}