javase_17(IO的总结)

所有的流在使用完毕时，都需要调用close方法进行关流，释放资源。
由于流操作都会有异常，如果发生异常就有可能导致close方法不能被调用
所以，IO异常一定要处理，close方法写在finally语句中
1.InputStream : 输入字节流 方法： read()从流(关联的设备)中读一个字节
** int read(buf):从流中读取n个字节放入缓冲区，方法会返回一个读取字节的个数 ips-->buf
读到一个-1，说明读到了流的末尾
 ------------------------------------------------------------------------------------------
|---FileInputStream: 重载的构造函数  (String fileName)  (File file)

2.OutputStream： 输出字节流 :方法 write(int c)将一个字节写入流  (byte)c
write(buf,offset,len)将指定字节数组的一部分写入流。 buf-->ops
 -------------------------------------------------------------------------------------------
|---FileOutputStream: 重载的构造函数 (Strng fileName) (String fileName, boolean append)
 append:指定数据是否追加到文件的末尾，默认是false，覆盖原有的数据，
 设置为true，将数据追加到文件的末尾
3.Reader：输入字符流 int read() 读一个字符   int read(buf)  buf是char[]类型
|---FileReader:  FileReader = InputStreamReader(FileInputStream) 只做了一件事：解码(父类在做)
4.Writer：输出字符流 write(int c) (char)c \  write(String str)
|---|---FileWriter:  FileWriter = OutputStreamWriter(FileOutputStream) 只做了一件事：编码

理解(会用)：
1.装饰设计模式： 对原有的类的进行包装，对方法进行增强
BufferedReader：实现缓冲的功能   创建包装流对象的时候，必须组合一个被包装的底层流
    增加了一个新方法 String readLine() 读一行
