### File类
~~~
public class FileDemo1 {
public static void main(String[] args) throws IOException {
// File类--不能访问文件
File file = new File("E:/abc.doc");
// 创建文件夹mkdirs()
// if(!file.exists()) {
// file.mkdirs();
// }
// 创建文件createNewFile()
// if(!file.exists()) {
// file.createNewFile();
// }
// 判断是文件还是文件夹的方法
// if(file.isFile()) {
// System.out.println("是文件");
// }
//
// if(file.isDirectory()) {
// System.out.println("是文件夹");
// }
// 文件路径
// System.out.println(file.getPath());
// 文件名称
// System.out.println(file.getName());
// 删除文件
// if(file.exists()) {
// file.delete();
// }
// System.out.println(file.getAbsolutePath());
}
}
~~~
***
### 流(Stream)
文件传输（读取和书写）
**按照流向分类**：输入输出的**参照物是Java程序**
①输入流：读文件
②输出流：写文件
**按照传输单位分类**：
①字节流：以字节为单位传输数据，一般用于二进制文件的传输
②字符流：以字符为单位传输数据，一般用于纯文本文件的传输
**按照功能分类**：
①节点流
②处理流
***
***
~~~
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
/**
* 纯文本的拷贝
* @author Administrator
*
*/
public class Practice1 {
public static void main(String[] args) {
// 将D:/text1.txt拷贝到E:test2.txt
FileReader fr = null;
BufferedReader in = null;
FileWriter fw = null;
PrintWriter out = null;
try {
fr = new FileReader("D:/test1.docx");
in = new BufferedReader(fr);
fw = new FileWriter("E:/test2.docx");
out = new PrintWriter(fw,true);
String msg = in.readLine();
while(msg != null) {
out.println(msg);
msg = in.readLine();
}
System.out.println("文件copy成功");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
out.close();
}
}
}
~~~
~~~
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* 二进制文件的拷贝
* @author Administrator
*
*/
public class BinaryFileCopyDemo1 {
public static void main(String[] args) {
// 搭建管道
FileInputStream fis = null;
BufferedInputStream in = null;
FileOutputStream fos = null;
BufferedOutputStream out = null;
try {
fis = new FileInputStream("C:\\Users\\Administrator\\Desktop\\2345截图20180511165805.png");
in = new BufferedInputStream(fis);
File file = new File("E:/xyz");
if(!file.exists()) {
file.mkdir();
}
fos = new FileOutputStream("E:/test.png");
out = new BufferedOutputStream(fos);
byte buffer[] = new byte[1024];
// len是真正读取到的字节数，没有返回-1
int len = in.read(buffer);
while(len != -1) {
// buffer缓冲区
// off 偏移量--0
// len 长度
out.write(buffer, 0, len);
len = in.read(buffer);
}
System.out.println("finish");
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
out.close();
} catch (IOException e1) {
e1.printStackTrace();
}
try {
if(fis != null) {
fis.close();
}
} catch (IOException e) {
e.printStackTrace();
}
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
~~~
***
### 对象序列化
对象(Object)序列化是指将对象转换为字节序列的过程
反序列化则是根据字节序列恢复对象的过程
通过使用ObjectInputStream和ObjectOutputStream类保存和读取对
象的机制叫做序列化机制
序列化对象前提：
这个类必须实现一个接口**Serializable**（或者**Externalizable**）
~~~
public interface Serializable {
}
~~~
接口Serializable是一个空的接口，Java中存在很多向这样没有方法，只有定义的接口：标识接口，标识一个类是否具有某种能力
实现Serializable的类对象就能实现序列化
~~~
import java.io.Serializable;
public class Person implements Serializable{
// serialVersionUID确保唯一
private static final long serialVersionUID = 8373631186930852694L;
// transient能够修饰属性--不能被序列化（反序列化只能得到默认值）
transient int age;
String name;
public Person() {
}
public Person(int age, String name) {
super();
this.age = age;
this.name = name;
}
}
~~~
~~~
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class SerializationDemo {
public static void main(String[] args) {
// 对象序列化
// Person p = new Person(13, "李四");
// FileOutputStream fos = null;
// ObjectOutputStream out = null;
// try {
// fos = new FileOutputStream("E:/person.bin");
// out = new ObjectOutputStream(fos);
// out.writeObject(p);
// } catch (Exception e) {
// e.printStackTrace();
// } finally {
// try {
// fos.close();
// } catch (IOException e) {
// e.printStackTrace();
// }
// try {
// out.close();
// } catch (IOException e) {
// e.printStackTrace();
// }
// }
// 反序列化
FileInputStream fis = null;
ObjectInputStream in = null;
try {
fis = new FileInputStream("E:/person.bin");
in = new ObjectInputStream(fis);
Person p1 = (Person) in.readObject();
System.out.println(p1.age + " " + p1.name);
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
~~~
