IO工具类汇总 【java资源库：http://www.gxcode.top/code】

已于 2022-04-02 12:46:15 修改
阅读量2.6k 收藏 1
点赞数 2
分类专栏： Java工具类 文章标签： java
于 2020-03-28 00:02:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jinhuding/article/details/105153613
版权

【java资源库：http://www.gxcode.top/code】
一.代码：

/**
 * 统计文件夹的大小和文件个数
 */
public class DirCount {
	public static long len =0l;  //大小
	public static int fileSize=0;   //文件的个数
	public static int dirSize=0;//文件夹的个数
	
	private DirCount() {}
	public static DirCount  counDriNum(String path) {
		File src = new File(path);
		count(src);
		return new DirCount();
	}	
	/*
	 * 统计大小和文件的个数
	 */
	private static void count(File src) {	
	 if(null!=src && src.exists()) {
	   if(src.isFile()) {  
		 len+=src.length(); //文件大小
		 fileSize++;  //文件个数
	   }else{
		 dirSize++; //文件夹的个数
		 for(File s:src.listFiles()) {count(s);}
	   }
	 }
	}	
}
-------------------
public class DriInfo {
	//根据文件路径显示文件下所有子孙文件
	public static Map<String,String[]> getFilePath(String filepath, Map<String,String[]> map) {
		File f = new File(filepath);
		String[] listAry ;
		String parentPath ="";
		if(f.isDirectory()) { //目录
			listAry = f.list();
			map.put(f.getPath(), listAry);
			parentPath = f.getPath()+"\\";
			for(String str : listAry) {
				String newPath = parentPath+str;
				if(new File(newPath).isDirectory()) {getFilePath(newPath, map);	}
			}
		}else if(f.isFile()) { //文件
			parentPath = f.getParent();//获取父目录;
			listAry = new File(parentPath).list();
			map.put(parentPath, listAry);
			//判断文件下没有目录就结束递归
			boolean isdirtory = false;
			for(String str : listAry) {
				String newPath = parentPath+"\\"+str;
				isdirtory = new File(newPath).isDirectory();
				if(isdirtory) {
					isdirtory = true;
					getFilePath(newPath, map);
				}
			}
			if(!isdirtory) {return map;}
			
		}
		return map;
	}
}
--------------------------------------
public class IoFile {
	// 1.文件的拷贝 
	public static void copy(String srcPath,String destPath) {
		//1、创建源
		File src = new File(srcPath); //源头
		File dest = new File(destPath);//目的地
		//2、选择流
		InputStream  is =null;
		OutputStream os =null;
		try {
			is =new FileInputStream(src);
			os = new FileOutputStream(dest);		
			//3、操作 (分段读取)
			byte[] flush = new byte[1024]; //缓冲容器
			int len = -1; //接收长度
			while((len=is.read(flush))!=-1) {
				os.write(flush,0,len); //分段写出
			}			
			os.flush();
		}catch(FileNotFoundException e) {		
			e.printStackTrace();
		}catch (IOException e) {
			e.printStackTrace();
		}finally{
			close(os,is); //4、释放资源 分别关闭 先打开的后关闭
		}
	}
	
	//2.字节数组到文件
	public static OutputStream  byteToFile(byte[] datas, String strFile) {
		OutputStream os = null ;
		try {
			InputStream is = new ByteArrayInputStream(datas);
			os = new FileOutputStream(strFile);
			copy(is,os);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}	
		return os;
	}

	//3.文件到字节数组
	public static byte[]  fileToByte(InputStream is) {
	    byte[] datas = null;
	    ByteArrayOutputStream os = new ByteArrayOutputStream();
		copy(is,os);
		datas = os.toByteArray();
		return datas;
	}
	
