1.Java 获得给定目录下 17年之前的文件/文件夹---------2.对指定的文件或者文件夹进行压缩

1.需求：由于服务器存储空间不足，读某一指定目录下18年之前的文件进行压缩。

获取指定目录下的满足条件的文件或者文件夹，如果文件夹下文件都是17年之前的文件，文件夹返回。

简单理解就是 如果文件夹下面都满足情况，则文件夹返回做压缩操作。如果文件夹下面有18年的文件，就单独返回该目录下18年之前的文件做压缩操作，对子文件夹重新判断。

package com.css.filezip;

import java.io.File;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * get qualified file and folder
 * @author CSS
 *
 */
public class qualifiedFileAndFolder {

	public static boolean flag_finish=false;
	public static String root_path="";	
	//private final long timeStamp=(long)1514736000*1000;//2018-01-01 00:00:00
	private static long timeStamp=(long)1524464048*1000;	//test 2018-04-23 14:14:08
	public static List<File> fileArr_ret= new ArrayList<File>();
	public static List<File> folderArr_ret= new ArrayList<File>();
	
	public static SimpleDateFormat sdf_date=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); 
	public static String str_date=sdf_date.format(timeStamp);  
	
	
	public static List<File> ListTest=new ArrayList<File>();
	
	public qualifiedFileAndFolder(String path){
		File file= new File(path);
		ListTest.add(file);
		test(ListTest);
		
		System.out.println("print Zip message================css");
		for(File file2:fileArr_ret){
			System.out.println("need Zip file	"+file2.getAbsolutePath());
		}
		
		for(File folder:folderArr_ret){
			System.out.println("need Zip folder	"+folder.getAbsolutePath());
		}
	}
       
	public static void test(List<File> ListTest){
		
		List<File> temp1List= new ArrayList<File>();
		if(ListTest!=null&&ListTest.size()>0){
			for(File fileTest:ListTest){
				System.out.println(" scan dir"+fileTest);
				//如果返回true 代表目录下有18年之后的文件，需要继续遍历子文件夹
				if(true == scan_dir(fileTest.getAbsolutePath())){
					temp1List.add(fileTest);
				}
			}
			
			
			List<File> temp2List= new ArrayList<File>();
			
			for(int i=0;i<temp1List.size();i++){
				//遍历不满足情况的目录下文件信息，将子文件夹加入到列表重新遍历
				File[] fileTempFiles=temp1List.get(i).listFiles();
				for(File file:fileTempFiles){
					if(file.isDirectory()){
						temp2List.add(file);
					}
				}	
			}
			
			test(temp2List);
				
		}
		
		
		
	}
	
	public static Boolean scan_dir(String dir_path){
		
		flag_finish=false;
		System.out.println("start scaning");
		List<File> fileArr= new ArrayList<File>();
		List<File> folderArr= new ArrayList<File>();
		File[] fileAndfloder_NameArr;
		File rootFile= new File(dir_path);
		if(rootFile.exists()){
			System.out.println(dir_path+"	dir eixt");
			fileAndfloder_NameArr=rootFile.listFiles();
			
			for(File  fileAndfloder:fileAndfloder_NameArr){
				if(fileAndfloder.isDirectory()){
					folderArr.add(fileAndfloder);
					//System.out.println("******	"+fileAndfloder+"	isDirectory");
				}
				else if(fileAndfloder.isFile()){
					fileArr.add(fileAndfloder);
					//System.out.println("******	"+fileAndfloder+"	isFile");
				}
			}
			
			//如果存在子文件夹，遍历子文件夹下面是否有文件是18年之后的
			if(folderArr.size()>0){
				exit18yearfile(folderArr);
			}else {
				flag_finish=false;
			}
			if(flag_finish){
				 System.out.println("flag====ture");
				//flag==true 代表不能把上级文件夹直接打包
				//将当前目录下的文件是18年之前的文件加入到需要打包的文件List fileArr_ret
				for(File fileName:fileArr){
					long filetime = fileName.lastModified();//返回文件最后修改时间，是以个long型毫秒数
					//System.out.println(fileName.getName()+"	文件最后修改时间" + filetime);
					SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); 
					 try {  
			                String str=sdf.format(filetime);  
			                Date temp=sdf.parse(str); 
			                Date date_18=sdf_date.parse(str_date); 
			                
			               //如果文件最后修改时间在18年之前就添加到fileArr_ret list数组里面
			               if(date_18.after(temp)){
			            	   fileArr_ret.add(fileName);
			            	   System.out.println(fileName.getName()+"	is need Zip");
			                }
			            } catch (ParseException e) {  
			                e.printStackTrace();  
			            }  
				}
				//返回true 让继续遍历子文件夹
				return true;
				
			}
			else{
				 System.out.println("flag====false");
				//flag==false 代表目录下的文件夹都满足情况，查看目录下是否所有的文件满足
				//目录下文件都是17年之前的 将上级目录放到要打包的文件夹List folderArr_ret
				if(fileArr!=null&&fileArr.size()>0)
				{
					for(File fileName:fileArr){
						long filetime = fileName.lastModified();//返回文件最后修改时间，是以个long型毫秒数
						
						SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); 
						 try {  
				                String str=sdf.format(filetime);  
				                Date temp=sdf.parse(str); 
				                Date date_18=sdf_date.parse(str_date); 
				                
				                
				               if(temp.after(date_18)){
									//出现18年的文件  不能将上级目录作为返回值
									//将当前目录下的文件是18年之前的文件加入到需要打包的文件List fileArr_ret
									for(File fileName_2:fileArr){
										long filetime_2 = fileName_2.lastModified();//返回文件最后修改时间，是以个long型毫秒数
										//System.out.println(fileName_2.getName()+"	文件最后修改时间" + filetime);
										
										SimpleDateFormat sdf2=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); 
										 try {  
								                String str2=sdf2.format(filetime_2);  
								                Date temp2=sdf2.parse(str2); 
								               if(date_18.after(temp2)){
								            	   fileArr_ret.add(fileName);
								                }
								            } catch (ParseException e) {  
								                e.printStackTrace();  
								            } 
									}
									//返回true 让继续遍历子文件夹
									return true;
				                }
				            } catch (ParseException e) {  
				                e.printStackTrace();  
				            } 
						 
					}
					//目录下文件夹都满足条件，文件都满足条件，将上级目录加入到folderArr_ret
					folderArr_ret.add(rootFile);
					return false;
				}
				else{
					//目录下文件夹都满足条件，文件都满足条件，将上级目录加入到folderArr_ret
					//这种情况是文件夹都满足 目录下没有文件
					if(folderArr.size()>0)
						folderArr_ret.add(rootFile);
					return false;
				}
				
			}
			
		}else {
			System.err.println(root_path+"is not exit");
		}
		return false;
	}
	
	public static void exit18yearfile(List<File> folderList){
		
		System.err.println("exit18yearfile  staring   "+folderList);
		for(File folder:folderList){
			if(folder.isFile()){
			
				long filetime = folder.lastModified();//返回文件最后修改时间，是以个long型毫秒数
				SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); 
				 try {  
		                String str=sdf.format(filetime);  
		                Date temp=sdf.parse(str);       
		                Date date_18=sdf_date.parse(str_date); 
		            	
		                //如果文件是18年之后的 则世界返回true
		               if(temp.after(date_18)){
		            	   flag_finish=true;
		            	   System.err.println(folder.getAbsolutePath()+"	exit 18 fileOrfolder");
		                }
		            } catch (ParseException e) {  
		                e.printStackTrace();  
		            }  
			}
		}
		
		//父目录没有18年之后的   遍历子文件夹
		List<File> folderList2= new ArrayList<File>();
		for(File folder:folderList){
			if(folder.isDirectory()){
			
				File[] folders=folder.listFiles();
				for(File fileName:folders){
					folderList2.add(fileName);
				}
			}
		}
		//如果存在满足17年之前的文件夹
		if(folderList2!=null&&folderList2.size()>0){
			exit18yearfile(folderList2);
		}	
	}
	
	//test use
	public static void main(String[] args) {
		new qualifiedFileAndFolder("C:/Users/CSS/Desktop/Test_Zip");
	}
	
}

