黑马程序员——java基础——IO的学习总结

Java IO流详解与实战

最新推荐文章于 2024-05-24 15:38:56 发布

原创最新推荐文章于 2024-05-24 15:38:56 发布 · 785 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#黑马程序员 #java基础 #io流 #复制文件 #复制多级目录

Java基础学习专栏收录该内容

13 篇文章

订阅专栏

本文深入探讨Java IO流体系，包括字节流与字符流的抽象基类及其实现方式，并通过具体案例演示文件复制、目录复制及文件批量重命名等实用技巧。

android培训、java培训期待与您交流！

一、IO流体系图：

二、字节流的抽象基类：

InputStream ，OutputStream

三、字符流的抽象基类：

Reader , Writer

由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。

如：InputStream的子类FileInputStream。

如：Reader的子类FileReader。

InputStreamReader是Reader的子类

四、注意事项
1、文件路径
定义文件路径时Windows中的目录符号为“\”，但这个符号在Java中是特殊字符，需要转义。
可以用“\\”或“/”表示。
2、读取文件
读取文件时必须保证文件存在，否则将抛出FileNotFoundException。
3、写出文件
写出时文件如不存在时程序会创建新文件，如文件已存在则会清空原文件内容重新写入。
如需追加内容可调用FileWriter构造函数FileWriter(String fileName, boolean append)

五、练习

1、复制文本文件的九种方法

package IO;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class copyFileDemo {
	public static void main(String[] args) throws IOException {
		String srcString ="C:\\Demo6.java";
		String destString="D:\\copyDemo.java";
		//method1(srcString,destString);
		//method2(srcString,destString);
		//method3(srcString,destString);
		//method4(srcString,destString);
		//method5(srcString,destString);
		
		//method6(srcString,destString);
		//method7(srcString,destString);
		method8(srcString,destString);
		/*method9(srcString,destString);*/
	}
	


	//字节流每次读取和输出一个字节
	public static void method1(String srcString,String destString) throws IOException{
		//建立字节流输入对象
		FileInputStream inFile=new FileInputStream(srcString);
		//建立字节流输出对象
		FileOutputStream outFile=new FileOutputStream(destString);
		int length=0;
		//读取和写出数据
		while((length=inFile.read())!=-1)
		{
			outFile.write(length);
		}
		//释放资源
		outFile.close();
		inFile.close();
	}
	
	//字节流每次读取一个字节数组，字节流每次输出一个字节数组的一部分
	private static void method2(String srcString, String destString) throws IOException{
		//建立字节流输入对象
		FileInputStream inFile=new FileInputStream(srcString);
		//建立字节流输出对象
		FileOutputStream outFile=new FileOutputStream(destString);
		byte [] buf=new byte[1024];
		int length=0;
		while((length=inFile.read(buf))!=-1){
			outFile.write(buf, 0, length);
			outFile.flush();
		}
		outFile.close();
		inFile.close();
	}
	
	//字节缓冲区每次读写一个字节
	public static void method3(String srcString, String destString) throws IOException {
		//建立字节输入缓冲流对象
		BufferedInputStream buffereIn=new BufferedInputStream(new FileInputStream(srcString));
		//建立字节输出缓冲流对象
		BufferedOutputStream buffereOut=new BufferedOutputStream(new FileOutputStream(destString));
		
		int length=0;
		while((length=buffereIn.read())!=-1){
			buffereOut.write(length);
		}
		//释放资源
		buffereOut.close();
		buffereIn.close();
	}
	
	//建立字节输入缓冲流对象每次读取一个字节数组，建立字节输出流每次写出一个字节数组的一部分
	public  static void method4(String srcString, String destString) throws IOException{
		//建立字节输入缓冲流对象
		BufferedInputStream bufferedIn=new BufferedInputStream(new FileInputStream(srcString));
		//建立字节输出缓冲流对象
		BufferedOutputStream bufferedOut=new BufferedOutputStream(new FileOutputStream(destString));
		
		byte[] buf=new byte[1024];
		int length=0;
		while((length=bufferedIn.read(buf))!=-1){
			bufferedOut.write(buf,0,length);
			bufferedOut.flush();
		}
		//释放资源
		bufferedOut.close();
		bufferedIn.close();
	}
	
	//字符流每次读取一个字符
	public static void method5(String srcString, String destString) throws IOException {
		//建立输入字符流对象
		FileReader inFile=new FileReader(srcString);
		//建立输出字符流对象
		FileWriter outFile=new FileWriter(destString);
		int length=0;
		while((length=inFile.read())!=-1){
			outFile.write(length);
		}
		//关闭资源
		outFile.close();
		inFile.close();
	}
	
	//字符输入流每次读取一个字符数组，字符流每次写出一个字符数组的一部分
	public static void method6(String srcString,String destString) throws IOException{
		//建立字符输入流对象
		FileReader inFile=new FileReader(srcString);
		//建立字符输入流对象
		FileWriter outFile=new FileWriter(destString);
		char[] chr=new char[1024];
		int length=0;
		while((length=inFile.read(chr))!=-1){
			outFile.write(chr,0,length);
			outFile.flush();
		}
		//释放资源
		outFile.close();
		inFile.close();
	}
	
	//字符缓冲流每次读写一个字符
	public static void method7(String srcString,String destString) throws IOException{
		//建立字符输入缓冲流对象
		BufferedReader brd=new BufferedReader(new FileReader(srcString));
		//建立字符输出缓冲流对象
		BufferedWriter bwt=new BufferedWriter(new FileWriter(destString));
		int length=0;
		while((length=brd.read())!=-1){
			bwt.write(length);
		}
		//释放资源
		bwt.close();
		brd.close();
	
	}
	//字符缓冲输入流每次读一个字符数组，字符缓冲输出流每次读一个字符数组的一部分
	public static void method8(String srcString,String destString) throws IOException{
		//建立字符输入缓冲流对象
		BufferedReader br=new BufferedReader(new FileReader(srcString));
		//建立字符输出缓冲流对象
		BufferedWriter bw=new BufferedWriter(new FileWriter(destString));
		char[] chs=new char[1024];
		int length=0;
		while((length=br.read(chs))!=-1){
			bw.write(chs,0,length);
		}
		//释放资源
		bw.close();
		br.close();
	}	
	
	//字符缓冲输入流每次读取一行，字符缓冲输出流每次写出一行
	public static void method9(String srcString,String destString) throws IOException{
		//建立字符输入缓冲流对象
		BufferedReader br=new BufferedReader(new FileReader(srcString));
		//建立字符输出缓冲流对象
		BufferedWriter bw=new BufferedWriter(new FileWriter(destString));
		String str=null;
		while((str=br.readLine())!=null){
			bw.write(str);
			bw.newLine();
			bw.flush();
		}
		//释放资源
		bw.close();
		br.close();
	}
}

