java——io文件流（详细、全面、快速掌握）

本篇主要对java中的io流进行总结，以复制文件操作为例对文件输入流(FileInputStream)、输出流(FileOutputStream)以及缓冲区的使用：BufferedInputStream、BufferedOutputStream以及字符输入流(BufferedReader)输出流(PrintWriter)进行讲解，最后讲解了序列化：将对象输出为文件和反序列化：将文件读取为对象进行了演示和讲解；以下代码可以直接复制到idea中运行，便于理解掌握；

第一篇：File的基本用法以及操作

package java_io;

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

//TODO io-文件流：
public class java_42 {
    public static void main(String[] args) throws IOException {
        //创建文件对象，使用文件路径关联系统文件；
        //TODO File:文件类型(可以是文件也可以是文件夹)，属于java.io
        String filepath="D:\\java_study\\data";
        File file=new File(filepath);
        System.out.println(file);
//        //判断当前的file是否是文件：判断是文件还是文件夹，是文件返回true
//        System.out.println(file.isFile());
//        //判断当前file是文件夹还是文件：是文件夹返回true：
//        System.out.println(file.isDirectory());
        //判断文件是否关联上，也就是是否存在：
        if(file.exists()){
            //文件存在，已经关联上；
            if(file.isFile()){
                System.out.println("文件对象关联的是一个文件");
                System.out.println(file.getName());
                System.out.println(file.length());
            }else{
                System.out.println("文件对象关联的是一个文件目录（夹）");
                System.out.println(file.getName());
                //获取文件夹下的一级文件名称：
                String[]list=file.list();
                System.out.println("文件夹中所有的文件：");
                for(String one:list){
                    System.out.println(one);
                }

                //获取这个文件夹下的一级文件对象：
                File[]files=file.listFiles();
                for(File one:files){
                    System.out.println(one);
                }
                //然后查看子文件夹下的文件：
                for(String one:files[0].list()){
                    System.out.println(one);
                }


            }
        }else{
            //文件不存在；
            System.out.println("文件对象不存在，没有关联成功！");
            //如果文件不存在，想创建多级文件夹的话：
            //file.mkdirs();
            //如果文件不存在，想创建一个文件的话：
            //file.createNewFile();

        }

    }
}

第二篇：文件输入输出流

package java_io;

import java.io.*;

//TODO 文件复制：
public class java_43 {
    public static void main(String[] args) {
        File firstfile=new File("D:\\java_study\\data\\word.txt");//源文件；
        File desfile=new File("D:\\java_study\\data\\new");//想复制的地点，也就是输出的地点；
        //TODO 文件输入流：
        FileInputStream in=null;
        //TODO 文件输出流：
        FileOutputStream out=null;
        try{
            //由于这里可能会出现异常，所以加上try-catch
            in=new FileInputStream(firstfile);
            out=new FileOutputStream(desfile);
            //TODO 注意：如果文件数据已经被全部读取完毕，那么再去读取数据读取的结果就是-1，即无效数据；
            /*下面这样只能读一个，无法完整的将文件中的数据全部读取出来；所以需要加while循环，结合不是-1就继续读数据：
            //打开阀门，流转数据：（输入）
            int data=in.read();
            //打开阀门，流转数据：（输出）
            out.write(data);*/
            int data=0;
            while((data=in.read())!=-1){
                out.write(data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //防止空指针，先判断一下：
            if(in!=null){
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(out!=null){
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }

    }
}

第三篇：缓冲流

package java_io;

import java.io.*;
import java.nio.Buffer;

//TODO 缓冲流 对于java_43中那种方法效率很慢，因为每次打开阀门只能读取一个数据，然后需要打开多次，
// 因此想设置一个缓冲区，每次将所有数据先都读过来存放到缓冲区，然后关闭读取阀门，将数据都输入到目的地；这样只需要打开一次阀门即可；
public class java_44 {
    public static void main(String[] args) {
        File kaishifile=new File("D:\\java_study\\data\\word.txt");
        File desfile=new File("D:\\java_study\\data\\new");
        FileInputStream in=null;
        FileOutputStream out=null;
        BufferedInputStream inbuff=null;
        BufferedOutputStream outbuff=null;
        //TODO 缓冲区
        byte[]cache=new byte[1024];
        int data=0;
        try {
            in=new FileInputStream(kaishifile);
            inbuff=new BufferedInputStream(in);
            out=new FileOutputStream(desfile);
            outbuff=new BufferedOutputStream(out);
            while((data=inbuff.read(cache))!=-1){
                outbuff.write(cache,0,data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(inbuff!=null){
                try {
                    inbuff.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(outbuff!=null){
                try {
                    outbuff.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

第四篇：字符流

package java_io;

import java.io.*;

//TODO 字符流：前面都是一个字节一个字节的读取，现在采用字符流，先读取字节后转换为字符在做处理，多个字符就可以组成字符串；此时如果想对读取的内容做处理的时候会非常方便；可以进行更改等操作；
public class java_45 {
    public static void main(String[] args) {
        File kaifile=new File("D:\\java_study\\data\\word.txt");
        File desfile=new File("D:\\java_study\\data\\new1");
        //字符输入流：
        BufferedReader reader=null;
        //字符输出流：
        PrintWriter writer=null;
        try {
            reader=new BufferedReader(new FileReader(kaifile));
            writer=new PrintWriter(desfile);
            //TODO 打开阀门，数据读取：
            //读取文件中的一行数据（字符串）：
            String line=null;
            while((line=reader.readLine())!=null){
                System.out.println(line);//查看读取的是什么
                writer.println(line);
            }
            //刷写数据：就是将内部缓冲区的数据强制输出到目的地，说如果读取了没有满，那么也要到出去，然后再重新读，不然会保存着原来的数据；
            writer.flush();

        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(reader!=null){
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(writer!=null){
                writer.close();
            }
        }


    }
}

第五篇：序列化和反序列化

package java_io;

import java.io.*;

//TODO 序列化：将对象输出成文件，反序列化：将文件读取为对象；
public class java_46 {
    public static void main(String[] args) {
        File dataFile=new File("D:\\java_study\\data\\obj.dat");

//        //对象输出流：
//        ObjectOutputStream objectout=null;
//        FileOutputStream out=null;
        //对象输入流：
        ObjectInputStream objectin=null;
        FileInputStream in=null;
        try {
            //输出操作：
//            out=new FileOutputStream(dataFile);
//            objectout=new ObjectOutputStream(out);
//            User user=new User();
//            objectout.writeObject(user);//此处需要添加字节类型，也就是说将对象转化为字节，JVM自动转，需要将下面User类实现一个接口
//            objectout.flush();
            //输入操作：
            in=new FileInputStream(dataFile);
            objectin=new ObjectInputStream(in);
            Object object = objectin.readObject();
            System.out.println(object);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
//            if(objectout!=null){
//                try {
//                    objectout.close();
//                } catch (IOException e) {
//                    e.printStackTrace();
//                }
               if(objectin!=null){
                   try {
                       objectin.close();
                   } catch (IOException e) {
                       e.printStackTrace();
                   }
               }
        }
    }
}
class User implements Serializable{

}