14、java——IO流

2021/7/21 14:35:50

编程Tag： string new io Java file 字节 out public 14

本文主要是介绍14、java——IO流，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

3、IO流

（1）前提需求: 读写文件内部的内容,上传,下载

（2）流: 管道数据以先入先出的方式进行流动，数据源--数据-->目的地

（3）io包: 一系列io相关类 File...

（4）流的分类:

①按照流向分:

输入流，输出流

(以大脑为中心,以程序为中心,明确数据源和目的地,能够确定输入还是输出)

②按照操作单元分;

字节流 : 万能流,任意内容都能转为字节，字符流 : 只能传输纯文本的内容

③按照功能分:

节点流 : 真实做读入写出的流，功能流 : 增强节点流的功能,加强性能

分类之间是相辅相成的

（5）字节流:

①字节输入流 InputStream

文件字节输入流 FileInputStream

功能: 节点流流向分:输入流操作单元:字节流

功能: 读入read() 关闭close

②字节输出流 OutputStream

public class Class001_IO {

    public static void main(String[] args) throws IOException {

        //FileInputStream(File file) 通过打开与实际文件的连接来创建 FileInputStream ，该文件由文件系统中的 File对象 file命名。

        File src = new File("D://test2.txt"); //数据源

        //创建流

        InputStream is = new FileInputStream(src);

        //读入数据 int read() 从此输入流中读取一个字节的数据。  读到文件末尾返回-1

        int num = is.read();

        //处理数据

        System.out.println((char)num);

        System.out.println((char)(is.read()));

        System.out.println((char)(is.read()));

        System.out.println(is.read());

        //关闭流

        is.close();

    }

}

③read() 从此输入流中读取一个字节的数据。读到文件末尾返回-1

每次读取一个字节,重复通过循环读入,可以简化代码结构

public class Class002_IO {

    public static void main(String[] args) throws IOException {

        //创建流

        //FileInputStream (String name) 通过打开与实际文件的连接来创建 FileInputStream ，该文件由文件系统中的路径名 name命名。

        InputStream is = new FileInputStream("D://test2.txt");

        //读入数据

        int num = -1;

        while((num=is.read())!=-1){

            //处理数据

            System.out.println((char)num);

        }

        //关闭流

        is.close();

    }

}

④public byte[] readAllBytes() throws IOException

从输入流中读取所有剩余字节。此方法将阻塞，直到读取了所有剩余字节并检测到流结束，或者抛出异常。此方法不会关闭输入流。

当此流到达流的末尾时，此方法的进一步调用将返回空字节数组，请注意，此方法适用于方便将所有字节读入字节数组的简单情况。它不用于读取包含大量数据的输入流。起始版本: java9

public class Class004_IO {

    public static void main(String[] args) throws IOException {

        //1.构建流

        InputStream is = new FileInputStream("D://test2.txt");



        //2.读入所有数据

        byte[] arr = is.readAllBytes();

        //3.处理数据

        System.out.println(new String(arr));



        //4.关闭

        is.close();

    }

}

（6）字节输出流

①OutputStream 此抽象类是表示输出字节流的所有类的超类。

②FileOutputStream : 文件输出流,将数据写出到指定文件中

③注意:如果目的地文件不存在,系统会自动创建

输出流如果目的地文件存在,内容默认覆盖,设置追加

（7）文件拷贝，数据源--> 读入---> 程序 --> 写出 --> 目的地

步骤:①创建流(输入输出)②准备小汽车字节数组③读入-->写出④刷出⑤关闭(后打开的先关闭)

public class Class006_CopyFile {

    public static void main(String[] args){

        //1.创建流(输入 输出)

        //作用域提升,为了能够在finally中使用

        InputStream is = null;

        OutputStream os = null;

        try {

            is = new FileInputStream("D://test.txt");

            os = new FileOutputStream("D://dest.txt");

            //2.准备小汽车 字节数组

            byte[] car = new byte[1024];

            //3.读入-->写出

            int len = -1; //记录每次读入到字节数组中数据的个数

            while((len=is.read(car))!=-1){

                //读入多少字节数据写出多少字节数据

                os.write(car,0,len);

            }

            //4.刷出

            os.flush();

        } catch (FileNotFoundException e) {

            e.printStackTrace();

        } catch (IOException e) {

            e.printStackTrace();

        } finally {

            //5.关闭(后打开的先关闭)

            //预防空指针异常出现

            if(os!=null){

                try {

                    os.close();

                } catch (IOException e) {

                    e.printStackTrace();

                }

            }

            if(is!=null){

                try {

                    is.close();

                } catch (IOException e) {

                    e.printStackTrace();

                }

            }

        }

    }

}

（8）字符输入流 : 只能读写纯文本数据

①输入流 : Reader 字符输入流的父类FileReader 文件字符输入流read()，read(char[])，close()

②输出流 : Writer

public class Class001_IO {

