Java中的IO流

Java中的IO流
Java对于文件的主要操作都封装在java.io包中，通过java.io包中的类可以实现对文件的输入、输出等各类操作

文件与流
文件概念
文件是由具体内容或用途的，而文件夹时用来防止这些文件的，文件和文件夹在Java中对应的类时File.File类时IO包中唯一代表磁盘文件本身的对象。可通过File来创建、删除、重命名文件。File类对象的只要作用就是用来获取文本本身的一些信息。如文本所在的目录、文件的长度、读写权限等。

语法：

  // 创建文件对象
    File file = new File("文件或文件夹路径");
    //判断是否是文件
    file.isFile();
    //判断是否为文件夹
    file.isDirectory();
    //判断文件是否存在
    file.exists();

什么是流

在Java中所读取的信息，是通过一跟管道，输送到数据文件的。这跟管道中的信息，称之为“流”。而在Java程序中打开流的这个操作称为“写”

Java流是指一连串流动的字符，是以先进先出的方式发送和接受数据的通道。流具有明确的方向性，当向一个流写入数据时，这个流被称为输出流 ， 输出流可以将信息送到程序的外部，如硬盘上的文件、打印机上的文件等；也可以从一个输入流读取数据，原则上这些数据是可以是任何的数据源。按照流的流向进行划分，可以分为输入流和输出流

输出：当你要将数据写入文件的时候，一个管道查到文件里面去，然后数据就顺着管道流出去到文件，这时你在管道的另一头就可以将数据写入到文件流出来的各种各样的数据l了

输入：当你要从文件读取数据的时候，一个管道查到文件里面去，然后数据就顺着管道流出来，这时你在管道的另一头就可以读取到从文件流出来的各种各样的数据le

写文件
字节输出流写文件
字节输出流 OutputStream
字节输出流 OutputStream 类时字节输出流的抽象类，表示输出字节流的所有类的父类，作用时吧内存中的数据输出到文件中 字节输出流 OutputStream 是他的子类，

字节输出流FIleOutputStream类
在实际应用中。我们通常使用 OutputStream 的子类 FileOutputStream 类来实现向文本文件写入数据，常用的构造方法有三个

(1): FileOutputStream (File file):file 指定文件目标数据源。使用此构造方法创建文件输出流对象如下

    File file = new File("D\\test.txt");
    FileOutputStream out = new FileOutputStream(file);

此时的文件输出流对象out就和目标源数据源联系起来了

（2）：FileOutputStream (String name): 其中，name指定文件目标数据源，包含路径信息.append表示是否在文件末尾添加数据，

    FileOutputStream out1 = new FileOutputStream("D:\\test.txt");

(3) :FileOutputStream （String name,boolean append):其中，name指定文件目标数据源，包含路径信息。append表示是否在文件末尾添加数据，若设置为true，则在文件末尾添加数据。

   FileOutputStream out2 = new FileOutputStream("D:\\test,txt",true);

需要注意的是，第一种和第二种构造方法在向文件写数据时将覆盖文件中原有的内容，另外，在使用FileOutputStream的构造方法jkio创建FileOutputStream实例时，如果相应的文件并不存在，就会自动创建一个空的文件，若参数file 或name表示的文件路径尽管存在，但是指代表一个文件目录，则此时会抛出FileNotFoundException异常。

public class Demo04 {

    public void writeFile() throws IOException, FileNotFoundException {
        FileOutputStream out = new FileOutputStream("d:\\test.txt");
        String str = "好好学习Java";
        byte[] words = str.getBytes();
        out.write(words);
        out.flush();
        out.close();

    }
    public static void main(String[] args) throws IOException {
        new Demo04().writeFile();
    }
}

字符输出流写文件
字节输出流 Writer类

所有字符输出流的实现都是字符输出流的抽象类的子类。长用字符输出流Writer类

字符输出流 FileWriter类