2、复制多级目录到另一个盘

package IO;

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

public class copyFolderDemo {
	public static void main(String[] args) {
		File srcFile=new File("F:\\JavaSe\\day23\\code\\Demo");
		File destFile=new File("G:\\");
		try {
			copyFolder(srcFile,destFile);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}

	public static void copyFolder(File srcFile, File destFile) throws IOException {
		if(srcFile.isDirectory()){  //如果是文件夹就获取该文件夹的名字和该文件夹下所有的File对象
			File newFolder=new File(destFile,srcFile.getName());//<span style="font-family: Arial, Helvetica, sans-serif;">并在目的地目录创建相同名称的文件夹</span>
			newFolder.mkdir();
			File[] fileArray=srcFile.listFiles();//获取该文件夹下所有的File对象存储到File[]数组中
			for(File file:fileArray){<span style="white-space:pre">	</span>//遍历File[]数组
				copyFolder(file, newFolder); //递归调用
			}
			
		}else{
			File newFile=new File(destFile,srcFile.getName());//如果是文件就获取文件名
			copyFile(srcFile,newFile);//<span style="font-family: Arial, Helvetica, sans-serif;">复制文件到目的地</span>

		}
	}

	public static void copyFile(File srcFile, File newFile) throws IOException {
		//建立字节输入缓冲流对象
		BufferedInputStream bufferedIn=new BufferedInputStream(new FileInputStream(srcFile));
		//建立字节输出缓冲流对象
		BufferedOutputStream bufferedOut=new BufferedOutputStream(new FileOutputStream(newFile));
		
		byte[] buf=new byte[1024];
		int length=0;
		while((length=bufferedIn.read(buf))!=-1){
			bufferedOut.write(buf,0,length);
			bufferedOut.flush();
		}
		//释放资源
		bufferedOut.close();
		bufferedIn.close();
		
	}
}

3、把指定文件夹的java文件复制另一个文件夹并改后缀名

package IO;

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

public class FileRenameDemo2 {
	public static void main(String[] args) {
		File srcFolder=new File("F:\\Demo");
		File destFolder=new File("F:\\Test");
		
		if(!destFolder.exists()){	//判断目的地是否有该文件夹，没有就创建
			destFolder.mkdir();
		}
		 //获取数据源文件的所有File对象，并用文件过滤器进行过滤，把以“.java”结尾的文件存储到File数组中
		File[] fileArray=srcFolder.listFiles(new FilenameFilter() {
			
			@Override
			public boolean accept(File dir, String name) {
				// TODO Auto-generated method stub
				return new File(dir,name).isFile()&&name.endsWith(".java");
			}
		});
		// 遍历用过滤器过滤过的File数组并调用复制文件的方法复制文件到目的地文件夹中
		for(File file:fileArray){
			String name=file.getName();
			File newFile=new File(destFolder,name);
			try {
				copyFile(file,newFile);//调用复制文件夹的方法
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		
		//获取目标文件夹下所有的File对象
		File[] destFileArray= destFolder.listFiles();
		for(File destFile:destFileArray){
			String name=destFile.getName();//遍历获取每一个File对象的名字
			String newName=name.replace(".java", ".jad");//替换
			File newFile=new File(destFolder,newName);//相同目录是重命名，不同目录是剪切
			destFile.renameTo(newFile);//重命名
		}
	}

	private static void copyFile(File file, File newFile) throws IOException {
		// TODO Auto-generated method stub
		//建立字节缓冲输入流对象
		BufferedInputStream bis=new BufferedInputStream(new FileInputStream(file));
		//建立字节缓冲输出流对象
		BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(newFile));
		byte[] buf=new byte[1024];
		int length=0;
		while((length=bis.read(buf))!=-1){
			bos.write(buf,0,length);
		}
		bos.close();
		bis.close();
	}
}