    public static void main(String[] args) throws IOException {

        //1.创建流

        //FileReader(String fileName)

        //FileReader(File file)

        Reader rd = new FileReader("D://test.txt");



        //2.读入

        //char ch = (char)(rd.read());

        //小汽车

        char[] car = new char[1024];



        //循环读入

        int len = -1;

        while((len = rd.read(car))!=-1){

            //3.处理数据

            System.out.println(new String(car,0,len));

        }



        //4.关闭

        rd.close();

    }

}

③输出流 : Writer 字符输出流抽象父类，FileWriter 文件字符输出流write()，flush()，close()

public class Class002_IO {

    public static void main(String[] args) throws IOException {

        //1.创建流

       /*

        //FileWriter(File file)

        //FileWriter(String fileName)

        //FileWriter(File file, boolean append)

        //FileWriter(String fileName, boolean append)

*/

        Writer rt = new FileWriter("D://test.txt",true);



        //2.准备数据

        String msg = "今天也要加油鸭!!!";



        //3.写出

        rt.write(msg);



        //4.刷出

        rt.flush();



        //5.关闭

        rt.close();

    }

}

④字符流实现文件拷贝，注意: 只能为纯文本文件

1、拷贝文件夹 :

（1）判断要拷贝的文件是文件还是文件夹

是文件: 调用工具类实现文件拷贝

是文件夹: 创建文件夹,遍历数据源文件夹,获取到所有的子文件然后重复

public static void main(String[] args) {
        copyDir("D://DDD","D://haha");
    }
    //拷贝文件夹
    public static void copyDir(String src,String dest){
        copyDir(src!=null?new File(src):null,dest!=null?new File(dest):null);
    }
    public static void copyDir(File src, File dest){
        if(src==null || dest==null){
            throw new NullPointerException();
        }
        if(!src.exists()){
            System.out.println("数据源不存在!!!");
            return;
        }
        //拷问文件夹|文件
        copyDetail(src,dest);
    }
    //实现拷贝细节
    public static void copyDetail(File src,File dest){
        //拼接完整目的地路径
        dest = new File(dest,src.getName()); //D:\haha\hehe\DDD
        //文件
        if(src.isFile()){
            //如果目的地路径不存在
           if(!dest.getParentFile().exists()){
               dest.getParentFile().mkdirs();
           }
            //文件拷贝
            CopyFileUtils.copyFile(src,dest);

        }else if (src.isDirectory()){
            //文件夹
            //创建不存在的目的地路径
            dest.mkdirs();
            //遍历数据源
            File[] arr = src.listFiles();
            for(File file:arr){   //D:\DDD\a.txt
                copyDetail(file,dest); ////D:\haha\hehe\DDD
            }
        }
    }
}

（2）按照功能分:

①节点流 : 真实做读入写出②功能流 : 加强性能③功能流都要包裹节点流使用

④缓冲流 : 功能流⑤作用: 提高读写效率

⑥字节节点流:

FileInputStream 文件流 | ByteArrayInputStream 字节数组流

FileOutputStream | ByteArrayOutputStream

⑤字节缓冲流 : 字节流功能流的一种

BufferedInputStream 字节输入缓冲流

BufferedOutputStream 字节输出缓冲流

⑥无新增功能,可以发生多态

⑦字符节点流

FileReader，FileWriter

⑧字符缓冲流

BufferedReader，BufferedWriter

存在新增方法: 不能发生多态

readLine()，newLine()

public class Class001_Buffered {

    public static void main(String[] args) throws IOException {

        //1.创建流

        InputStream is = new BufferedInputStream(new FileInputStream("D://test.txt"));

        OutputStream os = new BufferedOutputStream(new FileOutputStream("D://heihei.txt"));

        //2.拷贝

        byte[] car = new byte[1024];

        int len = -1;

        while((len=is.read(car))!=-1){

            os.write(car,0,len);

        }

        //3.刷出

        os.flush();

        //4.关闭

        os.close();

        is.close();

    }

}

2、基本数据类型流|Data流

（1）功能: 功能流操作单元: 字节流

（2）作用: 保留数据已经数据类型(基本数据类型+String)

DataInputStream，新增功能: readXxx()

DataOutputStream，新增功能: writeXxx()

（3）注意:①读入与写出的顺序要保持一致②java.io.EOFException : 读入的文件不是源文件

public class Class001_Data {

    public static void main(String[] args) throws IOException {

        readFromFile("D:/d.txt");

    }

    //读入

    public static void readFromFile(String path) throws IOException {

        //1.创建流

        DataInputStream is = new DataInputStream(new BufferedInputStream(new FileInputStream(path)));

        //2.读入

        int i = is.readInt();

        boolean flag = is.readBoolean();

        char ch = is.readChar();

        String s = is.readUTF();

        //3.处理数据

        System.out.println(i);

        System.out.println(flag);

        System.out.println(ch);

        System.out.println(s);

        //4.关闭

        is.close();

    }

    //写出

    public static void writeToFile(String path) throws IOException {

        //1.创建输出流

        DataOutputStream out = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(path)));

        //2.准备数据

        int i = 1;

        boolean flag = false;

        char ch = 'c';

        String str = "哈哈";

        //3.写出

        out.writeInt(i);

        out.writeBoolean(flag);

        out.writeChar(ch);

        out.writeUTF(str);

        //4.刷出

        out.flush();

        //5.关闭

        out.close();

    }

}

