1、File类
（1）File类的几种构造方法；
//创建文件和文件夹
public static void createFile() throws IOException {
//文件操作
//File file = new File("file.txt");
//创建
//boolean b = file.createNewFile();
//删除
//boolean b = file.delete();
//是否存在
//boolean b = file.exists();
//创建文件夹
File dir = new File("c:\\abc");
boolean b = dir.mkdir();
System.out.println("b="+b);
}
（2）获取文件信息（略）
获取名称，
获取路径，
获取大小，
获取时间。
（3）判断（略）
文件是否可读；
文件是否可写；
文件是否可执行；
文件是否隐藏；
（4）文件的创建和删除以及该文件是否存在；
（5）练习列出子目录中的内容（递归）；
//递归遍历文件夹
public static void printFiles(File dir,int count){
System.out.println(getSpace(count)+dir.getName());
count++;
File[] files = dir.listFiles();
if(files != null){
for(File file:dir.listFiles()){
if(file.isDirectory()){
printFiles(file,count);
}else{
System.out.println(getSpace(count)+file.getName());
}
}
}
}
//计算空格
public static String getSpace(int count){
StringBuilder builder = new StringBuilder();
for(int i=0;i<count;i++){
builder.append("|--");
}
return builder.toString();
}
（6）遍历删除文件夹
//递归删除一个文件夹下所有文件
public static void deleteFile(File dir){
//System.out.println(dir.getAbsolutePath());
File[] files = dir.listFiles();
for(File file:files){
if(file.isDirectory()){
deleteFile(file);
}else{
System.out.println(file.getAbsolutePath()+file.delete());
}
}
System.out.println(dir.getAbsolutePath()+dir.delete());
}
（7）Properties（略）
2、字符流Reader，Writer
（1）FileWriter使用
<1>例子：
FileWriter fw = new FileWriter("demo.txt");
fw.write("abcdef");
fw.flush();
fw.write("haha");
fw.close();
<2>flush()和close()有什么区别？
flush()：仅将缓冲区中的数据刷新到目的地。流对象可以继续使用。
close()：将缓冲区中的数据刷到目的地后，直接关闭资源，流无法继续使用。
<3>IO异常的基本处理方式：
FileWriter fw = null;
try {
fw = new FileWriter("demo.txt",true);
fw.write("abcdef");
fw.flush();
fw.write("ha\r\nha");
} catch (IOException e) {
e.printStackTrace();
}finally {
if(fw != null){
try {
fw.close();
} catch (IOException e) {
throw new RuntimeException("字符流关闭失败");
}
}
}
3、字节流
InputStream，OutputStream
4、转换流，打印流，对象序列化，编码等)
（1）PrintStream和PrintWriter：可直接操作流和文件
（2）序列流SequenceInputStream：对多个流进行合并
（3）操作对象
<1>ObjectInputStream与ObjectOutputStream
//被操作的对象需要实现Serializable；
<2>对象的序列化
Serializable使用的时候生成的序列号，建议显示声明，防止编译器不同时，发生错误；
注意：
（1）类中的静态成员变量是不能被序列化的，因为静态成员变量不再堆中。
（2）如果希望非静态数据不被初始化，可以使用transient修饰对象。
（4）文件分割
（5）RandomAccessFile
（6）管道流
特点：
<1>单线程容易造成死锁。
示例：
public class PipedStreamDemo {
public static void main(String[] args) throws IOException {
PipedInputStream inputStream = new PipedInputStream();
PipedOutputStream outputStream = new PipedOutputStream();
inputStream.connect(outputStream);
Input input = new Input(inputStream);
Output output = new Output(outputStream);
new Thread(output).start();
new Thread(input).start();
}
}
class Input implements Runnable{
private PipedInputStream in;
public Input(PipedInputStream in){
super();
this.in = in;
}
@Override
public void run() {
byte[] buf = new byte[1024];
int len = 0;
try {
len = in.read(buf);
String str = new String(buf,0,len);
System.out.println("read:"+str);
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
class Output implements Runnable{
private PipedOutputStream out;
public Output(PipedOutputStream out) {
this.out = out;
}
@Override
public void run() {
try {
out.write("hello piped!".getBytes());
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
（7）操作基本数据类型的流
private static void operateData() throws IOException {
// FileOutputStream fos = new FileOutputStream("data.txt");
// DataOutputStream dos = new DataOutputStream(fos);
// dos.writeInt(98);
// dos.writeBoolean(true);
// dos.close();
DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
int num = dis.readInt();
boolean b = dis.readBoolean();
System.out.println("num = "+num);
System.out.println("boolean = "+b);
dis.close();
}
（8）操作字节数组的流
private static void operateData() {
ByteArrayInputStream bis = new ByteArrayInputStream("abc".getBytes());
ByteArrayOutputStream bos = new ByteArrayOutputStream();
int ch = 0;
while ((ch=bis.read())!=-1){
bos.write(ch);
}
System.out.println(bos.toString());
}
5、IO流使用总结
（1）明确源和目的。
源：InputStream Reader 一定是被读取的。
目的:OutputStream Writer 一定是被写入的。
（2）处理的数据是否是基本数据？
是：使用字符流。Reader Writer
否：使用字节流。InputStream OutputStream
（3）明确数据所在设备：
源设备：
键盘（System.in）
硬盘（FileXXX）FileReader FileInputStream
内存（数组）ByteArrayInputStream CharArrayReader StringReader
网络（Socket）
目的设备：
显示器（控制台System.out）
硬盘（FileXXX）FileWriter FileOutputStream
内存（数组）ByteArrayOutputStream CharArrayWriter StringWriter
网络（Socket）
（4）明确是否需要额外功能？
<1>是否需要高效？缓冲区Buffered四个。
<2>是否需要转换？转换流 InputStreamReader OutputStreamWriter
<3>是否操作基本数据类型？DataInputStream DataOutputStream
<4>是否操作对象（对象序列化）？ObjectInputStream ObjectOutputStream
<5>需要对多个源合并吗？SequenceInputStream
<6>需要保证数据的表现形式到目的吗？PrintWriter
<7>如果数据有规律，并且源和目的都是file，需要随机访问时，可以使用RandomAccessFile工具类。
网友评论