zoukankan      html  css  js  c++  java
  • 【Java的IO流之文件字节输入输出流 24】

    一、文件通常是由一连串的字节或者字符构成,组成文件的字节序列称为字节流,组成文件的字符列称为字符流

    Java中可根据流的方向可分为输入流和输出流

    输入流是将文件或其他输入设备的数据加载到内存的过程(数据转换成ASSIC码)

    输出流恰恰相反,是将内存中的数据保存到文件或其他输出设备

    二、Java.IO常用流

    字节流:

    FIleInputStream

    FileOuputStream

    字符流:

    FileReader

    FileWriter

    包装流:

    BufferedReader

    BufferedWriter

    转换流:

    InputStreamReader

    OuputStreamReader

    打印流:

    PrintStream

    PrintWriter

    对象流:

    ObjectInputStream

    ObjectOuputStream

    文件类:

    java.io.File

    三、文件字节输入流:FileInputStream:从文件系统中的某个文件中获得输入字节。用于读取诸如图像数据之类的原始字节流,要读取字节流,请考虑FileReader

    package com.JavaStudy.studyIo0628;
    
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    
    /**
     * @Author wufq
     * @Date 2020/6/28 14:22
     * FileInputStream  --> 构造方法:FileInputStream(String name)(name指文件的路径)
     * -->int read()方法:读取文件内的一个数据字节
     */
    public class FileInputStreamTest01 {
        public static void main(String[] args){
            FileInputStream file = null;
    
            try {
                file = new FileInputStream("/Users/wufq/Desktop/test.txt");
    
                int i1 = file.read();
                System.out.println(i1);//97
    
                int i2 = file.read();
                System.out.println(i2);//98
    
                int i3 = file.read();
                System.out.println(i3);//99
    
                int i4 = file.read();
                System.out.println(i4);//100
    
                int i5 = file.read();
                System.out.println(i5);//-1 -->read没有读取到文件数据时返回-1
    
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                //为了保证流的关闭
                if(file !=null){
                    try {
                        file.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
    
        }
    }

    上面程序读取文件数据比较繁琐,多次写read,下面是利用循环来读取

    package com.JavaStudy.studyIo0628;
    
    import java.io.FileInputStream;
    import java.io.IOException;
    
    /**
     * @Author wufq
     * @Date 2020/6/28 14:44
     */
    public class FileInputStreamTest02 {
        public static void main(String[] args){
            FileInputStream file1 = null;
    
            try {
                file1 = new FileInputStream("/Users/wufq/Desktop/test.txt");
    
                int temp = 0;
                while ((temp=file1.read())!= -1){
                    System.out.println(temp);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                if(file1!=null){
                    try {
                        file1.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
    
        }
    }
    ====执行结果====
    97
    98
    99
    100

    2、一次读取多个字节

    一种常用的读取文件的方式,

    使用“int read();”方法读取硬盘访问次数太频繁。

    效率低,伤硬盘

    使用“int read(byte[] bytes)”:

    读取:一次读取多个字节。该方法执行结束之后返回值是该次读取到的字节数。读取不到返回-1

    返回:读入缓冲区的字节总数,如果文件末尾没有数据可读则返回-1

    package com.JavaStudy.studyIo0628;
    
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    
    /**
     * @Author wufq
     * @Date 2020/6/28 15:05
     * read(byte[] bytes)  -->一次可以读取多个数据
     */
    public class FileInputStreamTest03 {
        public static void main(String[] args){
    
            FileInputStream fis = null;
    
            try {
                //创建文件字节输入流
                fis = new FileInputStream("/Users/wufq/Desktop/test.txt");
                //开始读
                byte[] bs = new byte[4];//一次只能读取4个字节
                int countRead = fis.read(bs);// int read(byte[] bytes) -->返回读入缓冲区的字节总数,如果文件末尾没有数据则返回-1
    
                //把读取文件内的数据已字符串的形式输出
                String str = new String(bs,0,countRead);
                System.out.println(str);
    
                countRead = fis.read(bs); // -->test文件内是6个数,而bs数组只存放了4个字节,
                // 所以第一次读取文件放到缓冲池里面的只有4个数,第二次读取文件放到缓存池只有两个字节
                String str1 = new String(bs,0,countRead);
                System.out.println(str1);
    
                //读取不到返回-1
                countRead = fis.read(bs);
                String str2 = new String(bs,0,countRead);
                System.out.println(str2);
    
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }catch (IOException e) {
                e.printStackTrace();
            }finally {
                if(fis!= null){
                    try {
                        fis.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    
    }

    利用循环来控制读取数据

    package com.JavaStudy.studyIo0628;
    
    import java.io.FileInputStream;
    import java.io.IOException;
    
    /**
     * @Author wufq
     * @Date 2020/6/28 17:35
     */
    public class FileInputStreamTest04 {
        public static void main(String[] args){
            FileInputStream fis = null;
    
            try {
                //创建文件字节输入流
                fis = new FileInputStream("/Users/wufq/Desktop/test.txt");
                //定义数组,用于存放一次可以读取多个数据的字节数
                byte[] bytes = new byte[4];
                //初始化字节总数 --->开始读取,读取后返回缓冲池内的字节总数
                int countRead = 0;
    
                //循环控制返回读取文件内的字节总数,直到不能读取不到(-1)停止
                while ((countRead = fis.read(bytes))!=-1){
                    //把数组中的元素转换成字符串
                    String string = new String(bytes,0,countRead);
                    System.out.println(string);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if(fis !=null){
                    try {
                        fis.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    ====执行结果====
            abcd
            ef

    四、文件字节输出流:FileOuputStream:将数据写入文件内

    package com.JavaStudy.studyIo0628;
    
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    /**
     * @Author wufq
     * @Date 2020/6/29 11:47
     */
    public class FileOuputStreamTest01 {
        public static void main(String[] args){
            FileOutputStream fos = null;
            try {
                //创建输出流
                fos= new FileOutputStream("/Users/wufq/Desktop/test.txt");//先将文件内的数据全部清除,然后写入新的数据
                fos = new FileOutputStream("/Users/wufq/Desktop/test.txt",true);//不清除文件内的数据,写入的数据在原数据后追加
    
                //需要写入的数据
                String msg ="linux";
                //将msg字符编码为byte序列,并将结果存储到byte数组内
                byte[] bytes = msg.getBytes();
    
                fos.write(bytes);//将数组内的数据全部写入文件
                fos.write(bytes,2,2);//write(arr,int off,int len):arr代表数组,off代表偏移量,len代表长度。
                // 整体意思:将bytes数组内偏移量为2,长度为2的数据写入文件-->即:把nu写入文件内
    
                //手动刷新保证所有数据全部写入文件
                fos.flush();
    
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                if(fos!=null){
                    try {
                        fos.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
    
        }
    }

    五、练习题

    1、把A文件内的数据复制到B文件内(并且不能覆盖掉B文件内的原有数据)

    package com.JavaStudy.studyIo0628;
    
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    /**
     * @Author wufq
     * @Date 2020/6/29 14:06
     * 需求:从一个文件内读取数据,写入到另外一个文件内
     */
    public class FileInOuputStream01 {
        public static void main(String[] args){
            FileInputStream fis = null;
            FileOutputStream fos = null;
    
            try {
                fis = new FileInputStream("/Users/wufq/Desktop/copy.txt");
                fos = new FileOutputStream("/Users/wufq/Desktop/paste.txt",true);
    
                byte[] bytes = new byte[4];
                while ((fis.read(bytes))!= -1){
                        String msg = new String(bytes);
                        byte[] bytes1 = msg.getBytes();
                        fos.write(bytes1);
                }
                fos.flush();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }catch (IOException e){
                e.printStackTrace();
            } finally {
                if(fis!=null&fos!=null){
                    try {
                        fis.close();
                        fos.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
    
            }
        }
    }
    ====执行结果====
    copy的文件内容:testAAAA
    paste的文件内容:AAA
    执行后:
    paste由AAA--->AAAtestAAAA

    2、把c盘下的图片拷贝到D盘

    package com.JavaStudy.studyIo0628;
    
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    /**
     * @Author wufq
     * @Date 2020/6/29 14:50
     * 把c盘下的图片拷贝到D盘
     */
    public class FileInOuputSteam02 {
        public static void main(String[] args){
            FileInputStream fis = null;
            FileOutputStream fos = null;
    
            try {
                fis = new FileInputStream("/Users/wufq/Desktop/11.jpg");
                fos = new FileOutputStream("/Users/wufq/Desktop/bank/11.jpg");
    
                byte[] b1 = new byte[1024];
                while ((fis.read(b1))!=-1){
                    fos.write(b1);
                }
                fos.flush();
    
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch(IOException e){
                e.printStackTrace();
            } finally {
                if(fis!=null&fos!=null){
                    try {
                  //谁先定义后关闭谁
                        fos.close();
                fis.close(); }
    catch (IOException e) { e.printStackTrace(); } } } } }

    两则的区别:

    读写文件:读取文本内容时,需要把读取到的字节数转换为字符,然后在把字符写入到文件内

    读写图片:只需要读取,然后直接写入(不需要转换成字符串)

  • 相关阅读:
    vue中的 computed 和 watch 的区别
    mysql8.0 初始化数据库及表名大小写问题
    sql server alwayson 调整数据文件路径
    zabbix 自定义监控 SQL Server
    mysql 创建用户及授权
    mysql 设置从库只读模式
    mysql8.0 主从复制安装及配置
    centos8.0安装mysql8.0
    centos8替换阿里数据源
    npm publish 报错 【you or one of your dependencies are requesting a package version that is forbidden by your security policy】
  • 原文地址:https://www.cnblogs.com/frankruby/p/13188173.html
Copyright © 2011-2022 走看看