IO操作

Java对数据的操作都是通过流的方式，IO流用来处理设备之间的数据传输，文件上传和文件下载，Java用于操作流的对象都在IO包，NIO(New IO)包中。

创建文件

Java创建文件的方式有三种方式，我们接下来一个一个来介绍。

File.createFile()
java.io.file能够创建新的文件。创建一个File对象后，可以通过File对象的createNewFile方法创建文件,如果创建成功就返回true，如果创建失败就返回false。创建成功的文件是一个空文件，创建失败会抛出IO异常。创建File对象时是需要传入文件文件目录和名称，可以是绝对路径也可以是相对路径(相对当前工程的根目录内，和src同级别).
```
public class CreateFile {

	public static void main(String[] args) {
		// 方法一：File.createFile()
		File file= new File("./file.txt");

		try {
			boolean success = file.createNewFile();
			if (success) {
				System.out.println("Cretea File Success");
			} else {
				System.out.println("Cretea File Fail");
			}

		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}
```

FileOutputStream.write(byte[] b)

当创建文件是还想加入一些数据在文件中去，就可以使用FileOutputStream.write这个方法。代码如下

public class CreateFile {

	public static void main(String[] args) {

		String data = "Hello world!";
		try {
			FileOutputStream outputStream = new FileOutputStream("./Hello.txt"); // 创建文件
			outputStream.write(data.getBytes()); // 写入数据
			outputStream.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}
}

**NIO Files.write(Path path, byte[] bytes, OpenOption… options) **
NIO就是New IO 的意思，是一个可以替代标准Java IO API的API，提供的和标准IO 不同的工作方式。链接, 这里只做简单的介绍，会用专门的章节进行介绍。
第一个参数Path表示的是一个路径，可以指向一个路径或者一个文件夹，也可以是绝对路径和相对路径。例如 Paths.get("/Users/Johnny/Documents/hello.txt") 使用的就是一个绝对路径，Paths.get("/Users/Johnny", "Documents", "hello.txt") 使用的就是一个相对路径，相对路径把所有路径用目录分隔符拼接在一起。
第二个参数是写入的数据。
第三个参数是打开的方式，OpenOption是一个接口，NIO提供了一个StandardOpenOption枚举类，有READ, WRITE, APPEND, CREATE等。

public class CreateFile {

