各种IO流操作文件

IO流的继承关系：

 

文件有关操作

文件类对象构造

        /*文件类对象构造*/
        File f1=new File("D:\\idea_saved\\java.txt");//①第一种，绝对路径
        File f2=new File("D:\\idea_saved","java.txt");//②第二种，路径和文件名断开的绝对路径

        File f3=new File("D:\\idea_saved\\filetest");//③第三种，用别的文件类来创建对象
        File f4=new File(f3,"java.txt");

通过文件类对象创建文件

 /*文件类对象创建*/
        System.out.println(f1.createNewFile());//①创建一个新文件，true如果命名文件不存在并被成功
                                               //创建; false如果命名文件已经存在
        System.out.println(f3.mkdir()); //②创建一个新文件夹，如果父目录不存在创建失败
        File f5=new File("D:\\idea_saved\\filetest1\\filetest2");
        System.out.println(f5.mkdirs()); //③创建一个新文件夹，包括创建必需但不存在的父目录。

文件的获取和判断功能

       /*文件类的获取和判断功能*/
        System.out.println(f1.isFile());   //是否是文件，true当且仅当该抽象路径名表示的文件存在并
                                           //且是正常文件时; 否则为false
        System.out.println(f3.isDirectory());//是否是目录，true当且仅当该抽象路径名表示的文件存在
                                             // 且为目录时; 否则为false
        System.out.println(f4.exists()); //是否存在，true当且仅当存在由此抽象路径名表示的文件
                                             //或目录时; false否则
        System.out.println(f1.getAbsolutePath());//获取绝对路径字符串
        System.out.println(f1.getPath());  //将抽象路径转化为路径字符串，这是定义的时候的参数路径
        System.out.println(f1.getName());  //获取文件的名字
        System.out.println(f3.list());   //获取该目录下文件和目录的名称字符串组，如果目录为空，
                                         //则该数组将为空。
                                        // 如果此抽象路径名不表示目录，或返回I/O错误，返回null 
        System.out.println(f2.delete());//删除文件；true当且仅当成功删除时; 否则为false

字节流

import java.io.*;

public class in_outputstreamdemo {
    public static void main(String[] args) throws IOException {
        /*字节流构造*/
        FileOutputStream fos=new FileOutputStream("D:\\idea_saved\\filetest\\java.txt3");
        FileOutputStream fos2=new FileOutputStream("D:\\idea_saved\\filetest\\java2.txt",true);//表示在文件后附加
        FileInputStream fis =new FileInputStream("D:\\idea_saved\\filetest\\java.txt");

        /*字节输出流output三种方式*/
        fos2.write(48);                                  //第一种
        fos2.write("hello world\r\n".getBytes());        //第二种
        fos2.write("hello".getBytes(),0,2);//第三种，从h开始写，写两个
        fos.close();fos2.close();

        /*字节输入流input两种方式*/
        byte[] bys= new byte[5];                             //第一种方式
        int  len = fis.read(bys);
        System.out.println(new String(bys,0,len));

        byte[] bys2= new byte[1024];                           //第二种方式循环的方式去读
        int len2;
        while((len2=fis.read(bys2))!=-1){
          System.out.println(new String(bys2,0,len));
        }

        //字节输出流异常处理
        FileOutputStream fos3=null;
        try {
            fos3=new FileOutputStream("D:\\idea_saved\\filetest\\java.txt");
            fos3.write("hello".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(fos3!=null){
                try {
                    fos3.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        //字节流复制文件
        FileOutputStream fos4=new FileOutputStream("D:\\idea_saved\\filetest\\java3.txt");
        FileInputStream fis3 =new FileInputStream("D:\\idea_saved\\filetest\\java.txt");
        byte[] bys3=new byte[1024];
        int len3;
        while((len3=fis3.read(bys3))!=-1){
            fos4.write(bys3,0,len3);
        }
        fos4.close();
        fis3.close();
    }
}

字符流：

import java.io.*;
public class reader_writerdemo {
    public static void main(String[] args) throws IOException {
        /*构造方法*/
        OutputStreamWriter os=new
                OutputStreamWriter(new FileOutputStream("D:\\idea_saved\\filetest\\java3.txt"),"utf-8");
        InputStreamReader  is=new
                InputStreamReader(new FileInputStream("D:\\idea_saved\\filetest\\java.txt"));

        /*字符输出流的五种方式*/
        os.write("中国");
        os.write(97);os.flush();
        char[] chs={'a','b','c'}; os.write(chs);
        os.write(chs,0,chs.length);
        os.write("abcde",0,"abcde".length());


        /*字符输入流的两种方式*/
        int ch;
        while((ch=is.read())!=-1){
            System.out.println((char)ch);
        }
    }

    //字符流复制文件,InputStreamReader OutputStreamWriter
    void copy() throws Exception {
        OutputStreamWriter os2=new
                OutputStreamWriter(new FileOutputStream("D:\\idea_saved\\filetest\\java3.txt"));
        InputStreamReader  is2=new
                InputStreamReader(new FileInputStream("D:\\idea_saved\\filetest\\java2.txt"));
        char[] chs2=new char[1024];
        int len;
        while((len= is2.read(chs2))!=-1){
            os2.write(chs2,0,len);
            os2.flush();
        }
        is2.close();
        os2.close();

    }

    //上述类的子类复制文件,简洁版 FileReader FileWriter
    void copy2() throws Exception {
        FileReader fr=new FileReader("D:\\idea_saved\\filetest\\java.txt");
        FileWriter fw=new FileWriter("D:\\idea_saved\\filetest\\java3.txt");
        char[] chs3=new char[1024];
        int len2;
        while((len2= fr.read(chs3))!=-1){
            fw.write(chs3,0,len2);
            fw.flush();
        }
        fr.close();
        fw.close();
    }

    //字符缓冲流特殊方法BufferedReader  BufferedWriter
    void copy3() throws Exception {
        BufferedReader br=new BufferedReader(new FileReader("D:\\idea_saved\\filetest\\java.txt"));
        BufferedWriter bw=new BufferedWriter(new FileWriter("D:\\idea_saved\\filetest\\java3.txt"));
        String line;
        while((line=br.readLine())!=null){
            bw.write(line);
            bw.newLine();
            bw.flush();
        }
        br.close();
        bw.close();
    }

}