	//4.字符流数据写入指定文件
	public static void writeStrFile(String cont, String path, boolean b) {
		OutputStream os =null;
		try {
			File dest = new File(path);        //1、创建源
			os = new FileOutputStream(dest,b); //2、选择流
			byte[] datas =cont.getBytes();  //字符串->字节数组(编码 )
			os.write(datas,0,datas.length); //3、操作(写出)
			os.flush();
		}catch(FileNotFoundException e) {		
			e.printStackTrace();
		}catch (IOException e) {
			e.printStackTrace();
		}finally{
			close(os);  //4、释放资源
		}
	}
	//5.字节流读取指定文件内容
	public static String readStrFile(String pathFile) {
		StringBuilder sb = new StringBuilder("");
		InputStream  is =null; //2、选择流
		try {
			is =new FileInputStream(new File(pathFile)); //1、创建源
			//3、操作 (分段读取)
			byte[] flush = new byte[1024*10]; //缓冲容器
			int len = -1; //接收长度
			while((len=is.read(flush))!=-1) { //字节数组-->字符串 (解码)
				String str = new String(flush,0,len);
				sb.append(str);
			}		
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			close(is);  //4、释放资源
		}
		return sb.toString();
	}
	
		
	//6.字节数组写到指定文件内容
	public static void readByteFile(byte[] src,String filePath) {
		//1、创建源
		File dest = new File(filePath);
		//2、选择流
		InputStream  is =null;
		OutputStream os =null;
		try {
			is =new ByteArrayInputStream(src);
			os = new FileOutputStream(dest);
			//3、操作 (分段读取)
			byte[] flush = new byte[1024]; //缓冲容器
			int len = -1; //接收长度
			while((len=is.read(flush))!=-1) {
				os.write(flush,0,len);			//写出到文件	
			}		
			os.flush();
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			close(os);  //4、释放资源
		}
	}
	
	//7.指定文件获取字节数组
	public static byte[] writeByteFile(String filePath) {
		InputStream  is =null;//2、选择流
		ByteArrayOutputStream baos =null;
		try {
			is =new FileInputStream(new File(filePath)); //1、创建源与目的地
			baos = new ByteArrayOutputStream();
			//3、操作 (分段读取)
			byte[] flush = new byte[1024]; //缓冲容器
			int len = -1; //接收长度
			while((len=is.read(flush))!=-1) {
				baos.write(flush,0,len);		 //写出到字节数组中			
			}		
			baos.flush();
			return baos.toByteArray();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally {
			close(is);  //4、释放资源
		}
		return null;		
	}
	
	//8.把对象转字节数组
	public static byte[] objToByte(Object obj) {
		byte[] datas = null;
		//写出 -->序列化
		ByteArrayOutputStream baos =new ByteArrayOutputStream();
		ObjectOutputStream oos = null;
		try {
			oos= new ObjectOutputStream(new BufferedOutputStream(baos));
			oos.writeObject(obj);
			oos.flush();
			datas =baos.toByteArray();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			close(oos); //4、释放资源 分别关闭 先打开的后关闭
		}
		return datas;
	}
	
	//9.把字节数组转对象
	public static Object byteToObj(byte[] datas) {
		ObjectInputStream ois = null;
		Object obj = null;
		try {
			ois = new ObjectInputStream(new BufferedInputStream(new ByteArrayInputStream(datas)));
			obj = ois.readObject();
		} catch (IOException e) {
			System.out.println("转对象输入流错误！！！");
		}catch (ClassNotFoundException e) {
			System.out.println("转对象错误！！！");
		}finally {
			close(ois); //4、释放资源 分别关闭 先打开的后关闭
		}
		return obj;
	}


	//对接输入输出流
	public static void copy(InputStream is,OutputStream os) {		
		try {			
			//3、操作 (分段读取)
			byte[] flush = new byte[1024]; //缓冲容器
			int len = -1; //接收长度
			while((len=is.read(flush))!=-1) {
			  os.write(flush,0,len); //分段写出
			}			
			os.flush();
		}catch(FileNotFoundException e) {		
			e.printStackTrace();
		}catch (IOException e) {
			e.printStackTrace();
		}finally{
			close(os,is); //4、释放资源 分别关闭 先打开的后关闭
		}
	}
	
	// 释放资源
	public static void close(Closeable... ios) {
	 for(Closeable io:ios) {
		try {
		    if(null!=io) {io.close();}
		} catch (IOException e) {
			e.printStackTrace();
		}
	  }
	}
}
------------
public class SplitFile {
		