2.对文件夹或者文件进行压缩 copy他人的

package com.css.filezip;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

import com.css.file.fileTimeInfo;
/**
 * ZipUtils
 * @author 	ZENG.XIAO.YAN
 * @date 	2017年11月19日 下午7:16:08
 * @version v1.0
 */
public class ZipUtils {
	
	public static String root_path="C:/Users/CSS/Desktop/Test_Zip";
	private static final int  BUFFER_SIZE = 2 * 1024;
	
	/**
	 * 压缩成ZIP 方法1
	 * @param srcDir 压缩文件夹路径 
	 * @param out    压缩文件输出流
	 * @param KeepDirStructure  是否保留原来的目录结构,true:保留目录结构; 
	 * 							false:所有文件跑到压缩包根目录下(注意：不保留目录结构可能会出现同名文件,会压缩失败)
	 * @throws RuntimeException 压缩失败会抛出运行时异常
	 */
	public static void toZip(String srcDir, OutputStream out, boolean KeepDirStructure)
			throws RuntimeException{
		
		long start = System.currentTimeMillis();
		ZipOutputStream zos = null ;
		try {
			zos = new ZipOutputStream(out);
			File sourceFile = new File(srcDir);
			compress(sourceFile,zos,sourceFile.getName(),KeepDirStructure);
			long end = System.currentTimeMillis();
			System.out.println("压缩完成，耗时：" + (end - start) +" ms");
		} catch (Exception e) {
			throw new RuntimeException("zip error from ZipUtils",e);
		}finally{
			if(zos != null){
				try {
					zos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		
	}
	
	/**
	 * 压缩成ZIP 方法2
	 * @param srcFiles 需要压缩的文件列表
	 * @param out 	        压缩文件输出流
	 * @throws RuntimeException 压缩失败会抛出运行时异常
	 */
	public static void toZip(List<File> srcFiles , OutputStream out)throws RuntimeException {
		long start = System.currentTimeMillis();
		ZipOutputStream zos = null ;
		try {
			zos = new ZipOutputStream(out);
			for (File srcFile : srcFiles) {
				byte[] buf = new byte[BUFFER_SIZE];
				zos.putNextEntry(new ZipEntry(srcFile.getName()));
				int len;
				FileInputStream in = new FileInputStream(srcFile);
				while ((len = in.read(buf)) != -1){
					zos.write(buf, 0, len);
				}
				zos.closeEntry();
				in.close();
			}
			long end = System.currentTimeMillis();
			System.out.println("压缩完成，耗时：" + (end - start) +" ms");
		} catch (Exception e) {
			throw new RuntimeException("zip error from ZipUtils",e);
		}finally{
			if(zos != null){
				try {
					zos.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
	
	
	/**
	 * 递归压缩方法
	 * @param sourceFile 源文件
	 * @param zos		 zip输出流
	 * @param name		 压缩后的名称
	 * @param KeepDirStructure  是否保留原来的目录结构,true:保留目录结构; 
	 * 							false:所有文件跑到压缩包根目录下(注意：不保留目录结构可能会出现同名文件,会压缩失败)
	 * @throws Exception
	 */
	private static void compress(File sourceFile, ZipOutputStream zos, String name,
			boolean KeepDirStructure) throws Exception{
		byte[] buf = new byte[BUFFER_SIZE];
		if(sourceFile.isFile()){
			// 向zip输出流中添加一个zip实体，构造器中name为zip实体的文件的名字
			zos.putNextEntry(new ZipEntry(name));
			// copy文件到zip输出流中
			int len;
			FileInputStream in = new FileInputStream(sourceFile);
			while ((len = in.read(buf)) != -1){
				zos.write(buf, 0, len);
			}
			// Complete the entry
			zos.closeEntry();
			in.close();
		} else {
			File[] listFiles = sourceFile.listFiles();
			if(listFiles == null || listFiles.length == 0){
				// 需要保留原来的文件结构时,需要对空文件夹进行处理
				if(KeepDirStructure){
					// 空文件夹的处理
					zos.putNextEntry(new ZipEntry(name + "/"));
					// 没有文件，不需要文件的copy
					zos.closeEntry();
				}
				
			}else {
				for (File file : listFiles) {
					// 判断是否需要保留原来的文件结构
					if (KeepDirStructure) {
						// 注意：file.getName()前面需要带上父文件夹的名字加一斜杠,
						// 不然最后压缩包中就不能保留原来的文件结构,即：所有文件都跑到压缩包根目录下了
						compress(file, zos, name + "/" + file.getName(),KeepDirStructure);
					} else {
						compress(file, zos, file.getName(),KeepDirStructure);
					}
					
				}
			}
		}
	}
	
		public static void main(String[] args) throws Exception {
			
			/** 测试压缩方法1  */
			FileOutputStream fos1 = new FileOutputStream(new File("C:/Users/CSS/Desktop/analyze_css.zip"));
			ZipUtils.toZip("C:/Users/CSS/Desktop/SysLog", fos1,true);
			
			/** 测试压缩方法2  */
			List<File> fileList = new ArrayList<>();
			fileList.add(new File("C:/Users/CSS/Desktop/Test_Zip/css2/1.txt"));
			fileList.add(new File("C:/Users/CSS/Desktop/NAT日志最新需求和实现描述.docx"));
			FileOutputStream fos2 = new FileOutputStream(new File("C:/Users/CSS/Desktop/analyze_css.zip"));
			ZipUtils.toZip(fileList, fos2);
			
			
		}
		
}