Java IO流-----节点流（文件流）说明

最新推荐文章于 2021-06-29 15:32:51 发布

没有阳光，也一样灿烂

最新推荐文章于 2021-06-29 15:32:51 发布

阅读量165

点赞数

分类专栏： Java基础

本文链接：https://blog.youkuaiyun.com/insist_to_learn/article/details/110489754

版权

Java基础专栏收录该内容

54 篇文章

订阅专栏

节点流（文件流）

字符流

FileReader

package www.bh.c.iotest;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class Test1 {
    public static void main(String[] args)  {
        /*
        将calss下的hello.txt文件内容读入到内存中，并输出到控制台
         */
        FileReader fileReader = null;
        try {
            //1.实例化File类对象，指明要操作的文件
            File file = new File("calss\\hello.txt");
            //2.提供具体的流
            fileReader = new FileReader(file);
            //3.数据的读入
            //read():返回读入文件的一个字符，如果达到文件末尾，则返回-1
            //方式一：
//        int read = fileReader.read();
//        while (read!=-1){
//            System.out.print((char) read);
//            read=fileReader.read();
//        }
            //方式二：
            int read;
            while ((read=fileReader.read())!=-1){
                System.out.print((char)read);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fileReader!=null){
                try {
                    //4.流的关闭操作
                    fileReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
/*
注意点：
1.read()的理解：返回读入文件的一个字符，如果达到文件末尾，则返回-1
2.异常的处理：为了保证流资源一定可以执行关闭操作，需要使用try-catch-finally处理
3.读入的文件一定要存在，否则就会报错（FileNotFoundException）
 */

package www.bh.c.iotest;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class Test2 {
    public static void main(String[] args)  {
       /*
       使用read()的重载方法，对read()进行升级
        */
        FileReader fileReader = null;
        try {
            //1.实例化File类对象，指明要操作的文件
            File file = new File("calss\\hello.txt");
            //2.提供具体的流
            fileReader = new FileReader(file);
            //3.读取数据
            //read(char[] cbuf):返回每次读取cbuf数组中的字符个数，如果达到文件末尾，则返回-1
            char[] cbuf = new char[3];
            int len;
            while ((len=fileReader.read(cbuf))!=-1){
    //            方式一：
    //            for (int i=0;i<len;i++){
    //                System.out.print(cbuf[i]);
    //            }
                //方式二：
                String s = new String(cbuf, 0, len);
                System.out.print(s);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fileReader!=null){
                try {
                    //4.关闭流
                    fileReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

FileWriter

package www.bh.c.iotest;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

public class Test3 {
    public static void main(String[] args)  {
     //从内存中写出数据到硬盘中
        FileWriter fileWriter = null;
        try {
            //1.提供File类的对象，指明写出到的文件
            File file = new File("calss\\hello1.txt");
            //2.提供FileWrite的对象，用于数据的写出
            fileWriter = new FileWriter(file,true);
            //3.数据写出操作
            fileWriter.write("白日依山尽\n");
            fileWriter.write("黄河入海流\n");
            fileWriter.write("欲穷千里目\n");
            fileWriter.write("更上一层楼\n");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.关闭流资源
            if (fileWriter!=null){try {
                fileWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }}
        }
    }
}
/*
注意点：
1.输出操作，对应的File可以不存在，并不会报异常
2.File对应的硬盘中的文件如果不存在，在输出的过程中，会自动创建此文件
  File对应的硬盘中的文件如果存在：
  1）如果流使用的构造器是：FileWriter(file,false)/FileWriter(file):对原有的文件不会覆盖
  2）如果流使用的构造器是：FileWriter(file,true)：不会对原有文件覆盖，而是在原有文件基础上追加内容
 */

package www.bh.c.iotest;
import java.io.*;

//文件的读入和写出
public class Test4 {
    public static void main(String[] args) {
        FileReader fileReader = null;
        FileWriter fileWriter = null;
        try {
            //1.创建File类的对象，指明文件读入和写出的对象
            File file = new File("calss\\hello1.txt");
            File file1 = new File("calss\\hello2.txt");
            //2.创建输入流和输出流的对象
            fileReader = new FileReader(file);
            fileWriter = new FileWriter(file1,true);
            //3.数据读入和输出
            char[] cbuf=new char[3];
            int len;//记录每次读入到cbuf数组中的个数
            while ((len=fileReader.read(cbuf))!=-1){
                //每次写出len个字符
                fileWriter.write(cbuf,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
             //4.关闭流资源
            try {
                if (fileReader!=null)
                fileReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (fileWriter!=null)
                fileWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
//注：不能使用字符流来处理图片等字节数据

字节流

FileInputStream

//判断能否使用字节流FileInputStream处理文本文件：
package www.bh.c.iotest;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class Test5 {
    public static void main(String[] args) throws IOException {
        FileInputStream fileInputStream = null;
        try {
            //1.创建File类对象，指明读入文件的对象
            File file = new File("calss\\hello1.txt");
            //2.创建读入流的对象
            fileInputStream = new FileInputStream(file);
            //3.读入文件
            byte[] c=new byte[3];
            int len;
            while ((len=fileInputStream.read(c))!=-1){
                String s = new String(c, 0, len);
                System.out.println(s);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                //4.关闭流资源
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
/*
注：1.使用字节流FileInputStream处理文本文件，可能出现乱码
2.对于文本文件（.txt,.java,.c,.cpp）,使用字符流处理
3.对于非文本文件（.jpg,.mp3,mp4,.avi,.doc,.ppt,...）,使用字节流处理
*/

FileOutputStream

package www.bh.c.iotest;
import java.io.*;

//实现图片的复制操作
public class Test6 {
    public static void main(String[] args) {
        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;
        try {
            //1.创建File类的对象，指明文件读取和写入的对象
            File file = new File("calss\\Java.png");
            File file1 = new File("calss\\Java1.png");
            //2.创建流
            fileInputStream = new FileInputStream(file);
            fileOutputStream = new FileOutputStream(file1);
            //3.复制图片
            byte[] b=new byte[5];
            int len;
            while ((len=fileInputStream.read(b))!=-1){
                fileOutputStream.write(b,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.关闭流资源
            if (fileInputStream!=null){
                try {
                    fileInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fileOutputStream!=null){
                try {
                    fileOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

package www.bh.c.iotest;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
//指定路径下文件的复制
public class Test7 {
    public static void main(String[] args) {
        Test7 test7 = new Test7();
        String srcPath="E:\\Test\\calss\\copyFile\\FileWriter写出数据.avi";
        String destPath="E:\\Test\\calss\\copyFile\\FileWriter写出数据1.avi";
        long startTime=System.currentTimeMillis();
        test7.copyFile(srcPath,destPath);
        long endTime=System.currentTimeMillis();
        System.out.println("复制花费的时间为："+(endTime-startTime));
    }

    public void copyFile(String srcPath,String destPath){
        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;
        try {
            //1.创建File类的对象，指明文件读取和写入的对象
            File file = new File(srcPath);
            File file1 = new File(destPath);
            //2.创建流
            fileInputStream = new FileInputStream(file);
            fileOutputStream = new FileOutputStream(file1);
            //3.复制图片
            byte[] b=new byte[1024];
            int len;
            while ((len=fileInputStream.read(b))!=-1){
                fileOutputStream.write(b,0,len);
            }
        } catch (
                IOException e) {
            e.printStackTrace();
        } finally {
            //4.关闭流资源
            if (fileInputStream!=null){
                try {
                    fileInputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fileOutputStream!=null){
                try {
                    fileOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}