【javase高级-IO流复习】

• • 1.File
  • • 1.1常用方法
    • 1.2将文件夹下的所有文件打印输出
  • 2.I/O流
  • • 2.1原理
    • 2.2流的分类
    • 2.3流的体系结构划分
    • • 2.3.1节点流
      • • 对文件进行读取
        • 往文件中写入内容
        • 实现文本文件的复制
        • 实现图片、音频的复制
        • 节点流使用总结
      • 2.3.2处理流之缓冲流
      • • 缓冲流的作用
        • 缓冲流的使用
        • 缓冲流与普通流的效率比较

File 是文件或者文件夹

//创建文件类
		File  file = new File("C:\Users\Administrator\Desktop\aa");
		//判断文件是否可执行，可读，可写；返回值为Boolean值；
		System.out.println(file.canExecute()+"t"+
		file.canRead()+"t"+file.canWrite());
		//返回此路径名的绝对路径名形式。
		System.out.println(file.getAbsoluteFile());
		//返回此路径名的绝对路径名字符串。
		System.out.println(file.getAbsolutePath());
		//返回此路径名的路径名字符串；
		System.out.println(file.getPath());
		//返回此路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null。
		System.out.println(file.getParent());
		//返回此路径名父目录的路径名，如果不存在父目录，则返回null；
		System.out.println(file.getParentFile());

mkdir()创建指定目录
mkdirs() 创建指定目录，包含必须但不存在的父目录；
isDirectory() 判断是否是一个文件夹
exists()判断文件是否存在；
isFile()判断是否是一个文件；
length()返回该路径名所代表的文件的长度；
list() 返回一个字符串数组，这些字符串是此路径名表示的目录中的文件和目录的名字。
返回的是String的数组；
listFiles()；返回的是File数组；是此路径名表示的目录中的文件和文件夹；

public static void main(String[] args) {
		File file = new File("C:\Users\Administrator\Desktop");
		String[] list1 = file.list();
		for(String list:list1) {
			System.out.println(list);
		}
	}

File file = new File("C:\Users\Administrator\Desktop");
		File[] list2 = file.listFiles();
		for(File list:list2) {
			System.out.println(list);
		}

当所给路径不是文件夹，创建文件夹，若存在删除文件夹，

package com.openlab.pp;

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

public class TestFile {
	public static void main(String[] args) {
		File  file = new File("C:\Users\Administrator\Desktop\aa");
		if(!file.exists()) {
			//创建多级目录；
			file.mkdirs();
			
		}else{
			file.delete();//注意删除是不放回回收站的，所以要谨慎使用；
			System.out.println("删除成功");
		}
	}
}

判断所给是否为文件，若不是，判断父目录是否存在，不存在则创建，再创建文件，若是文件 则删除文件；