|--LineNumberReader: 增加了行号功能，getLineNumber() 、setLineNumber()
BufferedWriter：实现了缓冲功能  new BufferedWriter(new FileWriter("1.txt");
    增加了新方法  newLine() 另起一行
BufferedInputStream：实现缓冲的功能
BufferedOutputStream：实现缓冲的功能

2.InputStreamReader： 转换流   : 包装，实现了编码解码的功能
new InputStreamReader(new FileInputStream("1.txt"));

3.使用包装流包装System.in，读键盘方便，可以读一行
BufferedReader br =
 new BufferedReader(new InputStreamReader(System.in));
String line = br.readLine();
 
 
IO需要会写的程序： BufferedReader和BufferedWriter包装InputStream和OutputStream，读一行写一行

  BufferedReader和BufferedWriter包装Reader和Writer
  BufferedInputStream和BufferedOutputStream包装InputStream和OutputStream
  用基础流读写，自定义数组作为缓冲区，实现拷贝
  
-------以下做一个总结:

io流:数据传输的中转站-->IO流-->目的地

 IO流一般都是成对出现的,也就是说按照流的分向:输入流-->输出流
 IO流按照操作来分: 字节流-->字符流
 
一.字符流
基类:Reader(读)Writer(写)
|-Reader
 |--BufferedReader:对Reader进行了包装,提供了缓冲区(8192),有ReadLine()方法
  构造函数:BufferedReader(Reader r);
 |--InputStreamReader:转换流:将字节流转换成字符流:new InputStreamReader(System.in);
  |--FileReader:读取文件的字符流,FileReader(File file) FileReader(String fileName);
|-Writer
 |--BufferedWriter:包装流:常用的方法write(String s)、flush()刷新  newLine()换行
  构造函数:BufferedWriter(Writer w);
 |--OutputStreamWriter:转换流: new OutputStreamWriter(System.out);
  |--FileWriter:写入文件,FileWriter(File file)  FileWriter(String fileName)
   FileWriter(File file,boolean append),FileWriter(String fileName,boolean append)
   当append为true,将写入到文件的末尾处,当为false时,从文件开头开始写.就会覆盖原来的.默认为false
   
二.字节流:
|-InputStream(输入流)
 |--FileInputStream:读取文件的字符流,和FileReader基本是一样
 |--FilterInputStream:过滤流,一般不使用,只是针对了InputStream进行了包装
  |--BufferedInputStream:包装类:BufferedReader(InputStream in),提供缓存功能
  
|-OutputStream(输出流)
 |--FileOutputStream:写入文件的字符流,和FileWriter基本一样
 |--FilterOutputStream
  |--BufferedOutputStream:包装类:BufferedWriter(OutputStream out);
  
三.使用IO流必须要捕获异常,原因在于我们必须要还资源(关闭流)

FileWriter fw = null;
 try
 {
     fw = new FileWriter("src/1.txt");
 }
 catch(IOException e)
 {
     e.printStractTrace();
 }
 finally
 {
     try{if(fw!=null)fw.close();}catch(IOException){e.printStackTrace();}
 }

 

四.File文件类
1.构造方法:
File(File parnt,String child)
根据prent抽象路径名和child路径名字符串创建一个新的file实例.
File(String pathname)
通过将给定的路径名字来创建一个新的file实例.
File(String parent, String child)
根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例.

2.常用方法:
isFile:判断对象是否是一个标准文件
isDirectory:判断对象是否为一个文件夹
isAbsolute:判断是否为一个绝对路径
exists:判断对象指定的文件是否存在
createNewFile:根据对象的描述创建一个对象
getName:获得文件名
getPath:获得路径名
getParent:获得文件的父级抽象路径
getAbsolutepath:获得文件的绝对路径名
mkdir:创建此抽象路径指定的目录,(只能在存在的文件夹下创建一个目录)
mkdirs:创建此抽象路径指定的目录,包括所有必须但不存在的目录.创建多级目录(c:/a/b/c)
list(FilenameFilter filter)：根据指定过滤器遍历文件夹中的所有文件，返回String[]
 如果对象为标准文件，则返回null，如果对象是一个空文件夹，则返回空数组。length为0
 FilenameFilter是一个接口，只有一个方法accept，我们需要实现接口的accept方法。
 实现类是给list方法自动调用的
 方法的参数是list方法传给我们的，返回的结果也是给list方法去用。
listFiles：和list基本一样，返回值类型不一样，返回File[]。
常用案例：遍历目录下所有的文件和文件夹   拷贝一个文件夹  .

五:RandomAccessFile 文件流,可以读写
1.RandomAccessFile(File file,String mode)、RandomAccessFile(String fileName,String mode)
 mode:常用的: r,只读 rw读写
2.有很多read和write方法.
 seek方法,指定从那个位置开始读seek(0) ,从原有的位置覆盖掉
skipBytes(int n)：跳过多少个字节

六:PrintStream、PrintWriter打印流
有一个特殊的方法print可以实现打印
write方法是直接将字节和字符写出去
print：首先调用对象的toString方法转成字符串(如果是基本数据类型，会先自动装箱)
 再将字符串编码成字节数组，调用write方法写出去

七:SequenceInputStream序列流
可以将多个字节流组合起来
构造方法：SequenceInputStream(Enumeration<? extends InputStream> e) 
  //Enumeration可以通过Vector来获得，如果用的是ArrayList，如何获得呢？
     SequenceInputStream(InputStream in1,InputStream in2)

八:ObjectInputStream、ObjectOutputStream操作对象的字节流
一般成对出现
使用writeObject方法写入的对象，只能由readObject方法读出来
操作的对象必须实现java.io.Serializable序列化接口，该对象才可以被序列化和反序列化。
序列化: Java中规定的一种保存对象的数据格式

九:DataInputStream、DataOutputStream操作基本数据类型，格式化数据
readInt、writeInt等方法。
writeInt写入一个整数，文件大小为4字节。证明就是把基本数据类型对应的字节写出去了，没有丢失精度

十:ByteArrayInputStream、ByteArrayOutputStream对Byte数组进行读写的字节流，针对内存进行读写
源和目的地都是内存，一般用于对内存中的数据进行处理。

十一:PipedInputStream、PipedOutputStream管道流
1、输入管道流
构造方法：PipedInputStream(PipedOutputStream pos)实现拼接
也可以通过connect(PipedOutputStream pos)方法进行拼接

2、输出管道流
构造方法：PipedOutputStream(PipedInputStream pis)实现拼接
也可以通过connect(PipedInputStream pis)方法进行拼接

--Test:序列化与反序列化..
 package com.java.kudy_Say;
 
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.ObjectOutputStream;
 import java.io.Serializable;
 import java.util.ArrayList;
 import java.io.ObjectInputStream;
 import java.io.FileInputStream;
 /*
     序列化与反序列化的过程
 */
 public class Test {
     
     public static void main(String[]args) throws FileNotFoundException, IOException,ClassNotFoundException
     {
             
 /*        Student s1 = new Student("张三",18);
         Student s2 = new Student("王五",19);
         Student s3 = new Student("李四",20);
         Student s4 = new Student("大毛",21);
         ObjectOutputStream oos = 
                 new ObjectOutputStream(new FileOutputStream("f:/a.txt"));
         ArrayList<Student> al = new ArrayList<Student>();
         al.add(s1);
         al.add(s2);
         al.add(s3);
         al.add(s4);
         oos.writeObject(al);
         oos.close();//关闭流
         //首先我们把内容放到一个集合里面去
 */
         ObjectInputStream ois = 
                 new ObjectInputStream(new FileInputStream("f:/a.txt"));
         ArrayList<Student> al = (ArrayList<Student>)ois.readObject();
         for(Student s :al)
             System.out.println(s);
         ois.close();
     
     
         
     }
 }
 
 //必须要实现一个类
 class Student implements Serializable
 {
     private String name;
     private int age;
     Student(){}
     Student(String name,int age)
     {
         this.name = name;
         this.age = age;
     }
     public String toString()
     {
         return name+"@"+age;
     }
 }