IO流

---

1.File类的使用

• File可以新建、删除、重命名文件和目录，但是不能访问文件内容
• File对象可以作为参数传递给流的构造器
• public File(String pathname) 以指定路径创建File对象
• public File(String parent,String child) 以parent为父路径，child为子路径创建file对象
• public File(File parent,String child) 根据一个父File对象和子文件路径创建File对象

package javabasis.chapter13;

import java.io.File;
import java.io.IOException;

public class FileTest {
    public static void main(String[] args) throws IOException {
        
        File dir1=new File("dir1");//构造方法1
        if(!dir1.exists())//不存在则创建目录
        dir1.mkdir();//mkdir只能创建单级路径文件，上一级目录若不存咋，当前文件也不会被创建

        //创建dir1父目录下面的dir2对象
        File dir2=new File(dir1, "dir2");//构造方法2
        //不存在就创建为目录
        if(!dir2.exists())
        dir2.mkdirs();

        File dir4=new File(dir1, "dir3/dir4");
        if(!dir4.exists())
           dir4.mkdirs();//mkdirs可以创建dir3/dir4这种多级路径
       
        //获取指定路径下的text.txt对象
        File file=new File("D:/VS_Code_Java/dir1", "test.txt");//构造方法3
        //不存在则创建为文件类型（不是目录）
        if(!file.exists())
          file.createNewFile();


        //方法的使用
        //1.获取绝对路径
        System.out.println(file.getAbsolutePath());//D:\VS_Code_Java\dir1\test.txt
        //2.获取路径
        System.out.println(dir4.getPath());//dir1\dir3\dir4
        //3.获取名称
        System.out.println(file.getName());
        //4.获取上层目录文件
        System.out.println(file.getParent());
        //5.获取文件长度
        System.out.println(file.length());//只能是文件，不能是目录
        //6.判断是否是文件目录
        System.out.println(file.isDirectory());
        //7.判断是否是文件
        System.out.println(file.isFile());
    }
}

2.IO流原理及流的分类

• 输入：将外部数据（磁盘、光盘）中的数据读取到内存中
• 输出：将内存中的数据输出存储到磁盘、光盘上
• 四个基类：
  • 字节输入流 InputStream
  • 字节输出流 OutputStream
  • 字符输入流 Reader
  • 字符输出流 Writer

3.节点流（文件流）

• 字节输入流 FileInputStream
• 字节输出流 FileOutputStream
• 字符输入流 FileReader
• 字符输出流 FileWriter

package javabasis.chapter13;

import java.io.File;
import java.io.FileReader;


public class FileReaderTest {
    
    public static void main(String[] args) {
        FileReader fr=null;
 
        try {
            fr=new FileReader(new File("D:/VS_Code_Java/dir1/test.txt"));//路径用/或\\
            char buf[]=new char[1024];
            int len;
            while((len=fr.read(buf))!=-1)
            System.out.println(new String(buf,0,len));
        } catch (Exception e) {
           System.out.println(e.getMessage());
        }finally{
            if(fr!=null)
            {
                try {
                    fr.close();
                } catch (Exception e) {
                 System.out.println(e.getMessage());
                }
            }
        }
     }
    
}

package javabasis.chapter13;

import java.io.File;
import java.io.FileWriter;
public class FileWriterTest {
    public static void main(String[] args) {
        FileWriter fw=null;
        try {
            fw=new FileWriter(new File("D:/VS_Code_Java/dir1/test.txt"),true);
            //加上true会在原文件末尾追加  不加会覆盖原文件的内容
            fw.write("today is Monday");
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            if(fw!=null)
            {
                try {
                    fw.close();
                } catch (Exception e) {
                   e.printStackTrace();
                }
            }
        }
    }
}

4.缓冲流（处理流）

• 缓冲流可以提高数据读写的速度
• 缓冲流要嵌套在相应的节点流之上
• BufferedInputStream
• BufferedOutputStream
• BufferedReader
• BufferedWriter
• 使用缓冲流读取数据时，缓冲流会一次性从文件中读取一定的文件存放在缓冲区中，直到缓冲区满了再从文件中重新读取
• 使用缓冲流写入字节时，不会直接写入到文件，先写到缓冲区，缓冲区写满了，才将缓冲区中的数据一次性写到文件中
• 使用flush可以手动将buffer中的内容写入文件

package javabasis.chapter13;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;