	public static void main(String[] args) {

		String data = "Hello world!";
		try {
			Files.write(Paths.get("./Hello"), data.getBytes(), StandardOpenOption.CREATE);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

删除文件

上面我们学习了如何创建文件，接下来我们学习如何删除文件和文件夹。

删除文件和空目录File.delelte()

如果删除成功则返回true，文件或者空目录不存在就会返回false。

File file = new File("./test2");
if (file.delete()) {
	System.out.println("删除成功");
} else {
	System.out.println("删除失败");
}

如果不是空目录需要遍历目录中的文件，删除文件，再删除目录

如果不是空文件需要把目录里面的文件先删除掉，然后再删除空的目录

File dir = new File("./test");

if (!dir.isDirectory()) {
	System.out.println("不是文件夹");
} else {

File[] files = dir.listFiles();

for (File file: files) {
	System.out.println(file.getName());
	file.delete();
}

System.out.println("删除文件夹"+ dir.delete());
}

如果目录中有目录，目录中还有目录，多层级，就可以用NIO包中的 Files.walkFileTree(Path start, FileVisitor<? super Path> visitor) 循环遍历，逐个删除

第一个参数是路径。

第二个参数是一个接口，接口定义了四个方法用来指定当你访问一个节点之前、之中、之后、失败时应该采取什么行为。

public interface FileVisitor<T> {

    FileVisitResult preVisitDirectory(T dir, BasicFileAttributes attrs) // 访问一个目录前要干啥
        throws IOException;

    FileVisitResult postVisitDirectory(T dir, IOException exc) // 访问一个目录后要干啥
            throws IOException;

    FileVisitResult visitFile(T file, BasicFileAttributes attrs) // 正在访问一个文件时要干啥
        throws IOException;

    FileVisitResult visitFileFailed(T file, IOException exc) // 访问一个文件失败时要干啥
        throws IOException;
}

接口返回的是一个FileVisitResult枚举，分别是

CONTINUE：继续遍历

SKIP_SIBLINGS：继续遍历，但忽略当前节点的所有兄弟节点直接返回上一层继续遍历

SKIP_SUBTREE：继续遍历，但是忽略子目录，但是子文件还是会访问；

TERMINATE：终止遍历

遍历删除的代码如下：

	public static void main(String[] args) {


		Path path = Paths.get("./test");

		try {
			Files.walkFileTree(path, new SimpleFileVisitor<Path>(){
				@Override
				public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
					Files.delete(file); // 删除文件
					return FileVisitResult.CONTINUE; //继续遍历
				}

				@Override
				public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
					Files.delete(dir); //删除目录
					return FileVisitResult.CONTINUE; // 继续遍历
				}

				@Override
				public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
					// TODO Auto-generated method stub
					return super.preVisitDirectory(dir, attrs);
				}

				@Override
				public FileVisitResult visitFileFailed(Path file, IOException exc) throws IOException {
					// TODO Auto-generated method stub
					return super.visitFileFailed(file, exc);
				}

			});
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

分割符

文件分隔符(File.separator)：Windows 系统为 \, unix为/；
文件分隔符(File.separatorChar)：同上；
文件路径分割符(File.pathSeparator)：Windows 系统为 ;, unix为:；主要用于PATH，CLASSPATH等系统变量。
文件路径分割符(File.pathSeparatorChar)：同上；

为了让代码不依赖系统，一般路径应该使用文件分隔符。

Path path = Paths.get("./test"); // 只适应于Unix系统
Path path = Paths.get(".\test"); // 只适应于windows系统
Path path = Paths.get("."+File.separator+"test"); // 不依赖于系统

重命名文件(移动文件)

可以用File.renameTo去重命名或者移动文件. Unix 系统中如果目标文件存在，则会用源文件覆盖目标文件。

public static void main(String[] args) {

	File sourceFile = new File("."+File.separator+"Source.txt");
	File desFile = new File("." + File.separator + "Des.txt");

	if (sourceFile.renameTo(desFile)) { // 必须判断是否成功，因为这个方法不会抛出异常
		System.out.println("重命名成功");
	} else {
		System.out.println("重命名失败");
	}

}

获取文件大小

IO包中的File.Length

可以用IO包中文件的length方法获取文件大小，计算的得到的结果单位是byte，需要注意的是确保不是目录和不存在的文件。

File file = new File("." + File.separator + "test.txt");
System.out.println(file.length());

if (!file.exists() || file.isDirectory()) {
	System.out.println("不是文件，计算的长度不正确");
}

NIO包中的FileChannel.size()

Path path = Paths.get("."+File.separator+"file.txt");

FileChannel fileChannel;

try {
	fileChannel = FileChannel.open(path, StandardOpenOption.READ); // 打开
	long fileSize = fileChannel.size();
	System.out.println(fileSize + "bytes");
	fileChannel.close();
} catch (IOException e) {
	e.printStackTrace();
}

获取文件扩展名

有时候需要根据不同的文件类型做不同的操作，我们可以通过文件名来获得文件的扩展名。

private static String getFileName(File file) {
	String fileName = file.getName();
	if (fileName.lastIndexOf(".") != -1 && fileName.lastIndexOf(".") != 0) { // 如果有(.)且(.)不在第一个字符即不是隐藏文件
		return fileName.substring(fileName.lastIndexOf(".") + 1);
	}
	return null;
}

文件的创建时间、最后更改时间、最后访问时间

修改时间

File file = new File("." + File.separator + "file.txt");

long createTime = file.lastModified(); // 最后的修改时间戳--距离1970年一月一日的毫秒数,如果文件不存在则返回0

Calendar calendar = Calendar.getInstance(); // 由于Calendar是一个抽象类，不能用new实例化对象，getInstance获得了一个子类。https://www.cnblogs.com/huangminwen/p/6041168.html

calendar.setTimeInMillis(createTime); // 根据毫秒数得到时间,

SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); //时间格式化

System.out.println(formatter.format(calendar.getTime())); //2018-09-30 10:57:29

Java7提供了Files.getFileAttributeView(可以获得最后修改时间，创建时间，文件大小，是否为目录等等)

private static String createTime(String fileName) {
	// 获取将要操作的文件
	Path path = Paths.get(fileName);

	// 获取访问基本属性的BasicFileAttributeView
	// 两个参数：1，文件 2，指明一个类，BasicFileAttributeView是指访问文件的一些基本信息
	BasicFileAttributeView attributeView = Files.getFileAttributeView(path, BasicFileAttributeView.class);

	BasicFileAttributes attributes;

	Calendar calendar = Calendar.getInstance();

	try {
		attributes = attributeView.readAttributes(); // 获取信息
		calendar.setTimeInMillis(attributes.creationTime().toMillis()); // 创建时间

	} catch (IOException e) {
		e.printStackTrace();
		calendar.setTimeInMillis(0);
	}

	SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

	return dateFormat.format(calendar.getTime());
}

getPath()、getAbsolutePath()、getCanonical()

getPath()返回定义时的路径，（就是你写什么路径，他就返回什么路径）
getAbsolutePath()返回绝对路径，但不会处理“.”和“…”的情况
getCanonicalPath()返回的是规范化的绝对路径，相当于将getAbsolutePath()中的“.”和“…”解析成对应的正确的路径

File file = new File("." + File.separator + "file.txt");

System.out.println(file.getPath()); // ./file.txt

System.out.println(file.getAbsolutePath()); // /Users/Johnny/Documents/./file.txt


try {
	System.out.println(file.getCanonicalPath()); // /Users/Johnny/Documents/file.txt
} catch (IOException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
}

设置文件权限PosixFilePermission

java7以上用这种方法，可读性也非常强。

Set<PosixFilePermission> perms = new HashSet<PosixFilePermission>();
// 添加用户权限
perms.add(PosixFilePermission.OWNER_READ);
perms.add(PosixFilePermission.OWNER_WRITE);
perms.add(PosixFilePermission.OTHERS_EXECUTE);
//添加群权限
perms.add(PosixFilePermission.GROUP_READ);
perms.add(PosixFilePermission.GROUP_WRITE);
perms.add(PosixFilePermission.GROUP_EXECUTE);
// 添加其他人员的权限
perms.add(PosixFilePermission.OTHERS_READ);
perms.add(PosixFilePermission.OTHERS_WRITE);
perms.add(PosixFilePermission.OTHERS_EXECUTE);

try {
	Files.setPosixFilePermissions(Paths.get("." + File.separator + "file.txt"), perms);
} catch (IOException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
}

复制文件

Stream的方式：创建一个源文件和一个目标文件，从源文件建立一个输入流，用输出流写入目标文件

private static void copyFileUsingStream(File source, File dest) {

	FileInputStream fileInputStream = null;
	FileOutputStream fileOutputStream = null;

	try {
		fileInputStream = new FileInputStream(source);
		fileOutputStream = new FileOutputStream(dest);
		//定义一个字节数组,相当于缓存
		byte[] buffer = new byte[1024];

		int length;
		//循环读取
		while ((length = fileInputStream.read(buffer)) != -1) { //把fileInputStream里的东西读到bytes数组里去
			fileOutputStream.write(buffer, 0, length); 	// 把字节写入文件中
		}
	} catch (IOException e) {
		e.printStackTrace();
	} finally {
		//一定要关闭文件流, 并且关闭文件流必须放在finally里面
		try {
			fileInputStream.close();
			fileOutputStream.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

NIO 的 FileChannel 的 transform()

private static void copyFileUsingFileChannel(File source, File dest) {

	FileChannel sourceChannel = null;
	FileChannel desChannel = null;

	try {
		sourceChannel = new FileInputStream(source).getChannel();
		desChannel = new FileOutputStream(dest).getChannel();

		desChannel.transferFrom(sourceChannel, 0, source.length());

	} catch (IOException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	} finally {
		try {
			sourceChannel.close();
			desChannel.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}

Files的copy方法 – Java7 以上可以用，它使用FileSystemProvider来复制文件

try {
	Files.copy(source.toPath(), dest.toPath());
} catch (IOException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
}

读取文本内容

java.nio.file.Files

Files能够把内容读取出来变成一个byte数组，也可以把所有的行变成变成字符串数组。这些方法适合于把不是太大的文件读入内存中。

Path path = Paths.get("." + File.separator + "source.txt");

try {
	//Java7 读取所有的内容，默认以UTF-8编码读入文件，故文件的编码如果不是UTF-8，那么中文内容会出现乱字符
	byte[] bytes = Files.readAllBytes(path);
	System.out.println(new String(bytes));

	// Java8
	List<String> lists = Files.readAllLines(path);
	System.out.println(lists); // [string1, string2, ...]

} catch (IOException e) {
	e.printStackTrace();
}

java.io.FileReader

可以通过FileReader获得BufferedReader，然后一行一行的读取文件。

File file = new File("." + File.separator + "source.txt");

try {
	FileReader reader = new FileReader(file);
	BufferedReader bufferedReader = new BufferedReader(reader);

	String line;
	while ((line = bufferedReader.readLine()) != null) {
		System.out.println(line);
	}

} catch (IOException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
}

java.io.BufferedReader

BufferedReader适合于大文件，且是线程安全的特点，默认的缓存大小是8KB。

File file = new File("." + File.separator + "source.txt");

BufferedReader bufferedReader = null;
try {
	FileInputStream inputStream = new FileInputStream(file);
	InputStreamReader reader = new InputStreamReader(inputStream);
	bufferedReader = new BufferedReader(reader);

	String line;
	while((line = bufferedReader.readLine()) != null){
		//process the line
		System.out.println(line);
	}

} catch (IOException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
} finally {
	try {
		bufferedReader.close(); // 关闭流
	} catch (IOException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
}

Files.BufferedReader

try {
	BufferedReader bufferedReader = Files.newBufferedReader(Paths.get("." + File.separator + "source.txt"));

	String line;

	while ((line = bufferedReader.readLine()) != null) {
		System.out.println(line);
	}

} catch (IOException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
}

Scanner

Path path = Paths.get("." + File.separator + "source.txt");

try {
	Scanner scanner = new Scanner(path);
	while (scanner.hasNextLine()) {
		String line = scanner.nextLine();
		System.out.println(line);
	}
	scanner.close();
} catch (IOException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
}

打开文件(DeskTop)

java.awt.Desktop这个类能打开文件，但是调用之前需要判断是否支持java.awt.Desktop.

File sourceFile = new File("."+File.separator+"source.txt");

if (!Desktop.isDesktopSupported()) {
    System.out.println("Desktop is not supported");
    return;
}

Desktop desktop = Desktop.getDesktop();

try {
	desktop.open(sourceFile); // 打开文件
} catch (IOException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
}

读取文本文件成为字符串

BufferedReader

String pathname = "." + File.separator + "source.txt";

try {
	FileReader fileReader = new FileReader(new File(pathname));
	BufferedReader bufferedReader = new BufferedReader(fileReader); // bufferreader
	StringBuilder stringBuilder = new StringBuilder();
	String line = null;
	String ls = System.getProperty("line.separator"); // 换行符

	while ((line = bufferedReader.readLine()) != null) { // 读取的每行的数据
		stringBuilder.append(line); // 写入数据
		stringBuilder.append(ls);   // 写入换行符
	}
	stringBuilder.deleteCharAt(stringBuilder.length()-1); // 删除最后一个换行符

	bufferedReader.close(); // 关流

	String content = stringBuilder.toString(); // 字符

} catch (IOException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
}

FileInputStream

String pathname = "." + File.separator + "source.txt";

try {
	FileInputStream inputStream = new FileInputStream(new File(pathname));

	byte[] bytes = new byte[10];
	StringBuffer stringBuffer = new StringBuffer();

	while (inputStream.read(bytes) != -1) {
		stringBuffer.append(new String(bytes));
		bytes = new byte[10];
	}

	inputStream.close();

	String content = stringBuffer.toString();

} catch (IOException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
}

Files

String content = new String(Files.readAllBytes(Paths.get(fileName)));

写文件(会覆盖原有内容)

FileWriter

File file = new File("." + File.separator + "des.txt");

String data = "Writed Data using FileWriter";

FileWriter fw = null;
try {
	fw = new FileWriter(file);
	fw.write(data);

} catch (IOException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
} finally {
	try {
		fw.close();
	} catch (IOException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
}

BufferedWriter

File file = new File("." + File.separator + "des.txt");

String data = "Write using bufferwriter";

FileWriter fWriter = null;
BufferedWriter bWriter = null;

try {
	fWriter = new FileWriter(file);
	bWriter = new BufferedWriter(fWriter);

	bWriter.write(data);

} catch (IOException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
} finally {

	try {
		bWriter.close();
		fWriter.close();
	} catch (IOException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}

}

FileOutputStream

File file = new File("." + File.separator + "des.txt");
String data = "Write using outputstream";
FileOutputStream outputStream = null;
try {
	outputStream = new FileOutputStream(file);
	outputStream.write(data.getBytes(), 0, data.length());
} catch (IOException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
} finally {
	try {
		outputStream.close();
	} catch (IOException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
}

Files

String data = "Write using Files";

try {
	Files.write(Paths.get("." + File.separator + "des.txt"), data.getBytes());
} catch (IOException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
}

给文件增加内容

FileWriter

File file = new File("." + File.separator + "append.txt");

FileWriter fr = null;
try {
	fr = new FileWriter(file, true); // 第二个参数就是是否是增加
	fr.write(System.getProperty("line.separator") + "Append String using file writer");
} catch (IOException e) {
	e.printStackTrace();
} finally {
	try {
		fr.close();
	} catch (IOException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
}

BufferedWriter

File file = new File("." + File.separator + "append.txt");

String data = System.getProperty("line.separator") + "Append using bufferwriter";

FileWriter fWriter = null;
BufferedWriter bWriter = null;

try {
	fWriter = new FileWriter(file, true);
	bWriter = new BufferedWriter(fWriter);

	bWriter.write(data);

} catch (IOException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
} finally {

	try {
		bWriter.close();
		fWriter.close();
	} catch (IOException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}

}

FileOutputStream

File file = new File("." + File.separator + "append.txt");
String data = System.getProperty("line.separator") + "Append using outputstream";
FileOutputStream outputStream = null;
try {
    outputStream = new FileOutputStream(file, true);  // 第二个参数就是是否是增加
    outputStream.write(data.getBytes(), 0, data.length());
} catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
} finally {
    try {
        outputStream.close();
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}

PrintWriter

File file = new File("." + File.separator + "append.txt");
FileWriter fr = new FileWriter(file, true);
BufferedWriter br = new BufferedWriter(fr);
PrintWriter pr = new PrintWriter(br);
pr.println(System.getProperty("line.separator") + "Append using printwriter");
pr.close();
br.close();
fr.close();

在文件的指定位置读写(RandomAccessFile)

RandomAccessFile 是随机访问文件(包括读/写)的类,我们可以从指定的位置读取/写入文件数据。

读取数据

RandomAccessFile file = null;
try {
	file = new RandomAccessFile("source.txt", "r"); // 第一个参数是文件路径，第二个参数r表示只读

	file.seek(4); //游标移动四个位置

	byte[] bytes = new byte[2]; // 两个字符的缓存

	file.read(bytes); // 读入两个字符到缓存中

	System.out.println(new String(bytes)); // 打印读取出来的两个字符

} catch (IOException e) {
	e.printStackTrace();
} finally {
	try {
		file.close();
	} catch (IOException e) {
		e.printStackTrace();
	}
}

在某处写入数据

RandomAccessFile file = null;
try {
	file = new RandomAccessFile("source.txt", "rw"); // 第一个参数是文件路径，第二个参数rw表示读写

	file.seek(4); //游标移动四个位置

	file.write("Insert data".getBytes()); // 在第五个字符位置插入数据

} catch (IOException e) {
	e.printStackTrace();
} finally {
	try {
		file.close();
	} catch (IOException e) {
		e.printStackTrace();
	}
}

在文件末尾写入数据

file.seek(file.length());  // 把游标移动到文件的末尾，其他操作和插入操作一样

网络下载文件

InputStream

BufferedInputStream bis = null;
FileOutputStream fos = null;

try {
	//url代表一个绝对地址，URL对象直接指向这个资源
	URL url = new URL("http://pic6.nipic.com/20100417/1304280_085257009323_2.jpg");
	// url.openStream()返回为InputStream
	bis = new BufferedInputStream(url.openStream());
	// 存入本地文件
	fos = new FileOutputStream("." + File.separator + "meinv.jpg");

	byte[] bytes = new byte[1024];

	int count = 0;
	while ((count = bis.read(bytes)) != -1) {
		fos.write(bytes, 0, count);
	}

} catch (IOException e) {
	e.printStackTrace();
} finally {
	try {
		fos.close();
		bis.close();
	} catch (IOException e) {
		e.printStackTrace();
	}
}

NIO Channel

ReadableByteChannel rbc = null;
FileOutputStream fos = null;
try {

	//url代表一个绝对地址，URL对象直接指向这个资源
	URL url = new URL("http://pic6.nipic.com/20100417/1304280_085257009323_2.jpg");

	rbc = Channels.newChannel(url.openStream());
	fos = new FileOutputStream("." + File.separator + "meinv.jpg");

	fos.getChannel().transferFrom(rbc, 0, Long.MAX_VALUE);

} catch (IOException e) {
	e.printStackTrace();
} finally {
	try {
		fos.close();
		rbc.close();
	} catch (IOException e) {
		e.printStackTrace();
	}
}

压缩和解压缩文件

压缩文件

FileInputStream fis = null;
FileOutputStream fos = null;
GZIPOutputStream gos = null;
try {
	fis = new FileInputStream("./meinv.jpg"); // 输入流
	fos = new FileOutputStream("./Meinv.gz"); // 输出流
	gos = new GZIPOutputStream(fos); 		  // 压缩输出流

	byte[] buffer = new byte[1024];
	int count = 0;
	while ((count = fis.read(buffer)) != -1) {
		gos.write(buffer, 0, count);
	}

} catch (IOException e) {
	e.printStackTrace();
} finally {
	try {
		gos.close();
		fos.close();
		fis.close();
	} catch (IOException e) {
		e.printStackTrace();
	}
}

解压缩文件

FileInputStream fis = null;
GZIPInputStream gis = null;
FileOutputStream fos = null;

try {

	fis = new FileInputStream("./Meinv.gz");
    gis = new GZIPInputStream(fis);
    fos = new FileOutputStream("./new.jpg");
    byte[] buffer = new byte[1024];
    int len;
    while ((len = gis.read(buffer)) != -1) {
        fos.write(buffer, 0, len);
   }
} catch (IOException e) {
    e.printStackTrace();
} finally {
	try {
		fos.close();
		gis.close();
		fis.close();
	} catch (IOException e) {
		e.printStackTrace();
	}
}

创建临时文件

createTempFile(String prefix, String suffix, File directory) 可以用来创建临时文件，创建出来的文件名称是prefix+random_long_no+suffix,如果suffix给null，则为.tmp, 如果directory不给，则为系统默认的临时文件夹。

File tmpFile = File.createTempFile("data", null);

小蜜蜂

Java IO 操作