File  file = new File("C:\Users\Administrator\Desktop\aa\1.txt");
		
		if(!file.isFile()) {
			File parents = new File(file.getParent());
			if(!parents.exists()) {
				//如果父目录不存在，则创建目录；
				file.mkdirs();
				System.out.println("目录创建成功");
			}
			//接着创建文件
			
			if(!file.exists()) {
				try {
					file.createNewFile();
					System.out.println(file.getName()+"创建成功");
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}else {
			file.delete();
			System.out.println("删除成功");
			//注意删除是不放回回收站的，所以要谨慎使用；
		}

注意：要想删除父目录，如果目录下还有子目录或是子文件，时不能删除的，只有它是空的才能被删除掉；

public class TestFile {
	public static void main(String[] args) {
		String file = "C:\Users\Administrator\Desktop";
		copyFile(file);
	}
	public static void copyFile(String path) {
		File file = new File(path);
		File[] files = file.listFiles();//获取到所给路径下的文件和文件夹；
		for(File list : files) {
			if(list.isDirectory()) {//利用递归将文件夹下的子孙文件输出；
				copyFile(list.getAbsolutePath());
			}else{
				System.out.println(list.getName());
			}
		}
	}
}

I/O是input/output的缩写，I /O技术是用于处理设备之间的数据传输。例如读写文件，网络通讯等等。在Java程序中，对于数据的输入输出都是以流的方式进行操作的。Java.io包下提供了各种流的类与接口，可以获取不同种类的数据，通过标准的方法输入输出数据。
输入input：读取外部数据到内存中；
输出output：将程序（内存）中的数据输出到磁盘或光盘中。
根据不同的站位，流的方向有所不同，我们是站在程序的方向进行判断。

package com.openlab.pp;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

import org.junit.jupiter.api.Test;

public class TestRead {
	
	//@Test
	public  void read01() {
		File file = new File("E:\EclipseWorkSpace\zong\src\1.txt");//创建文件
		FileReader reader = null;
		try {//创建流
			reader = new FileReader(file);
			int data;//读取数据
			while((data = reader.read()) != -1) {
				System.out.print((char) data);
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			if(reader != null) {
				try {
					reader.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
	
	@Test
	public  void read02() {
		File file = new File("E:\EclipseWorkSpace\zong\src\1.txt");//创建文件
		FileReader reader = null;
		try {//创建流
			reader = new FileReader(file);
			char[] buf = new char[5];//读取数据
			int len;
			while((len = reader.read(buf)) != -1) {
//				//方式一：
//				//错误写法
//				for(int i = 0;i 
往文件中写入内容 
//@Test
	public void writer() {
		FileWriter writer = null;
		try {//file和流的创建；如果所给文件存在，它会创建一个文件；
			writer = new FileWriter("w.txt");
			writer.write("我是一个程序员");
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			if(writer != null) {
				try {
					writer.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
 
实现文本文件的复制 
方法一：使用FileReader和FileWriter
 
//@Test//实现文件的复制；
	public void testcopy1() {
		FileReader fr = null;
		FileWriter fw = null;
		try {
			fr = new FileReader("E:\\EclipseWorkSpace\\zong\\src\\1.txt");
			fw = new FileWriter("w.txt");
			int len;
			char[] buf = new char[5];
			while((len = fr.read(buf)) != -1) {
				fw.write(buf,0,len);
			}
			System.out.println("复制成功");
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			if(fw != null) {
				try {
					fw.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(fr != null) {
				try {
					fr.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
 
方法二：使用FileInputStream和FileOutputStream
 通过将文件设置为形参，可以实现指定文件的复制，这里有一个小点：使用字节流可以将文本文件复制到另一个文件中，那我们之前说使用字节，读取的有中文会乱码不就冲突了吗，这是因为我们将它在显示台输出的原因，你想它是读到几个输出几个，有的汉字读到一半自然会乱码；但我们进行复制完成后再在文件中查看的，所以没有出现乱码，在这个过程中，流充当的是搬运工的角色，并不会引起乱码。也就是字节流是万能流；
 
//实现指定文件的复制；
	@Test//实现文件的复制；
	public void testcopy1() {
			String src = "E:\EclipseWorkSpace\zong\src\1.txt";
			String dest = "w1.txt";
			testcopy(src,dest);
	}
	public static void testcopy(String srcfile,String destfile) {
		FileInputStream fis = null;
		FileOutputStream fos = null;
		File fileR = new File(srcfile);
		File fileW = new File(destfile);
		try {
			fis = new FileInputStream(fileR);
			fos = new FileOutputStream(fileW);
			int len;
			//获取到的是字节数组哦
			byte[] buf = new byte[5];
			while((len = fis.read(buf)) != -1) {
				fos.write(buf,0,len);
			}
			System.out.println("复制成功");
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			if(fos != null) {
				try {
					fos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(fis != null) {
				try {
					fis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
 
 
实现图片、音频的复制 
@Test //实现图片，音频的复制；所以使用的是字节流
	public void testcopy2() {
		FileInputStream fis = null;
		FileOutputStream fos = null;
		try {
			fis = new FileInputStream("D:\2345Downloads\安排.jpg");
			fos = new FileOutputStream("pp.jpg");
			int len;
			//获取到的是字节数组哦
			byte[] buf = new byte[5];
			while((len = fis.read(buf)) != -1) {
				fos.write(buf,0,len);
			}
			System.out.println("复制成功");
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			if(fos != null) {
				try {
					fos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(fis != null) {
				try {
					fis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
 
 
节点流使用总结 
1.对于文本文件，我们使用字符流进行处理，如（.txt,.java,.c,.cpp）等；
 2.对于非文本文件，我们使用字节流，如（.jpg,.mp3,.mp4,.avi,.doc,.ppt）等等；
 3.字节流是万能流，如果我们只是读取文件将文件内容写到某个文件中，并不会将其打印到控制台，对于文本文件我们也能用字节流；
 4.但是字符流时不能操作非文本文件的，即使你不在控制台输出也不行。
 
2.3.2处理流之缓冲流 
缓冲流的作用 
它就是为了提高读写的效率的，在没有缓冲下，它是读到多少输出多少；而有了缓冲以后，是将读到的数据放到缓冲区，等达到一定的容量，进行输出，提高了效率。
 
缓冲流的使用 
@Test
	public void test() {
		testBuffer("E:\EclipseWorkSpace\zong\src\1.txt","dd.txt");
	}
	public static void testBuffer(String srcFile,String destFile) {
		File fileR = new File(srcFile);
		File fileW = new File(destFile);
		FileInputStream fis = null;
		FileOutputStream fos = null;
		BufferedInputStream bis = null;
		BufferedOutputStream bos = null;
		try {
			fis = new FileInputStream(fileR);
			fos = new FileOutputStream(fileW);
			bis = new  BufferedInputStream(fis);
		    bos = new BufferedOutputStream(fos);
			int len;
			byte[] buf = new byte[5];
			while((len = bis.read(buf)) != -1) {
				bos.write(buf,0,len);
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			if(bos != null) {
				try {
					bos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(bis != null) {
				try {
					bis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
 
 
缓冲流与普通流的效率比较 
package com.openlab.pp;

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

import org.junit.jupiter.api.Test;

public class TestBuffer {
	
	@Test
	public void test() {
		long start = System.currentTimeMillis();
		testcopy("E:\EclipseWorkSpace\zong\src\小黑.mp3","w1.mp3");
		//testBuffer("E:\EclipseWorkSpace\zong\src\小黑.mp3","w2.mp3");
		long end = System.currentTimeMillis();
		System.out.println(end - start);
	}
	public static void testBuffer(String srcFile,String destFile) {
		File fileR = new File(srcFile);
		File fileW = new File(destFile);
		FileInputStream fis = null;
		FileOutputStream fos = null;
		BufferedInputStream bis = null;
		BufferedOutputStream bos = null;
		try {
			fis = new FileInputStream(fileR);
			fos = new FileOutputStream(fileW);
			bis = new  BufferedInputStream(fis);
		    bos = new BufferedOutputStream(fos);
			int len;
			byte[] buf = new byte[5];
			while((len = bis.read(buf)) != -1) {
				bos.write(buf,0,len);
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			if(bos != null) {
				try {
					bos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(bis != null) {
				try {
					bis.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
	
	//实现指定文件的复制；
		public static void testcopy(String srcfile,String destfile) {
			FileInputStream fis = null;
			FileOutputStream fos = null;
			File fileR = new File(srcfile);
			File fileW = new File(destfile);
			try {
				fis = new FileInputStream(fileR);
				fos = new FileOutputStream(fileW);
				int len;
				//获取到的是字节数组哦
				byte[] buf = new byte[5];
				while((len = fis.read(buf)) != -1) {
					fos.write(buf,0,len);
				}
				System.out.println("复制成功");
			} catch (FileNotFoundException e) {
				e.printStackTrace();
			} catch (IOException e) {
				e.printStackTrace();
			}finally {
				if(fos != null) {
					try {
						fos.close();
					} catch (IOException e) {
						e.printStackTrace();
					}
				}
				if(fis != null) {
					try {
						fis.close();
					} catch (IOException e) {
						e.printStackTrace();
					}
				}
			}
		}
}
 
普通流：
 缓冲流：
 
 可以看出缓冲流的效率比普通流高很多。