IO_原理_分类_字节流

最新推荐文章于 2022-08-05 08:00:00 发布

Carmen_W

最新推荐文章于 2022-08-05 08:00:00 发布

阅读量321

点赞数

分类专栏： JAVA基础

本文链接：https://blog.csdn.net/xw_Summer/article/details/84996566

版权

JAVA基础专栏收录该内容

38 篇文章 0 订阅

订阅专栏

一、概念
流:流动、流向，从一端移动到另一端
源头与目的地
程序与文件|数组|网络连接|数据库，以程序为中心

二、IO流分类

按流向: 输入流与输出流
按数据:
字节流:二进制，可以一切文件包括纯文本 doc 音频、视频等等
字符流:文本文件，只能处理纯文本
按功能:
节点:包裹源头
处理:增强功能，提高性能

三、字符流与字节流（重点）与文件
1、字节流

 输入流:InputStream  
 read(byte[] b) 
 read(byte[] b, int off, int len)  
 close() 
 FileInputStream()

在这里插入图片描述

方法摘要

输出流:OutputStream
write(byte[] b)
write(byte[] b, int off, int len)
flush()
close()
FileOutputStream
在这里插入图片描述

2、字符流

输入流:Reader 
read(char[] cbuf) 
read(char[] cbuf, int off, int len) 
close() 
FileReader()

在这里插入图片描述

 输出流:Writer  
    write(char[] cbuf) 
    write(char[] cbuf, int off, int len) 
    flush() 
    close()
    write(String str, int off, int len) 
    FileWriter()

在这里插入图片描述

方法摘要：

四、操作

举例:搬家 -->读取文件
1)、关联房子 —>建立与文件联系
2)、选择搬家 -->选择对应流
3)、搬家 -->读取|写出
a)、卡车大小 —>数组大小
b)、运输 -->读取、写出
4)、打发over -->释放资源
操作
1)建立联系
2)选择流
3)操作数组大小+read 、write
4)释放资源

字节流

字节流:可以处理一切文件，包括二进制音频、视频、doc等
节点流:
InputStream FileInputStream
OutputStream FileOutputStream

一、读取文件
1、建立联系 File对象源头
2、选择流文件输入流 InputStream FileInputStream
3、操作 : byte[] car =new byte[1024]; +read+读取大小
输出
4、释放资源 :关闭

package com.bjsxt.io.byteIO;

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

/**
 * 文件的读取
 * 1、建立联系   File对象
   2、选择流     文件输入流  InputStream FileInputStream
   3、操作  : byte[] car =new byte[1024];  +read+读取大小
              输出
   4、释放资源 :关闭
 * @author Administrator
 *
 */
public class Demo01 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		//1、建立联系   File对象
		File src =new File("e:/xp/test/a.txt");
		//2、选择流     文件输入流 
		InputStream is =null; //提升作用域
		try {
			is =new FileInputStream(src);
			//3、操作 不断读取 缓冲数组
			byte[] car =new byte[1024];
			int len =0; //接收 实际读取大小
			//循环读取
			StringBuilder sb =new StringBuilder();//一个可变的字符序列，构造一个不带任何字符的字符串生成器，其初始容量为 16 个字符。
			while(-1!=(len=is.read(car))){   // int read(byte[] b) 从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。并返回长度
				//输出  字节数组转成字符串
				String info =new String(car,0,len);
				sb.append(info);
			}
			System.out.println(sb.toString());
			
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
			System.out.println("文件不存在");
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("读取文件失败");
		}finally{
			try {
				//4、释放资源
				if (null != is) {
					is.close();
				}
			} catch (Exception e2) {
				System.out.println("关闭文件输入流失败");
			}
		}
	}

}

结果：
在这里插入图片描述
二、写出文件
1、建立联系 File对象目的地
2、选择流文件输出流 OutputStream FileOutputStream
3、操作 : write() +flush
4、释放资源 :关闭

package com.bjsxt.io.byteIO;

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

/**
 * 写出文件
1、建立联系   File对象  目的地
2、选择流     文件输出流  OutputStream FileOutputStream
3、操作  :  write() +flush
4、释放资源 :关闭
 * @author Administrator
 *
 */
public class Demo02 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		//1、建立联系   File对象  目的地
		File dest =new File("e:/xp/test/test.txt");
		//2、选择流   文件输出流  OutputStream FileOutputStream
		OutputStream os =null;
		//以追加形式 写出文件 必须为true 否则为覆盖
		try {
			os =new FileOutputStream(dest,true);   以追加形式 写出文件 必须为true 否则为覆盖
			//3、操作
			String str="bjsxt is very good \r\n";
			//字符串转字节数组
			byte[] data =str.getBytes();
			os.write(data,0,data.length);
			
			os.flush(); //强制刷新出去
		} catch (FileNotFoundException e) {
			e.printStackTrace();
			System.out.println("文件未找到");
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("文件写出失败");
		}finally{
			//4、释放资源 :关闭
			try {
				if (null != os) {
					os.close();
				}
			} catch (Exception e2) {
				System.out.println("关闭输出流失败");
			}
		}
	}

}