		/*
		 * 分割:
		 *   源文件路径：srcPath| 目标文件路径：destDir|分割每块大小(字节)：blockSize
		 */
		public static List<String> split(String srcPath, String destDir, int blockSize) {
			/* 1.init初始信息 */
			File src =new File(srcPath);
			List<String> destPaths =new ArrayList<String>();
			long len = src.length();	 //总长度	
			int size =(int) Math.ceil(len*1.0/blockSize);  //块数: 多少块
			for(int i=0;i<size;i++) { //路径
			  destPaths.add(destDir +"/"+i+"-"+src.getName());
			}	
			/*2.起始位置和实际大小*/
			int beginPos = 0;
			int actualSize = (int)(blockSize>len?len:blockSize); 
			for(int i=0;i<size;i++) {
				beginPos = i*blockSize;
				if(i==size-1) { //最后一块
					actualSize = (int)len;
				}else {
					actualSize = blockSize;
					len -=actualSize; //剩余量
				}
				
				/*3.指定第i块的起始位置 和实际长度*/
				RandomAccessFile raf = null;
				RandomAccessFile raf2 = null;
				try {
					raf =new RandomAccessFile(src,"r");
					raf2 =new RandomAccessFile(destPaths.get(i),"rw");
					raf.seek(beginPos); //随机读取
					//读取  3、操作 (分段读取)
					byte[] flush = new byte[1024]; //缓冲容器
					int len1 = -1; //接收长度
					while((len1=raf.read(flush))!=-1) {			
						if(actualSize>len1) { //获取本次读取的所有内容
							raf2.write(flush, 0, len1);
							actualSize -=len1;
						}else { 
							raf2.write(flush, 0, actualSize);
							break;
						}
					}			
				}catch (IOException e) {
					System.out.println("详细分割信息错误");
				}finally {
					close(raf2,raf);
				}
			}
			return destPaths;
		}
		
		/*
		 * 文件的合并
		 *  合并的多个文件路径：destPaths | 合并后新文件：destPath
		 */
		public static void merge(String destPath, List<String> destPaths)  {
			OutputStream os = null;
			SequenceInputStream sis =null;
			try {
			//输出流
			os =new BufferedOutputStream( new FileOutputStream(destPath,false));//true：表示追加
			Vector<InputStream> vi = new Vector<InputStream>();
			//输入流
			for(int i=0;i<destPaths.size();i++) {
				vi.add(new BufferedInputStream(new FileInputStream(destPaths.get(i))));											
			}
			sis =new SequenceInputStream(vi.elements());
			//拷贝
			//3、操作 (分段读取)
			byte[] flush = new byte[1024]; //缓冲容器
			int len = -1; //接收长度
			while((len=sis.read(flush))!=-1) {
				os.write(flush,0,len); //分段写出
			}			
			os.flush();	
			}catch(IOException e) {
				System.out.println("文件和的时候报错！！！");
			}finally {
				close(sis,os);
			}
		}
		
		
		/* 释放资源*/ 
		public static void close(Closeable... ios) {
		 for(Closeable io:ios) {
			try {
			    if(null!=io) {io.close();}
			} catch (IOException e) {
				e.printStackTrace();
			}
		  }
		}
		
}
----------
/**
 * 字符编码和解密工具
 */
public class StrinDE {
   //字符编码工具
   public  static byte[] getStrToByte(String str,String charset) {
		try {
		 if(str!=null && str.length()>0) {
		   byte[] ary = str.getBytes(charset);
		   return ary;
		 }
		} catch (UnsupportedEncodingException e) {
			System.out.println("字符串：编码错误");
		}
		return null ;
   }
   //字符解密码工具
   public  static String getByteToStr(String charset,byte[] ary) {
		try {
		 if(ary!=null && ary.length>0) {
		    String str = new String(ary,0,ary.length,charset);
		    return str;
		  }
		} catch (UnsupportedEncodingException e) {
			System.out.println("字节数组：解密错误");
		}
		return null ;
    }
}
----------
public class URLToString {
	public static String getStrToURL(String url,String charset,String desPath) {
		if(charset==null) { charset= "UTF-8";}
		if(url==null) { url = "http://www.baidu.com" ;}
		if(desPath==null) { desPath = System.getProperty("user.dir") ; }
		String count = "";
		BufferedReader reader = null;
		BufferedWriter writer = null;
		try {
		   reader = new BufferedReader(new InputStreamReader(new URL(url).openStream(),charset));
		   writer =new BufferedWriter(new OutputStreamWriter(new FileOutputStream(desPath),charset));
		   while((count=reader.readLine())!=null) {
			 writer.write(count); //字符集不统一不够出现乱码
			 writer.newLine();
		   }					
		   writer.flush();
		}catch(IOException e) {
			System.out.println("获取网络流数据错误！！！");
		}finally {
			close(reader,writer);
		}
		return count;
	}
	
