文件（java.io.File）
创建文件
boolean java.io.File.createNewFile() throws IOException{}
//用来创建文件，如果文件存在，创建失败，返回false；
实例：
//创建一个file对象
File f1 = new File("a.txt");
try
{
//创建文件:boolean java.io.File.createNewFile() throws IOException
boolean b = f1.createNewFile();
//第二次将会创建失败false，这里和流不一样
System.out.println(b);
}
catch (Exception e)
{
// TODO: handle exception
}
//目录分隔符：File.separator，相当于“\\”跨平台路径。
File f2 = new File("E:"+File.separator+"tmp","b.txt"); //File f2 = new File("E:\\tmp","b.txt");
f1.delete(); //删除文件：boolean java.io.File.delete()
f1.deleteOnExit(); //程序退出时，自动删除：void java.io.File.deleteOnExit()
boolean b = f1.exists(); //判断文件是否存在
boolean b = f1.isDirectory(); //判断是否为文件夹
创建文件夹
实例
File dir1 = new File("abc");
File dir2 = new File("a\\b\\c\\d");
try
{
//创建文件目录(即文件夹)：boolean java.io.File.mkdir()
//该方法只能创建“一级”目录
boolean b = dir1.mkdir();
System.out.println(b);
//创建多级文件夹：boolean java.io.File.mkdirs()
b = dir2.mkdirs();
System.out.println(b);
}
catch (Exception e)
{
System.out.println(e.toString());
}
boolean b = f1.isFile(); //判断是否为文件
获取文件信息
1）getName()：获取文件名；
2）getParent()：获取文件父目录；
3）getPath()：获取文件路径；
4）getAbsolutePath()：获取文件绝对路径；
5）lastModified()：获得文件最后一次被修改的时间；
6）length()：获取文件大小；
7）renameTo()：文件剪切，将文件f1剪切然后粘贴到f2（相当于右键f1->剪切->粘贴->f2所在目录）
流
java IO流分为字符流和字节流两种。
判断字节流和字符流，明确数据是否“纯文本”：
- 是：字符流；
- 否：字节流。
字节流
1、字节流有输入和输出流，输入流InputStream。
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
public class FileCount {
publicstatic void main(String[] args) {
int count=0; //统计文件字节长度
InputStream streamReader = null; //文件输入流
try{
streamReader=newFileInputStream(new File("D:/David/Java/java 高级进阶/files/tiger.jpg"));
/*FileInputStream是有缓冲区的，所以用完之后必须关闭，否则可能导致内存占满，数据丢失。 */
while(streamReader.read()!=-1) { //读取文件字节，并递增指针到下一个字节
count++;
}
System.out.println("---长度是： "+count+" 字节");
}catch (final IOException e) {
e.printStackTrace();
}finally{
try{
streamReader.close();
}catch (IOException e) {
e.printStackTrace();
}
}
}
}
2、FileOutputStream
Java I/O默认是不缓冲流的，所谓“缓冲”就是先把从流中得到的一块字节序列暂存在一个被称为buffer的内部字节数组里，然后你可以一下子取到这一整块的字节数据，没有缓冲的流只能一个字节一个字节读，效率孰高孰低一目了然。
import java.io.*;
public class FileCopy {
public static void main(String[] args) {
// TODO自动生成的方法存根
byte[] buffer=new byte[512]; //一次取出的字节数大小,缓冲区大小
int numberRead=0;
FileInputStream input=null;
FileOutputStream out =null;
try {
input=new FileInputStream("D:/David/Java/java 高级进阶/files/tiger.jpg");
out=new FileOutputStream("D:/David/Java/java 高级进阶/files/tiger2.jpg"); //如果文件不存在会自动创建
while ((numberRead=input.read(buffer))!=-1) { //numberRead的目的在于防止最后一次读取的字节小于buffer长度，
out.write(buffer, 0, numberRead); //否则会自动被填充0
}
} catch (final IOException e) {
// TODO自动生成的 catch 块
e.printStackTrace();
}finally{
try {
input.close();
out.close();
} catch (IOException e) {
// TODO自动生成的 catch 块
e.printStackTrace();
}
}
}
}
3、读写对象
ObjectInputStream 和ObjectOutputStream，该流允许读取或写入用户自定义的类，但是要实现这种功能，被读取和写入的类必须实现Serializable接口，其实该接口并没有什么方法，可能相当于一个标记而已，但是确实不合缺少的。
import java.io.*;
public class ObjetStream {
/**
* @param args
*/
public static void main(String[] args) {
// TODO自动生成的方法存根
ObjectOutputStream objectwriter=null;
ObjectInputStream objectreader=null;
try {
objectwriter=new ObjectOutputStream(new FileOutputStream("D:/David/Java/java 高级进阶/files/student.txt"));
objectwriter.writeObject(new Student("gg", 22));
objectwriter.writeObject(new Student("tt", 18));
objectwriter.writeObject(new Student("rr", 17));
objectreader=new ObjectInputStream(new FileInputStream("D:/David/Java/java 高级进阶/files/student.txt"));
for (int i = 0; i < 3; i++) {
System.out.println(objectreader.readObject());
}
} catch (IOException | ClassNotFoundException e) {
// TODO自动生成的 catch 块
e.printStackTrace();
}finally{
try {
objectreader.close();
objectwriter.close();
} catch (IOException e) {
// TODO自动生成的 catch 块
e.printStackTrace();
}
}
}
}
class Student implements Serializable{
private String name;
private int age;
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
}
字符流
（顾名思义，就是操作字符文件的流）
1、直接用FileReader打开的文件
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.nio.CharBuffer;
public class Print {
/**
* @param args
*/
public static void main(String[] args) {
// TODO自动生成的方法存根
char[] buffer=new char[512]; //一次取出的字节数大小,缓冲区大小
int numberRead=0;
FileReader reader=null; //读取字符文件的流
PrintWriter writer=null; //写字符到控制台的流
try {
reader=new FileReader("D:/David/Java/java 高级进阶/files/copy1.txt");
writer=new PrintWriter(System.out); //PrintWriter可以输出字符到文件，也可以输出到控制台
while ((numberRead=reader.read(buffer))!=-1) {
writer.write(buffer, 0, numberRead);
}
} catch (IOException e) {
// TODO自动生成的 catch 块
e.printStackTrace();
}finally{
try {
reader.close();
} catch (IOException e) {
// TODO自动生成的 catch 块
e.printStackTrace();
}
writer.close(); //这个不用抛异常
}
}
}
原博地址：
http://blog.csdn.net/qingdujun/article/details/41223841
http://blog.csdn.net/yczz/article/details/38761237
感谢作者分享，受益匪浅。