结果：
在这里插入图片描述

三、文件拷贝程序为桥梁

建立联系 File对象源头目的地
选择流
文件输入流 InputStream FileInputStream
文件输出流 OutputStream FileOutputStream
操作 : 拷贝
byte[] flush =new byte[1024];
int len =0;
while(-1!=(len=输入流.read(flush))){
输出流.write(flush,0,len)
}
输出流.flush
释放资源 :关闭两个流

package com.bjsxt.io.byteIO;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

/**
 1、建立联系   File对象   源头 目的地
2、选择流     
	 文件输入流  InputStream FileInputStream
	  文件输出流  OutputStream FileOutputStream
3、操作  :  拷贝
	 byte[] flush =new byte[1024]; 
	 int len =0;
	  while(-1!=(len=输入流.read(flush))){  
		 输出流.write(flush,0,len)
	  }
             输出流.flush
4、释放资源 :关闭 两个流
 
 
 * @author Administrator
 *
 */
public class CopyFileDemo {

	/**
	 * @param args
	 * @throws FileNotFoundException 
	 */
	public static void main(String[] args) {
		String src ="E:/xp/test";
		String dest="e:/xp/test/4.jpg";
		try {
			copyFile(src,dest);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
			System.out.println("文件不存在");
		} catch (IOException e) {
			e.printStackTrace();
			System.out.println("拷贝文件失败|关闭流失败");
		}
	}
	/**
	 * 文件的拷贝
	 * @param  源文件路径
	 * @param  目录文件路径
	 * @throws FileNotFoundException,IOException
	 * @return 
	 */
		public static void copyFile(String srcPath,String destPath) throws FileNotFoundException,IOException {
			//1、建立联系 源(存在且为文件) +目的地(文件可以不存在)  
			File src =new File(srcPath);
			File dest =new File(destPath);
			if(! src.isFile()){ //不是文件或者为null
				System.out.println("只能拷贝文件");
				throw new IOException("只能拷贝文件");
			}
			//2、选择流
			InputStream is =new FileInputStream(src);
			OutputStream os =new FileOutputStream(dest);
			//3、文件拷贝   循环+读取+写出
			byte[] flush =new byte[1024];
			int len =0;
			//读取
			while(-1!=(len=is.read(flush))){
				//写出
				os.write(flush, 0, len);
			}
			os.flush(); //强制刷出
			
			//关闭流
			os.close();
			is.close();
		}

}

四、文件夹拷贝

递归查找子孙级文件|文件夹
文件复制(IO流复制)
文件夹创建
A
/
a.txt b
|
b.txt

AA
|
A
/
a.txt b
|
b.txt
不能将父目录拷贝到子目录中
删除超长目录

package com.bjsxt.io.byteIO;

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 java.io.InputStream;
import java.io.OutputStream;
/**
 * 文件操作
 * 1、文件拷贝
 * 2、文件夹拷贝  拒绝自己拷贝给自己
 * @author Administrator
 *
 */
public class FileUtil {
	/**
	 * 拷贝文件夹
	 * @param src 源路径
	 * @param dest 目标路径
	 * @throws IOException 
	 * @throws FileNotFoundException 
	 */
	public static void copyDir(String  srcPath,String destPath) throws FileNotFoundException, IOException{
		//拒绝自己拷贝给自己
		if(srcPath.equals(destPath)){
			return ;
		}
		File src=new File(srcPath);
		File dest =new File(destPath);
		copyDir(src,dest);		
	}
	
	
	
	/**
	 * 拷贝文件夹
	 * @param src 源File对象
	 * @param dest 目标File对象
	 * @throws IOException 
	 * @throws FileNotFoundException 
	 */
	public static void copyDir(File src,File dest) throws FileNotFoundException, IOException{
		if(src.isDirectory()){ //文件夹
			dest =new File(dest,src.getName());     // getName():返回目录的名称
			 // File(File parent, String child) 根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。
			 // File	getAbsoluteFile()  返回此抽象路径名的绝对路径名形式。
			 // String	getAbsolutePath() 返回此抽象路径名的绝对路径名字符串。
			if(dest.getAbsolutePath().contains(src.getAbsolutePath())){ //是否包含子字符串
				System.out.println("父目录不能拷贝到子目录中");
				return;
			}
		}		
		copyDirDetail(src,dest);
	}
	