public class BufferStreamTest {
    public static void main(String[] args) {
        BufferedReader br=null;
        BufferedWriter bw=null;


        try {
            br=new BufferedReader(new FileReader("D:/VS_Code_Java/javabasis/chapter13/source.txt"));
            bw=new BufferedWriter(new FileWriter("D:/VS_Code_Java/javabasis/chapter13/desc.txt"));

            String str;
            while((str=br.readLine())!=null)//一次性读取一行
            {
                bw.write(str);
                bw.newLine();
            }
            bw.flush();
        } catch (Exception e) {
        e.printStackTrace();
        }finally{
            try {
                if(bw!=null)
                bw.close();
            } catch (Exception e) {
               e.printStackTrace();
            }

            try {
                if(br!=null)
                br.close();
            } catch (Exception e) {
              e.printStackTrace();
            }
        }

    }

}

5.转换流（处理流）

• 实现字节流和字符类之间的转化
• InputStreamReader：将InputStream转化为Reader
• OutputStreamWriter：将Writer转化为OutputStream

package javabasis.chapter13;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class TransStream {

    public static void main(String[] args) throws Exception {
          //创建字节流
        FileInputStream fin=new FileInputStream("D:/VS_Code_Java/javabasis/chapter13/source.txt");
        FileOutputStream fout=new FileOutputStream("D:/VS_Code_Java/javabasis/chapter13/desc.txt");
        
        InputStreamReader byte2char=new InputStreamReader(fin,"UTF-8");//字节流--->字符流  编码要一致 不然会乱码
        OutputStreamWriter char2byte=new OutputStreamWriter(fout,"UTF-8");//字符类--->字节流
        
        BufferedReader br=new BufferedReader(byte2char);
        BufferedWriter bw=new BufferedWriter(char2byte);

        String str=null;
        while((str=br.readLine())!=null)
        {
              bw.write(str);
              bw.newLine();
              bw.flush();
        }
        bw.close();
        br.close();
    
    }
    }

6.对象流

• ObjectInputStream
• ObjectOutputStream
• 序列化：用ObjectInputStream保存对象或基本类型
• 反序列化：用ObjectOutputStream读取对象或基本类型
• ObjectInputStream ObjectOutputStream不能序列化static和transient修饰的成员变量
• 对象序列化的条件：实现Serializable或Externalizable接口之一
• 如果对象里面有其他引用类型（String除外），该引用类型也必须实现Serializable接口
• 基本数据类型

package javabasis.chapter13;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class SerializableTest {
    public static void main(String[] args) throws Exception, IOException {
       //序列化
        ObjectOutputStream out=new ObjectOutputStream(new FileOutputStream("D:/VS_Code_Java/javabasis/chapter13/Person.txt"));
       Person p1=new Person("Mike", 11, new Pet("dog"));
       Person p2=new Person("Tom", 12, new Pet("cat"));
       out.writeObject(p1);
       out.writeObject(p2);
       out.flush();
       out.close();

       //反序列化
       ObjectInputStream in=new ObjectInputStream(new FileInputStream("D:/VS_Code_Java/javabasis/chapter13/Person.txt"));
       Person p3= (Person) in.readObject();
       Person p4= (Person) in.readObject();
       System.out.println(p3);
       System.out.println(p4);
 
   
    }
    
}
class Person implements Serializable{
     String name;
     int age;
     Pet pet;
     public Person(String name,int age,Pet pet)
     {
         this.name=name;
         this.age=age;
         this.pet=pet;
     }
     public String toString()
     {
         return "name:"+name+" age:"+age+" "+pet;
     }
}
class Pet implements Serializable{
    String name;
    public Pet(String name)
    {
        this.name=name;
    }
    public String toString()
    {
        return "pet:"+name;
    }
}
name:Mike age:11 pet:dog
name:Tom age:12 pet:cat

7.随机存取文件流

package javabasis.chapter13;

import java.io.FileNotFoundException;
import java.io.RandomAccessFile;

public class RandomAccessFileTest {
    public static void main(String[] args) throws Exception {
        RandomAccessFile raf=new RandomAccessFile("javabasis/chapter13/source.txt", "rw");
        raf.seek(2);//定位到文件某个位置开始读取
        byte b[]=new byte[1024];

        raf.read(b,0,5);
        System.out.println(new String(b,0,5));
        raf.close();

    }
}