3、Object 流| 对象流 | 引用数据类型流

（1）作用: 读写对象数据|引用数据类型的数据(包含基本数据类型)

ObjectInputStream 反序列化输入流，新增功能: readObject()

ObjectOutputStream 序列化输出流，新增功能: writeObject(Object obj)

（2）序列化: 将对象数据转换一个可存储或者可传输的状态过程

（3）特性：

①先序列化后反序列化

②不能所有的类型都能序列化 java.io.Serializable

③不是所有的属性都需要序列化

④静态的内容不会序列化

⑤如果父类实现序列化,子类没有实现,可以序列化所有的成员

⑥如果子类实现序列化,父类实现,只能序列化子类成员

（4）通过序列号控制版本不一致问题:

①实现Serializable接口的类型默认生成序列号,序列号会根据成员的修改做更新 serialVersionUID = -5204947308809070324

②控制版本的统一问题: 控制类型修改之前与之后序列不变

③通过工具生成序列号: a.实现Serializable接口 b.setting设置 c.选中类名->alt+enter->生成序列号

public class Class001_Object {

    public static void main(String[] args) throws IOException, ClassNotFoundException {

        //writeToFile("D://e.txt");

        readFile("D://e.txt");

    }

    //反序列化

    public static void readFile(String path) throws IOException, ClassNotFoundException {

        //1.输入流

        ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(new FileInputStream(path)));

        //2.读入

        User obj1 = (User) in.readObject();

        int[] arr = (int[]) in.readObject();

        //3.处理数据

        System.out.println(obj1);

        System.out.println(Arrays.toString(arr));

        //4.关闭

        in.close();

    }

    //序列化输出

    public static void writeToFile(String path) throws IOException {

        //1.输出流

        ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(path)));

        //2.数据

        User user = new User("zhangsan",18,"123");

        int[] arr = {1,2,3,4};

        //3.写出

        out.writeObject(user);

        out.writeObject(arr);

        //4.刷出

        out.flush();

        //5.关闭

        out.close();

        //修饰user对象的成员,静态

        user.username = "lisi";

        user.password = "4321";

    }

}

class User implements Serializable{

    private static final long serialVersionUID = -5204947308809070324L;

    public String username;

    //transient 修饰的字段不会序列化

    public transient int age;

    public static String password;

    //成员的修改: 新增的成员

    public int vip;

    public int id;  //用户编号

    public User() {

    }

    public User(String username, int age, String password) {

        this.username = username;

        this.age = age;

        this.password = password;

    }

    @Override

    public String toString() {

        return "User{" +

                "username='" + username + '\'' +

                ", age=" + age +

                ", password='" + password + '\'' +

                '}';

    }

}

（1）CommonsIO 是apache的一个开源的工具包,封装了IO操作的相关类，使用Commons IO可以很方便的读写文件,url源代码等。

（2）使用第三方组件的方式|步骤:

①下载源码资源,找到核心jar包

②项目下新建文件夹lib,放入jar包

③commons-IO 需要加入classpath 的第三方 jar 包内的 class 文件才能在项目中使用，选中jar包右键->add as lib...

public class Class001_CommonsIO {

    public static void main(String[] args) throws IOException {

        //1.创建File对象

        File src = new File("D://a.txt");

        File dest = FileUtils.getFile("D://f.txt");

        //FilenameUtils

        //isExtension(String fileName, String text) // 判断fileName是否是text后缀名

        //FilenameUtils.getBaseName(String filename) // 去除目录和后缀后的文件名       System.out.println(FilenameUtils.getBaseName("D://DDD/haha.txt"));;        System.out.println(FilenameUtils.getName("D://DDD/haha.txt"));;       System.out.println(FilenameUtils.isExtension("D://DDD/haha.txt","txt"));;

        //FileUtils

        //FileUtils.copyFile(File srcFile, File destFile)` // 复制文件

        FileUtils.copyFile(src,dest);

        // **复制文件夹**

        //FileUtils.copyDirectory(File srcDir, File destDir)` // 复制文件夹（文件夹里面的文件内容也会复制）

        FileUtils.copyDirectory(new File("D://DDD"), new File("D://hehe/DDD"));

        //FileUtils.copyDirectory(File srcDir, File destDir, FileFilter filter)` // 复制文件夹，带有文件过滤功能

        FileUtils.copyDirectory(new File("D://DDD"),  new File("D://houhou/DDD"), FileFilterUtils.fileFileFilter());

        //**把字符串写入文件**

        //`FileUtils.writeStringToFile(File file, String data, String encoding)`  // 字符串以指定的编码写到文件

        //`FileUtils.writeStringToFile(File file, String data, String encoding, boolean append)`// 指定知否追加

        FileUtils.writeStringToFile(src,"yyds!!!!","UTF-8",true);

    }

}

这篇关于14、java——IO流的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

14、java——IO流

相关编程文章