	/**
	 * 拷贝文件夹细节
	 * @param src
	 * @param dest
	 */
	public static void copyDirDetail(File src,File dest) throws FileNotFoundException,IOException{
		if(src.isFile()){ //文件
			try {
				FileUtil.copyFile(src, dest);
			} catch (FileNotFoundException e) {
				//e.printStackTrace();
				throw e;
			} catch (IOException e) {
				//e.printStackTrace();
				throw e;
			}
		}else if(src.isDirectory()){ //文件夹
			//确保目标文件夹存在
			dest.mkdirs();
			//获取下一级目录|文件
			for(File sub:src.listFiles()){
				copyDirDetail(sub,new File(dest,sub.getName()));
			}
		}
	}
	
	
	/**
	 * 文件的拷贝
	 * @param  源文件路径
	 * @param  目录文件路径
	 * @throws FileNotFoundException,IOException
	 * @return 
	 */
	public static void copyFile(String srcPath,String destPath) throws FileNotFoundException,IOException {
		//1、建立联系 源(存在且为文件) +目的地(文件可以不存在) 
		copyFile(new File(srcPath),new File(destPath));
	}
	/**
	 * 文件的拷贝
	 * @param  源文件File对象
	 * @param  目录文件File对象
	 * @throws FileNotFoundException,IOException
	 * @return 
	 */
	public static void copyFile(File src,File dest) throws FileNotFoundException,IOException {
		if(! src.isFile()){ //不是文件或者为null
			System.out.println("只能拷贝文件");
			throw new IOException("只能拷贝文件");
		}
		//dest为已经存在的文件夹，不能建立于文件夹同名的文件
		if(dest.isDirectory()){
			System.out.println(dest.getAbsolutePath()+"不能建立于文件夹同名的文件");
			throw new IOException(dest.getAbsolutePath()+"不能建立于文件夹同名的文件");
		}
		
		
		//2、选择流
		InputStream is =new BufferedInputStream(new FileInputStream(src));
		OutputStream os =new BufferedOutputStream(new FileOutputStream(dest));
		//3、文件拷贝   循环+读取+写出
		byte[] flush =new byte[1024];
		int len =0;
		//读取
		while(-1!=(len=is.read(flush))){
			//写出
			os.write(flush, 0, len);
		}
		os.flush(); //强制刷出
		
		//关闭流
		os.close();
		is.close();
	}
}

package com.bjsxt.io.byteIO;

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

/**
 * 文件夹的拷贝
 * 1、文件 赋值  copyFile
 * 2、文件 创建 mkdirs()
 * 3、递归查找子孙级
 * 
 * @author Administrator
 *
 */
public class CopyDir {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		//源目录
		String srcPath="E:/xp/test/a"; 	
		//目标目录
		String destPath="E:/xp/test/a/b";
		try {
			FileUtil.copyDir(srcPath,destPath);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		
	}
	/**
	 * 拷贝文件夹
	 * @param src 源路径
	 * @param dest 目标路径
	 */
	public static void copyDir(String  srcPath,String destPath){
		File src=new File(srcPath);
		File dest =new File(destPath);
		copyDir(src,dest);		
	}
	
	
	
	/**
	 * 拷贝文件夹
	 * @param src 源File对象
	 * @param dest 目标File对象
	 */
	public static void copyDir(File src,File dest){
		if(src.isDirectory()){ //文件夹
			dest =new File(dest,src.getName());			
		}		
		copyDirDetail(src,dest);
	}
	
	/**
	 * 拷贝文件夹细节
	 * @param src
	 * @param dest
	 */
	public static void copyDirDetail(File src,File dest){
		if(src.isFile()){ //文件
			try {
				FileUtil.copyFile(src, dest);
			} catch (FileNotFoundException e) {
				e.printStackTrace();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}else if(src.isDirectory()){ //文件夹
			//确保目标文件夹存在
			dest.mkdirs();
			//获取下一级目录|文件
			for(File sub:src.listFiles()){
				copyDirDetail(sub,new File(dest,sub.getName()));
			}
		}
	}
	
	

}

Carmen_W

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
IO_原理_分类_字节流

一、概念流:流动、流向，从一端移动到另一端源头与目的地程序与文件|数组|网络连接|数据库，以程序为中心二、IO流分类按流向: 输入流与输出流按数据:字节流:二进制，可以一切文件包括纯文本 doc 音频、视频等等字符流:文本文件，只能处理纯文本按功能:节点:包裹源头处理:增强功能，提供性能三、字符流与字节流（重点）与文件1、字节流输入流:In...
复制链接

扫一扫