javase i/o流

1. i/o流包含了大量的接口和类，储存在java.io包中
2. File类，对磁盘中文件的增删改查（CURD），但是不能对文件的内容进行操作
3. File类的常用API
   createNewFile()不存在时创建一个空文件
   static createTempFile(String perfix,String suffix)创建一个带前后缀的空文件
   static createTempFile(String prefix,String suffix,File directory)指定文件目录
   delete()删除文件或者空目录
   exists()测试是否存在
   getAbsoluteFile()返回绝对路径名形式
   getAbsolitePath()返回绝对路径名字符串
   getParentFile()返回父文件
   isAbsolute()测试是否是绝对路径名
   isDirectory()测试是否是目录
   isFile()测试是否是标准文件
   length()文件长度
   list()返回文件名和目录名（字符串数组)
   listFiles()返回文件数组
   mkdir()创建指定目录
   mkdirs()包含不存在的父目录
   renameTo（）重新命名
4. 递归方法遍历文件夹所有文件；删除一个非空文件夹

package io0818;

import java.io.*;

public class insert {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        File file = new File("c:/1809/新建文件夹");
        show(new File("c:/1809"));
        delete(new File("c:/18091"));
    }

    public static void show(File file) {
        if (file.isFile()) {
            System.out.println(file.getAbsolutePath());
        } else if (file.isDirectory()) {
            System.out.println("这是一个目录：");
            for (File s : file.listFiles()) {
                show(s);
            }
        }

    }

    public static void delete(File file) {
        if (file.isFile()) {
            System.out.println("删除"+file.getAbsolutePath());
            file.delete();
        } else if (file.isDirectory()) {
            System.out.println("这是一个目录：");
            for (File s : file.listFiles()) {
                delete(s);
            }
        }
        file.delete();
    }
}

1. io流：在java中将信息的输入和输出抽象为io流
   输入是指数据流入程序
   输出是指数据从程序流出
   
   1. 分类
      按流向：输入流/输出流
      按字节：字节流/字符流
      按功能：节点流/处理流
      四个顶层的流：InputStream,OuputStream,Reader,Writer
      对于文件操作的流：FileInputStream,FileOutputSream,FileReader,FileWriter
   2. FileInputStream file=new FileInputStream(“c:/1809”);
      int data=file.read();
      while(data!=-1){
      System.out.println(data);
      data=file.read();
      }
      file.close();
   3. 复制一个文件
      import java.io.*;

//复制的三种方案1.一次性2.一个一个复制3.数组缓冲
public class copyTeacher {

public static void main(String[] args) throws IOException {
    // TODO Auto-generated method stub
    FileInputStream fis = new FileInputStream("c:/1809/java1.txt");
    FileOutputStream fos = new FileOutputStream("c:/1809/java2.txt");
    byte[] a = new byte[2048];
    int size = 0;
    while ((size = fis.read(a)) != -1) {
        fos.write(a, 0, size);
    }
    fos.close();
}

}

1. 对象的序列化
   序列化：把对象转换为字节对象的过程
   反序列化：把字符对象恢复为对象的过程
   类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。
   ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
   oos.writeInt(456);
   ObjectInputStream ois=new ObjectInputStream(new FileInputStream(c:/1809/java2.txt”);
   System.out.println(ois.readInt());

   1. 缓冲流

BufferedWriter:
FileWriter fw = new FileWriter("c:/1809/java2.txt",true);
        BufferedWriter bw = new BufferedWriter(fw);
        String str = "这是一个缓冲字符流";
        for (int i = 0; i < 100; i++) {
            bw.write(str+i);
            bw.newLine();
        }
        bw.close();
BufferedReader:
Reader file = new FileReader("c:/1809/java2.txt");
        BufferedReader br = new BufferedReader(file);
        String str = null;
        while ((str = br.readLine()) != null) {
            System.out.println(str);
        }
        br.close();

1. PrintWriter
   PrintWriter pr = new PrintWriter(“c:/1809/java3.txt”);
   for (int i = 0; i < 100; i++) {
   pr.printf(“这是我的第%d个字符串”,i);
   pr.println();
   }
   pr.close();
2. Properties
   查找：
   Properties p=new Properties();
   p.load(new FileReader(c:/1809/java4.txt”);
   System.out.println(p.gerProperties(“name”);
   添加：
   Properties p=new Properties();
   p.load(new FileReader(c:/1809/java4.txt”);
   p.setProperties(“name”,”price”);
   p.store(new FileWriter(c:/1809/java4.txt”),”test”);
3. ByteArrayInputStream,ByteArrayOutputStream:节点流，将数据写到指定的字节数组中例如：网络传输（把任何对象转成字节数组），对象的深复制（克隆）
   将对象转成字节数组;

public static byte[] toBytes(Object obj) throws Exception {
        //1.创建 一个ByteArrayOutputStream;
        ByteArrayOutputStream baos=new ByteArrayOutputStream();
        ObjectOutputStream oos=new ObjectOutputStream(baos);
        oos.writeObject(obj);
        oos.close();
        return baos.toByteArray();
}

//把字符数组转成对象

public static Book toBook(byte[] bytes) throws Exception {
        ByteArrayInputStream bais=new ByteArrayInputStream(bytes);
        ObjectInputStream bis=new ObjectInputStream(bais);
        Book b=(Book)bis.readObject();
        bais.close();
        return b;
    }

/**
* 对象的深复制
* @param obj
* @return
*/

public static Object copy(Object obj) {
        Object result=null;
        try {
            result=toBook(toBytes(obj));
        }catch(Exception e) {
            e.printStackTrace();
        }
        return result;
    }

1. 转换流：字节流–字符流（不能进行相反操作）
   应用场景：又是开发是API只为我们提供以恶搞字节流，但是我们的操作是做字符的传输，需要转换流：例如：网络传输，文件上传下载；
   IInputStreamReader(InputStream);
   OutputStreamWriter(OutputStream);

2. 总结：
   输入/输出操作的抽象;

   输入
   InputStream,Reader
   read(),read();
   ObjectInputStream: readObject,readInt,ReadDouble;
   BufferedReader: readLine()
   FileInputStream,FileReader,ByteArrayInputStream; 节点
   InputStreamReader: 转换
   输出
   OutputStream,Writer
   write();write();
   ObjectOutputStream: writeInt,writeObject,writeUTF,writerDouble
   BufferedWriter; newLine();
   PrintWriter print,println,printf
   FileOutputStream,FileWriter,ByteArrayOutputStream; 节点流
   OutputStreamWriter: 转换流