	public static void close(Closeable... ios) {
	 for(Closeable io:ios) {
		try {
		    if(null!=io) {io.close();}
		} catch (IOException e) {
			e.printStackTrace();
		}
	  }
	}

}

二.工具类说明：
1.com.djh.utils.io.StrinDE
1.1编码方法：
byte[] ary1 = StrinDE.getStrToByte(“你好，我是…”, “GBK”);
1.2 解码方法：
String newStr = StrinDE.getByteToStr(“GBK”, ary1);
System.out.println(newStr);

2.com.djh.utils.io.DirCount
根据目录统计：
DirCount.counDriNum(“D:\other”);
文件夹大小：
DirCount.len;
文件夹下目录多少：
DirCount.fileSize);
文件夹下文件多少：
DirCount.dirSize);

3.com.djh.utils.io.DriInfo
根据文件路径，获取该文件下所有文件：【说明key:文件夹路径 ，value:文件夹路径下文件(文件夹和文件)】
Map<String,String[]> resultMap = DriInfo.getFilePath(“D:\other”,new HashMap<String,String[]>());

4.com.djh.utils.io.IoFile
4.1 拷贝单个文件：
IoFile.copy(String srcPath,String destPath);
4.2 文件到字节数组：
byte[] ary1 = IoFile.fileToByte(new FileInputStream(“D:\other\H.java”));
System.out.println(ary1.length);
4.3 字节数组到文件：
IoFile.byteToFile(ary11, “D:\other\p.java”);

    4.4数据写入指定文件
   	   IoFile.writeStrFile("要写内容","D:\\OO.txt",true); //文件末尾追加
    4.5 指定文件路径读取内容
       IoFile.readStrFile("D:\\\\OO.txt");
    4.6 文件到字节数组中
       byte[] byteAry = IoFile.writeByteFile("D:\\\\111.jpg");
    4.7  字节数组到文件中
       IoFile.readByteFile(byteAry,"D:\\\\333.jpg");
    4.8 对象序列化为字节数组
       //注意People类需要实现Serializable接口。
       byte[] dates = IoFile.objToByte(new People("nn",10));
    4.9 字节数组反序列化为对象
      Object o = IoFile.byteToObj(dates);

5.com.djh.SplitFile
5.1文件分割： 返回分割后多个文件路径名。
List destPaths = SplitFile.split(“D:\tupain.jpg”, “D:\”,1024*10);
5.2文件合并
SplitFile.merge(“D:\newtupain.jpg”, destPaths);