FileWriter类时Writer类的子类，常用的构造方法格式如下：

 FileWriter(String filename);

其中，fileName表示与系统有关的文件名，使用此构造方法创建字符输出流对象如下：

 Writer fr = new FileWriter("e:\\test.txt");

代码实例:

public class Demo06 {

  public static void main(String[] args) {
      Writer fw = null;
      try {
          fw = new FileWriter("d:\\test.txt");
          fw.write("我热爱Java编程");
          fw.flush();
      } catch (Exception e) {
          e.printStackTrace();
      } finally {
          if (fw != null) {
              try {


                  fw.close();
              } catch (Exception e) {
                  e.printStackTrace();
              }

          }
      }
  }
}

字节输出流 BufferedWriter 类

BufferedWriter 类时writer类的子类。 BufferedWriter 类与BufferedReader类的流方向正好相反，BufferedWriter 类时把一批数据写到缓冲区，当缓冲区满的时候，在把缓冲区的数据写到字符输出流中。这样避免每次都执行物理写操作，从而提高输入输出操作的效率。

    Writer fw = new FileWriter("d:\\hello.txt");
    BufferedWriter bw = new BufferedWriter(fw);

案例代码：

public class Demo08 {
   public static void main(String[] args) {
       FileWriter fw = null;
       BufferedWriter bw = null;
       try {
           fw=new FileWriter("d:\\hello.txt");
           bw = new BufferedWriter(fw);
           bw.write("大家好");
           bw.write("我在学习 Bufferedwriter");
           // 插入换行符
           bw.newLine();
           bw.write("请多指教");
           bw.newLine();
           bw.flush();
       }catch (Exception e) {
           e.printStackTrace();
       }finally {
           try {
               if (fw != null)  bw.close();
               if (fw != null) fw.close();
               
           }catch (Exception e) {
               e.printStackTrace();
           }
       }
   }
   
}

在操作上字节流和字符流有一个区别，字符流在操作时使用了缓冲区（内部存储器），而字节流在操作时是直接操作文件的，不会使用缓冲区

序列化
序列化机制允许将实现序列化的Java对象转换为字节序列，这些字节序列可以保存在磁盘上，或通过网络 传输以达到以后恢复成原来的对象，序列化机制使得独享可以脱离程序的运行而独立存在

使用序列化

在项目中，我们的数据不是单个对象，而是一组对象。我们使用ObjectOutputStream类来做数据的i写入，同时还需要对实体类做序列化操作

语法：

需要序列化的类实现Serializable接口

public class Client extends Person implements Serializable{  
}

Serializable 接口时一个标记接口，不用实现任何方法。一旦实现了此接口，该类的对u想就是可序列化的

案例代码：

public class Demo10    implements Serializable {
    private static final long serialVersionUID = 1L;
    private  String clientId;
    private  String phone;
    private  String name;
    private  String sex;
    private  int  age;

    public int getAge() {
        return age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Demo10(String s, String s1) {
    }

    @Override
    public String toString() {
        return "Demo10{" +
                "clientId='" + clientId + '\'' +
                ", phone='" + phone + '\'' +
                ", name='" + name + '\'' +
                '}';
    }

    public static long getSerialVersionUID() {
        return serialVersionUID;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getClientId(){
        return clientId;
    }
    public void setClientId(String clientId) {
        this.clientId = clientId;
    }
    public String getPhone() {
        return phone;
    }
    public void setPhone(String phone) {
        this.phone = phone;
    }

}


public class TestDemo10 {
    public static void main(String[] args) {
        Demo10 demo10 = new Demo10("101101","12345678765");
        demo10.setName("张三");
        demo10.setAge(22);
        demo10.setSex("男");
        
        try(ObjectInputStream oos = new ObjectInputStream(new FileInputStream("D:\\client.txt"))){
            oos.writeObject(demo10);
            oos.close();
        }catch (IOException e) {
            e.printStackTrace();
        }
        
    }
}