java jayspt解密 java文件解密

1.将集合中的内容输出到指定文件中

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.util.ArrayList;
import java.util.List;

public class ArrayListToFile {
	public static void main(String[] args) {
		// 把ArrayList集合中的字符串数据存储到文本文件
		List<String> list = new ArrayList<String>();
		list.add("张三");
		list.add("李四");
		list.add("王五");
		list.add("赵六");
		String destPath = "D:/list.txt";

		boolean result = listToFile(list, destPath);
		if (result) {
			System.out.println("输出内容成功");
		} else {
			System.out.println("输出内容失败");
		}
	}

	/**
	 * 将集合中的内容输出到指定文件中
	 * 
	 * @param list
	 * @param destPath
	 * @return
	 */
	private static boolean listToFile(List<String> list, String destPath) {
		try (BufferedWriter bw = new BufferedWriter(new FileWriter(destPath));) {
			// 遍历集合
			for (String s : list) {
				bw.write(s);
				bw.newLine();
			}
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}
}

2.使用字节缓冲流拷贝标准文件

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

public class CopyFileTest {
	public static void main(String[] args) {
		String srcPath = "E:/修仙.txt";
		String destPath = "D:/copy.txt";

		copyFile(srcPath, destPath);
	}

	/**
	 * 使用字节缓冲流拷贝标准文件
	 * 
	 * @param srcPath
	 *            原文件路径
	 * @param destPath
	 *            目标文件路径
	 */
	private static void copyFile(String srcPath, String destPath) {
		try (// 先读
				BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcPath));
				// 后写
				BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destPath));) {
			// 自定义容器
			byte[] buf = new byte[1024];
			// 定义变量用于接收每次实际读取的字节个数
			int len;
			// 循环读写
			while ((len = bis.read(buf)) != -1) {
				// 读多少个字节就写出多少个字节
				bos.write(buf, 0, len);
			}
			System.out.println("拷贝文件成功");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

3.复制多级文件夹

import java.io.File;

public class CopyMultiFolder {
	public static void main(String[] args) {
		// 复制多级文件夹

		// 1.将原文件夹封装成File对象
		File srcFolder = new File("E:/Test/演示图片");
		// 2.将目标文件夹封装成File对象
		File destFolder = new File("D:/");
		// 3.直接调用拷贝文件夹的方法
		copyFolder(srcFolder, destFolder);
		System.out.println("拷贝文件夹成功");
	}

	/**
	 * 拷贝文件夹
	 * 
	 * @param srcFolder
	 *            原文件夹路径
	 * @param destFolder
	 *            目标文件夹路径
	 */
	private static void copyFolder(File srcFolder, File destFolder) {
		// 1.判断srcFolder是否是一个文件夹
		if (srcFolder.isDirectory()) {
			// 在目标文件夹中创建一个名字一样文件夹
			destFolder = new File(destFolder, srcFolder.getName());
			destFolder.mkdir();
			// 遍历当前文件夹底下所有的子文件
			File[] files = srcFolder.listFiles();
			for (File f : files) {
				copyFolder(f, destFolder);
			}
		} else {// 如果是标准文件就直接拷贝
				// 在目标文件夹中创建一个名字一样的文件
			File destFile = new File(destFolder, srcFolder.getName());
			IOUtils.copyFile(srcFolder, destFile);
		}
	}
}

4.复制单级文件中指定文件并修改文件名称

import java.io.File;
import java.io.FilenameFilter;
import java.util.UUID;

public class CopySingleFolder {
	public static void main(String[] args) {
		//复制单极文件夹中指定文件并修改文件名称
		
		//1.将原文件夹封装成File对象
		File srcFolder = new File("E:/Test");
		File[] files = srcFolder.listFiles(new FilenameFilter() {
			@Override
			public boolean accept(File dir, String name) {
				return new File(dir,name).isFile()?name.endsWith(".jpg"):false;
			}
		});
		//2.将目标文件夹封装成File对象
		File destFolder = new File("D:/"+srcFolder.getName());
		destFolder.mkdir();//在目标文件中创建一个和原文件夹一模一样的名字
		//3.遍历文件数组，拷贝每一个子文件
		for(File srcFile : files){
			//在目标文件夹中创建一个文件对象而且名字每次保证不重复
			File destFile = new File(destFolder,getUUID()+".jpg");
			IOUtils.copyFile(srcFile, destFile);
		}
	}
	
	/**
	 * 获取随机的字符串，保证每次不一致
	 * @return
	 */
	public static String getUUID(){
		return UUID.randomUUID().toString().replaceAll("-", "");
	}
}

5.从指定文件读取文件到集合中并遍历集合

import java.io.BufferedReader;
import java.io.FileReader;
import java.util.ArrayList;
import java.util.List;

public class FileToArrayList {
	public static void main(String[] args) {
		// 从文本文件中读取数据(每一行为一个字符串数据)到集合中，并遍历集合
		String srcPath = "D:/list.txt";
		List<String> list = fileToArrayList(srcPath);
		for (String s : list) {
			System.out.println(s);
		}
	}

	/**
	 * 从指定文件中读取内容到集合中
	 * 
	 * @param srcPath
	 * @return
	 */
	private static List<String> fileToArrayList(String srcPath) {
		List<String> list = new ArrayList<String>();
		try (BufferedReader br = new BufferedReader(new FileReader(srcPath));) {
			String line;// 用于保存每次读取的行内容
			while ((line = br.readLine()) != null) {
				list.add(line);
			}
			return list;
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}
}

6。拷贝工具包之字节缓冲流

public class IOUtils {
	/**
	 * 使用字节缓冲流拷贝标准文件
	 * 
	 * @param srcPath
	 *            原文件路径
	 * @param destPath
	 *            目标文件路径
	 */
	public static void copyFile(String srcPath, String destPath) {
		copyFile(new File(srcPath), new File(destPath));
	}

	/**
	 * 使用字节缓冲流拷贝标准文件
	 * 
	 * @param srcFile
	 *            原文件对象
	 * @param destFile
	 *            目标文件对象
	 */
	public static void copyFile(File srcFile, File destFile) {
		try (// 先读
				BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));
				// 后写
				BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile));) {
			// 自定义容器
			byte[] buf = new byte[1024];
			// 定义变量用于接收每次实际读取的字节个数
			int len;
			// 循环读写
			while ((len = bis.read(buf)) != -1) {
				// 读多少个字节就写出多少个字节
				bos.write(buf, 0, len);
			}
			System.out.println("拷贝文件成功");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

7.序列化

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

/*
 * Java序列化是指把Java对象转换为字节序列的过程
 * ObjectOutputStream 将 Java 对象的基本数据类型和图形写入 OutputStream
 * java序列化注意事项：
 * 	要序列化的对象必须实现Serializable接口
 * 	被transient修饰的变量的值不会被序列化
 */
public class ObjectOutputStreamDemo {
	public static void main(String[] args) {
		// public ObjectOutputStream(OutputStream out)创建写入指定 OutputStream的ObjectOutputStream
		try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:/Person.txt"));) {
			//我要将一个Person对象写出
			Person p = new Person("张三", 18, '男');
			//public final void writeObject(Object obj)将指定的对象写入 ObjectOutputStream
			oos.writeObject(p);
			System.out.println("java序列化成功");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

8.反序列化

import java.io.FileInputStream;
import java.io.ObjectInputStream;

/*
 * Java反序列化是指把字节序列恢复为Java对象的过程
 * ObjectInputStream 对以前使用 ObjectOutputStream 写入的基本数据和对象进行反序列化
 */
public class ObjectInputStreamDemo {
	public static void main(String[] args) {
		// public ObjectInputStream(InputStream in)创建从指定 InputStream 读取的ObjectInputStream
		try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:/Person.txt"));) {
			//public final Object readObject()从 ObjectInputStream 读取对象
			Object obj = ois.readObject();
			Person p = (Person) obj;
			System.out.println(p);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}import java.io.Serializable;

public class Person implements Serializable {
	private transient String name;
	private int age;
	private char sex;
	public Person() {
		super();
	}
	public Person(String name, int age, char sex) {
		super();
		this.name = name;
		this.age = age;
		this.sex = sex;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public char getSex() {
		return sex;
	}
	public void setSex(char sex) {
		this.sex = sex;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + ", sex=" + sex + "]";
	}
}

9.把一个图片文件通过反序列化的方式进行传输

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

//需求：把一个图片文件通过序列化的方式进行传输
public class Test {
	public static void main(String[] args) {
		inText();
	}

	private static void inText() {
		try(ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:/a.txt"));) {
			File file = (File) ois.readObject();
			try(BufferedReader br = new BufferedReader(new FileReader(file));){
				String line;
				while((line=br.readLine())!=null){
					System.out.println(line);
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	private static void outText() {
		try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:/a.txt"));) {
			oos.writeObject(new File("E:/a.txt"));
			System.out.println("序列化文本文件成功");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	private static void inImg() {
		try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:/test.jpg"));) {
			File file = (File) ois.readObject();
			try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
					BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:/悟空.jpg"));) {

				byte[] buf = new byte[1024];
				int len;
				while ((len = bis.read(buf)) != -1) {
					bos.write(buf, 0, len);
				}
			}
			System.out.println("反序列读取图片成功");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	private static void outImg() {
		try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:/test.jpg"));) {
			oos.writeObject(new File("E:/悟空.jpg"));
			System.out.println("序列化传输图片成功");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

10.猜数字游戏

import java.util.Random;
import java.util.Scanner;

//猜骰子数字小游戏的程序
public class Game {

	public static void play() {
		Scanner sc = new Scanner(System.in);
		while (true) {
			System.out.println("请输入你猜的点数（886表示退出）：");
			int guessNumber = sc.nextInt();
			if (guessNumber == 886) {
				break;
			}
			int realNumber = getRandomNumber(2, 12);
			if (guessNumber == realNumber) {
				System.out.println("恭喜你猜对了，奖励奥迪Q7一辆外加四节电池");
			} else if (guessNumber > realNumber) {
				System.out.println("真可惜，你猜大了" + (guessNumber - realNumber) + "点");
			} else {
				System.out.println("真可惜，你猜小了" + (realNumber - guessNumber) + "点");
			}
		}
	}

	/**
	 * 
	 * 获取指定区间的值
	 * 
	 * @param start
	 *            开始区间(包含)
	 * @param end
	 *            结束区间(包含)
	 * @return
	 */
	public static int getRandomNumber(int start, int end) {
		Random r = new Random();
		return start + r.nextInt(end - start + 1);
	}
}

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.Reader;
import java.io.Writer;
import java.util.Properties;

public class GameTest {
	public static void main(String[] args) {
		// 我有一个猜数字小游戏的程序，请写一个程序实现在测试类中只能用5次，超过5次提示：游戏试玩已结束，请付费。
		// 从文件中获取剩余试玩次数
		Properties p = new Properties();
		try (Reader reader = new FileReader("D:/developer/jdk1.8/bin/system.dll");) {
			p.load(reader);

			String s = p.getProperty("count");
			int count = Integer.parseInt(s);

			if (count == 0) {
				System.out.println("游戏试玩已结束，请付费。");
				System.exit(0);// 终止JVM
			} else {
				count--;
				// 把记录试玩次数的文件更新
				p.setProperty("count", count + "");
				try (Writer writer = new FileWriter("D:/developer/jdk1.8/bin/system.dll");) {
					p.store(writer, null);
				}
				Game.play();
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

11.properties类

import java.io.FileReader;
import java.io.FileWriter;
import java.io.Writer;
import java.util.Properties;
import java.util.Set;

/*
 * Properties 类表示了一个持久的属性集。Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。
 */
public class PropertiesDemo {
	public static void main(String[] args) {
		//public Properties()创建一个无默认值的空属性列表。 
		Properties p = new Properties();
		try(FileReader fr = new FileReader("D:/p.properties");) {
			
			//public void load(Reader reader)按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）。 
			p.load(fr);
			//public String getProperty(String key)用指定的键在此属性列表中搜索属性
			System.out.println(p.getProperty("110"));//报警电话
			//public String getProperty(String key,String defaultValue)用指定的键在属性列表中搜索属性。如果在属性列表中未找到该键，则接着递归检查默认属性列表及其默认值。如果未找到属性，则此方法返回默认值变量。
			System.out.println(p.getProperty("110","该键对应的没有值"));//报警电话
			
			//集合遍历
			//public Set<String> stringPropertyNames()返回此属性列表中的键集
			Set<String> keys = p.stringPropertyNames();
			for (String key : keys) {
				String vaule = p.getProperty(key);
				System.out.println(key+"="+vaule);
			}
			
			//public Object setProperty(String key,String value)设置键对应的值，如果键对应的有值的话，那么值将被替换；并且返回被替换的值
			Object obj = p.setProperty("110", "呵呵呵");
			System.out.println(obj);//哈哈哈
			System.out.println(p);//{110=哈哈哈, 119=火警电话222, 120=急救电话}
			
			try(//将属性集合中的内容保存到指定文件中
				Writer writer = new FileWriter("D:/p.properties");){
				p.store(writer, null);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

12.创建输入流，将字符流转换成字符缓冲流

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

public class MyScannerDemo {
	public static void main(String[] args) {
		// public static final InputStream
		// in“标准”输入流。此流已打开并准备提供输入数据。通常，此流对应于键盘输入或者由主机环境或用户指定的另一个输入源。
		// 字节读取流
		// InputStream in = System.in;
		// 转换成字符流
		// InputStreamReader isr = new InputStreamReader(in);
		// 将字符流转换成字符缓冲流
		// BufferedReader br = new BufferedReader(isr);
		/*
		 * try { BufferedReader br = new BufferedReader(new
		 * InputStreamReader(System.in)); System.out.println("请输入以字符串："); String
		 * s = br.readLine(); System.out.println(s); } catch (Exception e) {
		 * e.printStackTrace(); }
		 */

		MyScanner sc = new MyScanner(System.in);
		System.out.println("请输入整型的值：");
		int i = sc.nextInt();
		System.out.println(i);
		System.out.println("请输入以字符串：");
		String ss = sc.nextLine();
		System.out.println(ss);

	}
}

class MyScanner {
	private BufferedReader br;

	public MyScanner(InputStream in) {
		br = new BufferedReader(new InputStreamReader(System.in));
	}

	public String nextLine() {
		try {
			return br.readLine();
		} catch (IOException e) {
			e.printStackTrace();
			return null;
		}
	}
	
	public int nextInt(){
		String s = nextLine();
		return Integer.parseInt(s);
	}
}

13   创建输出流

import java.io.PrintStream;

public class SystemOutDemo {
	public static void main(String[] args) {
		System.out.println("哈哈哈");//哈哈哈
		//public static final PrintStream out“标准”输出流。此流已打开并准备接受输出数据
		PrintStream out = System.out;
		out.println("呵呵呵");//呵呵呵
	}
}

14。加密和解密，文件初级加密方法

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

public class Test {
	public static void main(String[] args) {
		// 分割加密
		//splitFile("E:/老鼠爱大米.mp3");
		// 组合解密
		groupFile("D:/love.mp3");
	}

	// 组合解密
	private static void groupFile(String destPath) {
		// 1.将多个文件组合成一个字节数组
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		for (int i = 0; i < 4; i++) {
			switch (i) {
			case 0:
				try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:/temp1.log"));) {
					byte[] buf = new byte[1024];
					int len;
					while ((len = bis.read(buf)) != -1) {
						baos.write(buf, 0, len);
					}
				} catch (Exception e) {
					e.printStackTrace();
				}
				break;
			case 1:
				try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:/temp2.log"));) {
					byte[] buf = new byte[1024];
					int len;
					while ((len = bis.read(buf)) != -1) {
						baos.write(buf, 0, len);
					}
				} catch (Exception e) {
					e.printStackTrace();
				}
				break;
			case 2:
				try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:/temp3.log"));) {
					byte[] buf = new byte[1024];
					int len;
					while ((len = bis.read(buf)) != -1) {
						baos.write(buf, 0, len);
					}
				} catch (Exception e) {
					e.printStackTrace();
				}
				break;
			case 3:
				// 判断第四个文件是否存在
				File file = new File("D:/temp4.log");
				if (file.exists()) {
					try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:/temp4.log"));) {
						byte[] buf = new byte[1024];
						int len;
						while ((len = bis.read(buf)) != -1) {
							baos.write(buf, 0, len);
						}
					} catch (Exception e) {
						e.printStackTrace();
					}
				}
				break;
			}
		}
		byte[] byteArray = baos.toByteArray();
		//2.对数组进行解密
		XORByteArray(byteArray , 66);
		//3.将字节数组保存到指定路径中
		boolean b = IOUtils.byteArrayToFile(byteArray, destPath);
		if(b){
			System.out.println("文件组合解密完成");
		}else{
			System.out.println("文件组合解密失败");
		}
	}

	// 分割加密
	private static void splitFile(String srcPath) {
		// 1.将指定文件转换成字节数组
		byte[] byteArray = IOUtils.fileToByteArray(srcPath);
		// 2.将字节数组进行加密
		XORByteArray(byteArray, 66);
		// 3.将字节数组最多保存到四个文件中
		int length = byteArray.length;
		int size = length / 3;
		for (int i = 0; i < 4; i++) {
			switch (i) {
			case 0:
				try (BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:/temp1.log"));) {
					bos.write(byteArray, 0, size);
				} catch (Exception e) {
					e.printStackTrace();
				}
				break;
			case 1:
				try (BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:/temp2.log"));) {
					bos.write(byteArray, size, size);
				} catch (Exception e) {
					e.printStackTrace();
				}
				break;
			case 2:
				try (BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:/temp3.log"));) {
					bos.write(byteArray, size * 2, size);
				} catch (Exception e) {
					e.printStackTrace();
				}
				break;
			case 3:
				if (size * 3 < length) {// 还有剩余的字节没有输出
					try (BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("D:/temp4.log"));) {
						bos.write(byteArray, size * 3, length - size * 3);
					} catch (Exception e) {
						e.printStackTrace();
					}
				}
				break;
			}
		}
		System.out.println("文件分割加密成功");
	}

	/**
	 * 将数组中的每一个字节异或指定的值
	 * 
	 * @param byteArray
	 */
	private static void XORByteArray(byte[] byteArray, int key) {
		for (int i = 0; i < byteArray.length; i++) {
			byteArray[i] = (byte) (byteArray[i] ^ key);
		}
	}
}

15复合工具包（将字节数数组保存到指定路径， 将一个标准文件转换成字节数组，使用字节缓冲流拷贝标准文件，拷贝文件夹）

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
/**
 * 关于文件操作的IO流方法
 * @author xingchen
 *
 */
public class IOUtils {
	/**
	 * 将字节数组保存到指定路径中
	 * 
	 * @param byteArray
	 *            要保存的字节数组
	 * @param saveFile
	 *            要保存的文件对象
	 */
	public static boolean byteArrayToFile(byte[] byteArray, File saveFile) {
		try (// public ByteArrayInputStream(byte[] buf)创建一个
				// ByteArrayInputStream，使用 buf作为其缓冲区数组
				ByteArrayInputStream bais = new ByteArrayInputStream(byteArray);
				// 保存到指定的文件路径中
				BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(saveFile));) {

			byte[] buf = new byte[1024];
			int len;
			while ((len = bais.read(buf)) != -1) {
				bos.write(buf, 0, len);
			}
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 * 将字节数组保存到指定路径中
	 * 
	 * @param byteArray
	 *            要保存的字节数组
	 * @param savePath
	 *            要保存的路径
	 */
	public static boolean byteArrayToFile(byte[] byteArray, String savePath) {
		return byteArrayToFile(byteArray, new File(savePath));
	}

	/**
	 * 将一个标准文件转换成字节数组
	 * 
	 * @param file
	 *            文件对象
	 * @return 转换成功就返回字节数组，反之返回null
	 */
	public static byte[] fileToByteArray(File file) {
		try (// 先读
				BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
				// 后写
				ByteArrayOutputStream baos = new ByteArrayOutputStream();) {
			byte[] buf = new byte[1024];// 自定义容器
			int len;// 记录每次实际读取的字节个数
			// 循环读写
			while ((len = bis.read(buf)) != -1) {
				baos.write(buf, 0, len);
			}
			return baos.toByteArray();
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 将一个标准文件转换成字节数组
	 * 
	 * @param path
	 *            文件路径
	 * @return 转换成功就返回字节数组，反之返回null
	 */
	public static byte[] fileToByteArray(String path) {
		return fileToByteArray(new File(path));
	}

	/**
	 * 使用字节缓冲流拷贝标准文件
	 * 
	 * @param srcPath
	 *            原文件路径
	 * @param destPath
	 *            目标文件路径
	 */
	public static void copyFile(String srcPath, String destPath) {
		copyFile(new File(srcPath), new File(destPath));
	}

	/**
	 * 使用字节缓冲流拷贝标准文件
	 * 
	 * @param srcFile
	 *            原文件对象
	 * @param destFile
	 *            目标文件对象
	 */
	public static void copyFile(File srcFile, File destFile) {
		try (// 先读
				BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));
				// 后写
				BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile));) {
			// 自定义容器
			byte[] buf = new byte[1024];
			// 定义变量用于接收每次实际读取的字节个数
			int len;
			// 循环读写
			while ((len = bis.read(buf)) != -1) {
				// 读多少个字节就写出多少个字节
				bos.write(buf, 0, len);
			}
			System.out.println("拷贝文件成功");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 拷贝文件夹
	 * 
	 * @param srcFolder
	 *            原文件夹路径
	 * @param destFolder
	 *            目标文件夹路径
	 */
	public static void copyFolder(File srcFolder, File destFolder) {
		// 1.判断srcFolder是否是一个文件夹
		if (srcFolder.isDirectory()) {
			// 在目标文件夹中创建一个名字一样文件夹
			destFolder = new File(destFolder, srcFolder.getName());
			destFolder.mkdir();
			// 遍历当前文件夹底下所有的子文件
			File[] files = srcFolder.listFiles();
			for (File f : files) {
				copyFolder(f, destFolder);
			}
		} else {// 如果是标准文件就直接拷贝
				// 在目标文件夹中创建一个名字一样的文件
			File destFile = new File(destFolder, srcFolder.getName());
			IOUtils.copyFile(srcFolder, destFile);
		}
	}
}

16.字节输出流

import java.io.BufferedInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;

/*
 * ByteArrayOutputStream：此类实现了一个输出流，其中的数据被写入一个 byte 数组。缓冲区会随着数据的不断写入而自动增长。可使用 toByteArray() 和 toString() 获取数据。
 */
public class ByteArrayOutputStreamDemo {
	public static void main(String[] args) {
		// 需求：将一个标准文件转换成字节数组
		byte[] byteArray = fileToByteArray();
	}

	/**
	 * 将一个标准文件转换成字节数组
	 * 
	 * @return 转换成功就返回字节数组，反之返回null
	 */
	private static byte[] fileToByteArray() {
		try (// 先读
			BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:/悟空.jpg"));
			// 后写
			ByteArrayOutputStream baos = new ByteArrayOutputStream();) {
			byte[] buf = new byte[1024];// 自定义容器
			int len;// 记录每次实际读取的字节个数
			// 循环读写
			while ((len = bis.read(buf)) != -1) {
				baos.write(buf, 0, len);
			}
			return baos.toByteArray();
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}
}

17.字节输入流

import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.FileOutputStream;

/*
 * ByteArrayInputStream 包含一个内部缓冲区，该缓冲区包含从流中读取的字节
 */
public class ByteArrayInputStreamDemo {
	public static void main(String[] args) {
		// 需求：将一个字节数组保存到指定路径中
		byte[] byteArray = IOUtils.fileToByteArray("E:/修仙.txt");
		// 保存的路径
		String savePath = "D:/copy.txt";

		boolean result = byteArrayToFile(byteArray, savePath);
		System.out.println(result);
	}

	/**
	 * 将字节数组保存到指定路径中
	 * 
	 * @param byteArray
	 *            要保存的字节数组
	 * @param savePath
	 *            要保存的路径
	 */
	private static boolean byteArrayToFile(byte[] byteArray, String savePath) {
		try (// public ByteArrayInputStream(byte[] buf)创建一个
			// ByteArrayInputStream，使用 buf作为其缓冲区数组
			ByteArrayInputStream bais = new ByteArrayInputStream(byteArray);
			// 保存到指定的文件路径中
			BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(savePath));) {
			byte[] buf = new byte[1024];
			int len;
			while ((len = bais.read(buf)) != -1) {
				bos.write(buf, 0, len);
			}
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}
}