6.com.djh.URLToString
6.1 根据网络URL获取和编码获取网络资源信息
URLToString.getStrToURL(“www.baidu.com”,“UTF-8”,“D:\page.html”);

java之书
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
毕业设计---基于java的软件资源库的实现(后端).zip
01-15
例如，Java提供产生图形用户接口部件的类（java.awt包），这里awt是抽象窗口工具集（abstract windowing toolkit）的缩写，处理输入输出的类（java.io包）和支持网络功能的类（java.net包）。 分布性 Java设计成支持...
JAVA_API1.6文档（中文）
04-12
java.util 包含 collection 框架、遗留的 collection 类、事件模型、日期和时间设施、国际化和各种实用工具类（字符串标记生成器、随机数生成器和位数组）。 java.util.concurrent 在并发编程中很常用的实用工具类...
IO常用工具类 commons-io
chy1984的博客
08-11 1674
都是先调用openOutputStream()打开文件，进行写入，再关闭文件；未指定字符集时，默认使用jvm默认字符集，jvm默认字符集由jvm启动时根据操作系统设置的地区、字符集确定。commons-io 是apache开源的io工具类库，封装了很多IO工具类，使用方便。打开文件后，如果已经读取了所有内容，后续再次读取时游标已经在文件尾了，读不到任何内容。copy()、copyLarge() 底层都是调用相同的方法，区别在于。，用 \ 转义字符串中的 \，所以写成 \\，实际返回、输出的是 \。...
【Java-11】 IO流、Properties集合、IO工具类的知识整理总结
接着奏乐接着舞的博客
05-31 2051
通过变量,数组,或者集合存储数据都是不能永久化存储 , 因为数据都是存储在内存中只要代码运行结束，所有数据都会丢失使用IO流1，将数据写到文件中，实现数据永久化存储2，把文件中的数据读取到内存中(Java程序)I 表示intput ，是数据从硬盘进内存的过程，称之为读。O 表示output ，是数据从内存到硬盘的过程。称之为写IO的数据传输，可以看做是一种数据的流动，按照流动的方向，以内存为参照物，进行读写操作简单来说：内存在读，内存在写。
Java中commons-IO
最新发布
2401_84024343的博客
04-11 692
总而言之，面试官问来问去，问的那些Redis知识点也就这么多吧，复习的不够到位，知识点掌握不够熟练，所以面试才会卡壳。将这些Redis面试知识解析以及我整理的一些学习笔记分享出来给大家参考学习一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！一个人可以走的很快，但一群人才能走的更远。
IOUtils详解——工具类学习
qq_43842093的博客
10-05 1382
IOUtils类的所有成员字段和方法都是静态的，因此在标准编程中不需要创建IOUtils类的对象，而是通过类名和适当的方法名来使用它。。现在我们将要讨论的是IOUtils中的一些非常重要的方法。类中的所有处理InputStream的方法都带有内部的缓冲区，所以我们不需要再使用或者，默认的缓冲区大小为4K，不过我们也可以自定义它的大小。：它将无条件的关闭一个可被关闭的对象而不抛出任何异常。它也有很多版本去支持关闭所有的InputStream、OutputStream、Reader和Writer。
Java常见类库与工具及官网
ConstXiong
05-21 2078
Javahttps://www.oracle.com/java/technologies/ OpenJDKhttps://openjdk.java.net/ w3c(万维网联盟)https://www.w3.org/ apache(开源项目非盈利组织)https://www.apache.org/ Oraclehttps://www.oracle.com/index.html MySQLhttps://www.mysql.com/ mongoDB(分布式文件存储的数据库)https://www.
[Java参考文档].JDK_API 1.6
09-21
java.util 包含 collection 框架、遗留的 collection 类、事件模型、日期和时间设施、国际化和各种实用工具类（字符串标记生成器、随机数生成器和位数组）。 java.util.concurrent 在并发编程中很常用的实用工具类。...
Java资源包01
08-31
PortGroper 是一款java写的开源拒绝服务测试工具,它不是僵尸网络类的ddos,而是使用大量的代理作为bots发起DDOS。Port Groper可以与用测试防火墙，干扰web 统计脚本的跟踪，为网站增加流量..往好了用什么都能干，就是...
JAVA上百实例源码以及开源项目
01-03
　Java二进制IO类与文件复制操作实例，好像是一本书的例子，源代码有的是独立运行的，与同目录下的其它代码文件互不联系，这些代码面向初级、中级Java程序员。 Java访问权限控制源代码 1个目标文件 摘要:Java源码,...
【Java】Java中的常用工具类（排名前 16）
DreamSun的博客
03-22 2952
在Java中，工具类定义了一组公共方法，这篇文章将介绍Java中使用最频繁及最通用的Java工具类。以下工具类、方法按使用流行度排名，参考数据来源于Github上随机选取的5万个开源项目源码。大部分方法可以望文知意，请务必浏览一遍，知道有哪些好用的工具类，不必自己造轮子了。现在你只要了解了以上16种最流行的工具类方法，你就不必要再自己写工具类了，不必重复造轮子。大部分工具类方法通过其名字就能明白其用途。另外，工具类，根据阿里开发手册，包名如果要使用util不能带s，工具类命名为 XxxUtils。
Java好资源网址推荐
热门推荐
cnds123的专栏
01-31 6万+
Java好资源网址推荐
Java——IO流
weixin_44146372的博客
09-21 252
字节流、字符流、缓冲流、转换流、对象流等等 IO 操作🌌
JAVA常用的工具类
qq_43409973的博客
05-04 2381
我们都知道，java中的很多集合，比如：ArrayList、LinkedList、HashMap、HashSet等，都是线程不安全的。中传递信息，比如：traceId，source等，便于在查询日志时能够串联一次完整的请求链路，快速定位问题。包下的一个类，它的全称是Mapped Diagnostic Context，我们可以认为它是一个线程安全的存放诊断日志的容器。**接口，MDC中获取当前请求的traceId，然后设置到header中。**方法，将这些线程不安全的集合，直接转换成线程安全集合。
JAVA常用工具-文件操作相关IO
wuyundong123的博客
04-11 535
源文件->输入流->逻辑处理->输出流->目标文件；流动方向：输入流、输出流；流数据类型：字节流、字符流基础API字节流：InputStream输入、OutputStream输出；数据传输的基本单位是字节；read()：输入流中读取数据的下一个字节；read(byte b[])：读数据缓存到字节数组；write(int b)：指定字节写入输出流；write(byte b[])：数组字节写入输出流；字符流：Reader读取、Writer写出；数据传输的基本单位是字符；
java commons-io 工具类的使用
Rockandrollman的博客
04-26 350
commons-io是第三方程序员编写的工具类，并不是java本身带的方法。是在java提供的工具类基础上，开发的工具类。简化了代码的用法，可以提升开发效率。
【从入门到起飞】JavaSE—IO工具包(Commons-io，Hutool) (2)
小吉妙妙屋
11-16 1226
IO工具包
Java基础：IO相关的类
天然玩家的博客
02-07 1146
（1）字节流：使用InputStream和OutputStream抽象类的子类； （2）字符流：使用Reader和Writer抽象类的子类； （3）File：文件和目录路径的抽象表达，用于操作文件和目录； （4）RandomAccessFile：随机写入和读取文件。
java.io.FileNotFoundException: ../../../res/xml/timezones.xml
12-15
在这个例子中，文件路径为"../../../res/xml/timezones.xml"，这个路径是相对路径，表示在当前文件的上两级目录下的res/xml文件夹中寻找timezones.xml文件。如果在这个路径下找不到timezones.xml文件，就会报java.io...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

java之书

会持续更新实用好的文章谢谢关注

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值