Java的第十四篇文章——文件和IO流（后期再学一遍）

已于 2023-07-29 15:18:22 修改
阅读量384 收藏 6
点赞数 6
分类专栏： 后端开放（JavaSE） 文章标签： java 开发语言
于 2023-07-26 17:28:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ANNE_fly/article/details/131937028
版权

目录

学习目标

1. FIle类

1.1 File类的构造方法

1.2 FIle类的创建方法

1.3 File类的删除方法

1.4 File类的判断方法

1.4.1 绝对路径和相对路径

1.5 File类的获取的方法

1.6 File类的方法listFIles()

2. IO流对象

2.1 IO流对象的分类

2.1.1 按照操作的文件类型分类

2.1.2 按照数据的流向分类

2.1.3 IO流对象的分类归纳

3. 字节输出流

3.1 FileOutputStream

3.2 字节输出流写入文件的步骤

3.3 写入单个字节

3.4 写入字节数组

3.5 追加写入和换行

3.6 IO异常处理

4. 字节输入流

4.1 FileInputStream

4.2 字节输入流读取单个字节

4.3 字节输入流读取字节数组

5. 文件复制

6. 字节流的缓冲流

6.1 BufferedOutputStream 构造方法

6.2 BufferedInputStream 构造方法

7. 字符流

7.1 OutputStreamWriter类

7.2 InputStreamReader类

7.3 便捷类

7.4 字符输出流的缓冲流

7.6 字符流复制文本文件

8. 字符流和字节流的区别

9. 打印流

10. 基本数据类型流（现阶段作用不大）

学习目标

  • IO流对象的分类

  • 字节流

  • 字符流

  • 转换流

  • 打印流

  • 对象序列化

  • 基本数据类型操作流

1. FIle类

  • 文件夹 Directory：存储文件的容器,防止文件重名而设置，文件归类，文件夹本身不存储任何数据，计算专业数据称为 目录

  • 文件 File，存储数据的，同一个目录中的文件名不能相同

  • 路径 Path：一个目录或者文件在磁盘中的位置

    • c:\jdk8\jar 是目录的路径，是个文件夹的路径

    • c:\jdk8\bin\javac.exe 是文件的路径

  • File类，描述目录文件和路径的对象

  • 平台无关性

1.1 File类的构造方法

  • File (String pathname)传递字符串的路径名

  • File(String parent,String child)传递字符串的父路径，字符串的子路径

  • File(File parent,String child)传递File类型的父路径，字符串的子路径

public static void main(String[] args) {
        fileMethod03();
    }
    /**
     * File(File parent,String child)传递File类型的父路径,字符串的子路径
     */
    public static void fileMethod03(){
        File parent = new File("C:/Java/jdk1.8.0_221");
        String child = "bin";
        File file = new File(parent,child);
        System.out.println(file);
    }

    /**
     * File(String parent,String child)传递字符串的父路径,字符串的子路径
     * C:\Java\jdk1.8.0_221\bin
     * C:\Java\jdk1.8.0_221 是 C:\Java\jdk1.8.0_221\bin 的父路径
     */
    public static void fileMethod02(){
        String parent = "C:/Java/jdk1.8.0_221";
        String child = "bin";
        File file = new File(parent,child);
        System.out.println(file);
    }

    /**
     * File (String pathname)传递字符串的路径名
     */
    public static void fileMethod(){
        //字符串的路径,变成File对象
        File file = new File("C:\\Java\\jdk1.8.0_221\\bin");
        System.out.println(file);
    }

1.2 FIle类的创建方法

  • boolean createNewFile()创建一个文件，文件路径写在File的构造方法中

  • boolean mkdirs()创建目录，目录的位置和名字写在File的构造方法中

boolean mkdir() : 创建此抽象路径名指定的目录。
boolean mkdirs() : 创建此抽象路径名指定的目录，包括创建必需但不存在的父目录。

    //创建文件夹 boolean mkdirs()
    public static void fileMethod02(){
        File file = new File("C://Java//1.txt");
        boolean b = file.mkdirs();
        System.out.println("b = " + b);
    }

    //创建文件 boolean createNewFile()
    public static void fileMethod() throws IOException {
        File file = new File("C://Java//1.txt");
        boolean b = file.createNewFile();
        System.out.println("b = " + b);
    }

1.3 File类的删除方法

  • boolean delete() 删除指定的目录或者文件，路径写在File类的构造方法

    • 不会进入回收站，直接从磁盘中删除了，有风险

    public static void fileMethod03(){
        File file = new File("C:/Java/aaa");
        boolean b = file.delete();
        System.out.println("b = " + b);
    }

1.4 File类的判断方法

  • boolean exists() 判断构造方法中的路径是否存在

  • boolean isDirectory()判断构造方法中的路径是不是文件夹

  • boolean isFile()判断构造方法中的路径是不是文件

  • boolean isAbsolute() 判断构造方法中的路径是不是绝对路径

1.4.1 绝对路径和相对路径

  • 绝对路径

    • 在磁盘中的路径具有唯一性

    • Windows系统中，盘符开头 C:/Java/jdk1.8.0_221/bin/javac.exe

    • Linux或者Unix系统，/开头,磁盘根 /usr/local

    • 互联网路径：www.baidu.com

      • https://item.jd.com/100007300763.html

      • https://pro.jd.com/mall/active/3WA2zN8wkwc9fL9TxAJXHh5Nj79u/index.html

  • 相对路径

    • 必须有参照物

    • C:/Java/jdk1.8.0_221/bin/javac.exe

    • bin是参考点：父路径 C:/Java/jdk1.8.0_221

    • bin是参考点：子路径 javac.exe

    • bin参考点：父路径使用 ../表示

   /**
     * boolean isAbsolute() 判断构造方法中的路径是不是绝对路径
     * 不写绝对形式的路径,写相对形式的,默认在当前的项目路径下
     */
    public static void fileMethod04(){
        File file = new File("C:/Java/jdk1.8.0_221/bin/javac.exe");
        boolean b = file.isAbsolute();
        System.out.println("b = " + b);

        File file2 = new File("javac.exe");
        b = file2.isAbsolute();
        System.out.println("b = " + b);
    }

1.5 File类的获取的方法

  • File getAbsoluteFile() 获取绝对路径，返回值是File类型

  • File getParentFile() 获取父路径，返回值是File类型

  • String getName() 获取名字，File构造方法中的路径的名字

  • String getPath() 获取File构造方法中的路径，完整的路径转成String返回

  • long length()获取文件的字节数

/**
* File类的获取方法
* - File getAbsoluteFile() 获取绝对路径,返回值是File类型
* - File getParentFile() 获取父路径,返回值是File类型
*/
public static void fileMethod02(){
    File file = new File("C:\\Java\\jdk1.8.0_221\\bin\\java.exe");
    //获取绝对路径
    File absoluteFile = file.getAbsoluteFile();
    System.out.println("absoluteFile = " + absoluteFile);
    //获取父路径
    File parentFile = file.getParentFile().getParentFile();
    System.out.println("parentFile = " + parentFile);
    //文件的字节数
    long length = file.length();
    System.out.println("length = " + length);
}

/**
* File类获取方法
* - String getName() 获取名字,File构造方法中的路径的名字
* - String getPath() 获取File构造方法中的路径,完整的路径转成String返回
*/
public static void fileMethod(){
    File file = new File("C:\\Java\\jdk1.8.0_221\\bin\\java.exe");
    //getName()获取名字
    String name = file.getName();
    System.out.println("name = " + name);

    //getPath()构造方法参数,转成字符串
    String path = file.getPath();
    System.out.println("path = " + path);
}

1.6 File类的方法listFIles()

返回值是File[] 数组，存储了多个File对象，方法的作用是遍历当前的文件夹。

    public static void main(String[] args) {
        //fileMethod();

        foreachDir(new File("C:\\Java\\jdk1.8.0_221"));
    }
    /**
     * 目录的递归遍历 : 传递参数,遍历哪个路径,传递过来
     */
    public static void foreachDir(File dir){
        System.out.println(dir);
        //listFiles()遍历目录  C:\Java\jdk1.8.0_221
        File[] files = dir.listFiles();
        //遍历数组,取出数组中的File对象
        //是遍历到的所有文件的全路径 (绝对路径)
        for(File f : files){
            //判断遍历到的路径是不是文件夹
            if(f.isDirectory()) //C:\Java\jdk1.8.0_221\jre  ,进入继续遍历
                //递归调用自己,传递路径
                foreachDir(f);
            else
                System.out.println(f);
        }
    }

    /**
     * 遍历目录
     */
    public static void fileMethod(){
        File file = new File("C:\\Java\\jdk1.8.0_221");
        File[] files = file.listFiles();
        for(File f : files){
            System.out.println(f);
        }
    }

2. IO流对象

IO：Input Output IO作用是将数据从一个设备中流入到另一个设备

数据文件，从磁盘中流向内存中，从磁盘中流向移动存储设备，从一台计算机流向另一台计算机

一切都是字节：任何数据文件都是字节组成，字节是计算机中最小的存储单元 (Java源码、游戏、音乐、电影)

2.1 IO流对象的分类

2.1.1 按照操作的文件类型分类

  • 文本类型文件 -- 选择流对象字符流

    • 什么是文本文件 : 使用文本工具,记事本,notepad++ ,editplus 打开文件后人类可以直接阅读

  • 非文本类型文件 -- 选择流对象字节流

2.1.2 按照数据的流向分类

  • 输入流 : Java程序从其它地方读取数据

  • 输出流 : Java程序中的数据,写入到其它地方

2.1.3 IO流对象的分类归纳

  • 字节输出流 : OutputStream 抽象类

  • 字节输入流 : InputStream 抽象类

  • 字符输出流 : Writer 抽象类

  • 字符输入流 : Reader 抽象类

3. 字节输出流

java.io.OutputStream是所有字节输出流的超类：可以写入任何类型文件

  • 写入字节的方法 write

    • void write(int b) 写入单个字节

    • void write(byte[] b)写入字节数组

    • void write(byte[] b,int off,int len) 写入数组的一部分,开始索引,写入的个数

3.1 FileOutputStream

  • 构造方法 : FileOutputStream(File file)

  • 构造方法 : FileOutputStream(String file)

    • 创建字节输出流对象，绑定参数就是要写入的数据目的

JVM很聪明 : 任何一个操作系统都具备IO的能力，JVM依赖操作系统实现IO功能，IO流对象使用完毕后，要释放资源

3.2 字节输出流写入文件的步骤

  • 创建字节输出流对象，构造方法中，绑定文件路径，写入目的

  • 调用流对象的方法write写入数据

  • 释放资源

3.3 写入单个字节

    /**
     * 写入单个字节
     * new FileOutputStream("c:/1.txt"); 文件没有就创建,有了就覆盖
     */
    public static void writeByte() throws IOException {
        //创建字节输出流对象,构造方法中,绑定文件路径,写入目的
        FileOutputStream fos = new FileOutputStream("c:/1.txt");
        //写入单个字节
        fos.write(45);
        fos.write(49);
        fos.write(48);
        fos.write(48);
        //释放资源
        fos.close();
    }

3.4 写入字节数组

    /**
     * 写入字节数组
     */
    public static void writeByteArray() throws IOException {
        //创建字节输出流对象,构造方法中,绑定文件路径,写入目的
        FileOutputStream fos = new FileOutputStream("c:/1.txt");
        byte[] bytes = {97,98,99,100,101,102};
        //写入字节数组
        fos.write(bytes);
        //写入字节数组中文
        fos.write("你好,我好,大家好".getBytes());
        //写入数组一部分
        fos.write(bytes,1,3);
        //释放资源
        fos.close();
    }

3.5 追加写入和换行

  • 追加写入，FileOutputStream构造方法的第二个参数写true

  • 换行写入，使用Windows系统的换行符号 \r\n

    /**
     * 追加写入和换行
     */
    public static void writeAppend()throws IOException {
        //创建字节输出流对象,构造方法中,绑定文件路径,写入目的
        FileOutputStream fos = new FileOutputStream("c:/1.txt",true);
        fos.write(65);
        //写入换行符号
        fos.write("\r\n".getBytes());
        fos.write(66);
        //释放资源
        fos.close();
    }

3.6 IO异常处理


    /**
     *  try catch异常处理 : close()写在finally
     */
    public static void write2()  {
        //提升作用域 : try外定义变量,try创建对象
        FileOutputStream fos = null;
        FileOutputStream fos2 = null;
        try {
            //创建字节输出流对象,构造方法中,绑定文件路径,写入目的
            fos = new FileOutputStream("c:/1.txt");
            fos2 = new FileOutputStream("c:/2.txt");
            //写入单个字节
            fos.write(45);
            fos.write(49);
            fos.write(48);
            fos.write(48);
        }catch (IOException ex){
            ex.printStackTrace();
        }finally {
            //释放资源
            try {
                //流对象创建失败,fos变量的值是空,不能调用close
                if(fos != null)
                    fos.close();
            }catch (IOException ex){
                ex.printStackTrace();
            }

            //释放资源
            try {
                //流对象创建失败,fos变量的值是空,不能调用close
                if(fos2 != null)
                    fos2.close();
            }catch (IOException ex){
                ex.printStackTrace();
            }
        }
    }


    /**
     *  try catch异常处理 : close()写在finally
     */
    public static void write()  {
        //提升作用域 : try外定义变量,try创建对象
        FileOutputStream fos = null;
        try {
            //创建字节输出流对象,构造方法中,绑定文件路径,写入目的
            fos = new FileOutputStream("q:/1.txt");
            //写入单个字节
            fos.write(45);
            fos.write(49);
            fos.write(48);
            fos.write(48);
        }catch (IOException ex){
            ex.printStackTrace();
        }finally {
            //释放资源
            try {
                //流对象创建失败,fos变量的值是空,不能调用close
                if(fos != null)
                    fos.close();
            }catch (IOException ex){
                ex.printStackTrace();
            }
        }
    }

4. 字节输入流

java.io.InputStream是所有字节输入流的超类 : 可以读取任何类型文件

  • 读取字节的方法 read()

    • int read() 读取单个字节，读取到流的末尾返回 -1

    • int read(byte[] b)读取字节数组，读取到流的末尾返回 -1

4.1 FileInputStream

  • 构造方法 : FileInputStream(File file)

  • 构造方法 : FileInputStream(String file)

    • 创建字节输入流对象，绑定参数就是要读取的数据源文件

4.2 字节输入流读取单个字节

    /**
     * 字节输入流,读取单个字节
     * int read() 读取单个字节
     */
    public static void readByte()throws IOException {
        //创建字节输入流对象,绑定数据源文件
        FileInputStream fis = new FileInputStream("c:/1.txt");
        //读取单个的字节
        //循环读取,条件 read()!=-1就行
        int r = 0;
        while ( (r = fis.read()) !=-1){
            System.out.print((char) r);
        }
        //释放资源
        fis.close();
    }

4.3 字节输入流读取字节数组

    /**
     * 字节输入流,读取字节数组
     * int read(byte[] b) 读取字节数组
     * 返回值 : 返回读取到的字节个数
     * String类的构造方法 new String(字节数组,开始索引,转换的个数)
     */
    public static void readByteArray()throws IOException{
        //创建字节输入流对象,绑定数据源文件
        FileInputStream fis = new FileInputStream("c:/1.txt");
        byte[] bytes = new byte[50];
        //定义变量,保存read方法的返回值
        int r = 0 ;
        while ( (r=fis.read(bytes)) !=-1){
            System.out.print(new String(bytes,0,r));
        }

        fis.close();
    }

5. 文件复制

实现文件的复制功能，操作系统中的Ctrl+C，Ctrl+V一样。原理上就是字节搬家

   /**
     * 文件复制,就是IO流对象的读写
     * 提高效率使用数组
     */
    public static void copy_1()throws IOException {
        //字节输入流,绑定数据源文件
        FileInputStream fis = new FileInputStream("c:/1.avi");
        //字节输出流,绑定要复制的目的文件
        FileOutputStream fos =  new FileOutputStream("e:/1.avi");
        //字节数组缓冲
        byte[] bytes = new byte[1024];
        //定义变量,保存读取方法read的返回值
        int r = 0;
        //循环读取数据源文件
        while ( (r=fis.read(bytes)) != -1){
            //字节输出流,写入字节数组,0索引开始,写入读取到的个数
            fos.write(bytes,0,r);
        }
        fos.close();
        fis.close();
    }

6. 字节流的缓冲流

使用字节流的缓冲流，提高原有流对象的读写性能

字节流缓冲区流，流的本质上也是字节流

  • BufferedOuputStream 继承OutputStream

    • 方法write() 写入单个的字节，或者字节数组

  • BufferedInputStream 继承InputStream

    • 方法read()读取单个字节，读取字节数组

6.1 BufferedOutputStream 构造方法

BufferedOuputStream (OutputStream out) 传递字节输出流

Buffered开头的流，称为缓冲流，FileOutputStream基础流

new BufferedOuputStream (new FileOutputStream()) 传递哪个基础流，就对哪个基础流高效操作

6.2 BufferedInputStream 构造方法

BufferedInputStream(InputStream in) 传递字节输入流

new BufferedInputStream(new FileInputStream())

  /**
     *  文件复制,缓冲流实现,高效
     */
    public static void copy_2()throws IOException {
        //字节输入流,绑定数据源文件
        FileInputStream fis = new FileInputStream("c:/1.avi");
        //字节输出流,绑定要复制的目的文件
        FileOutputStream fos =  new FileOutputStream("e:/1.avi");
        //创建字节输入流的缓冲流,提高原有字节输入流的效率
        BufferedInputStream bis = new BufferedInputStream(fis);
        //创建字节输出流的缓冲流,提高原有字节输出流的效率
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        //字节数组缓冲
        byte[] bytes = new byte[1024];
        //定义变量,保存读取方法read的返回值
        int r = 0;
        while ( (r = bis.read(bytes)) !=-1){
            bos.write(bytes,0,r);
        }
        bis.close();
        bos.close();
}

7. 字符流

只能操作文本文件

  • Writer类，是所有字符输出流的父类 (写入文本文件)

    • write(int c)写入单个字符

    • write(char[] ch)写入字符数组

    • write(char[] ch,int off,int len)写入字符数组一部分，开始索引，写入的个数

    • write(String str)写入字符串

    • void flush() 刷新该流的缓冲 (写入数据,先写入到内存)，只有刷新了数据才会到达目的文件

  • Reader类，是所有字符输入流的父类 (读取文本文件)

    • int read()读取单个字符

    • int read(char[] ch)读取字符数组

7.1 OutputStreamWriter类

OutputStreamWriter继承Writer，是字符的输出流，同时又是转换流

字符流 = 字节流 + 编码表

OutputStreamWriter 转换流 : 字符流通向字节流的桥梁，字符转成字节

  • 构造方法:

    • OutputStreamWriter(OutputStream out)传递任意字节输出流

    • OutputStreamWriter(OutputStream out,String 编码表名)传递任意字节输出流

  • 转换流写入字符文件，UTF-8编码

    /**
     *  使用编码表,UTF-8
     */
     public static void writeUTF8()throws IOException {
         //创建字节输出流
         FileOutputStream fos = new FileOutputStream("c:/utf.txt");
         //创建转换流对象,构造方法传递字节的输出流
         OutputStreamWriter osw = new OutputStreamWriter(fos);
         //写入字符串
         osw.write("你好");
         //刷新流
         osw.flush();
         //资源是否
         osw.close();
     }

  • 转换流写入字符文件GBK编码

    /**
     * 使用编码表,GBK
     */
    public static void writeGBK()throws IOException{
        //创建字节输出流
        FileOutputStream fos = new FileOutputStream("c:/gbk.txt");
        //创建字符输出流,转换流,构造方法传递字节输出流,指定编码表名
        OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");
        //写入字符串
        osw.write("你好");

        osw.close();
    }

字符输出流write完后，必须刷新，也就是调用f字符输出流的flush函数

7.2 InputStreamReader类

InputStreamReader继承Reader，字符输入流,读取文本文件

字节流通向字符流的桥梁，字节流转成了字符流

  • 构造方法:

    • InputStreamReader(InputStream out)传递任意字节输入流

    • InputStreamReader(InputStream out,String 编码表名)传递任意字节输入流

    /**
     * 读取GBK文件
     */
    public static void readGBK() throws IOException{
        //创建字节流对象,绑定数据源
        FileInputStream fis = new FileInputStream("c:/gbk.txt");
        //创建转换流对象,绑定字节输入流,指定编码表
        InputStreamReader isr = new InputStreamReader(fis,"GBK");
        //读取字符数组
        char[] chars = new char[1024];
        //保存读取方法read的返回值
        int r = 0 ;
        r = isr.read(chars);
        //数组转成字符串
        System.out.println(new String(chars,0,r));

        isr.close();
    }

    /**
     * 读取UTF文件
     */
    public static void readUTF8()throws IOException {
        //创建字节流对象,绑定数据源
        FileInputStream fis = new FileInputStream("c:/utf.txt");
        //创建转换流对象,绑定字节输入流
        InputStreamReader isr = new InputStreamReader(fis);
        //读取字符数组
        char[] chars = new char[1024];
        //保存读取方法read的返回值
        int r = 0 ;
        r = isr.read(chars);
        //数组转成字符串
        System.out.println(new String(chars,0,r));

        isr.close();
    }

7.3 便捷类

注：也就是没了字节流，直接传入文件对象。

  • FileWriter 继承 OutputStreamWriter

    • 是字符的输出流，写入文本文件

    • 直接采用默认的编码表

    • FileWriter构造方法直接传递字符串的文件名即可

public static void main(String[] args) throws IOException {
    //创建字符输出流的便捷类
    FileWriter fw = new FileWriter("day20/hehe.txt");
    //写入字符串
    fw.write("谢谢");
    fw.close();
}

  • FileReader 继承 InputStreamReader

    • 是字符的输入流，读取文本文件

    • 直接采用默认的编码表

    • FileReader构造方法直接传递字符串的文件名即可

public static void main(String[] args)throws IOException {
    //创建字符输入流对象,绑定数据源
    FileReader  fr = new FileReader("day20/hehe.txt");
    //读取字符数组
    char[] chars = new char[1024];
    int r = 0;
    while ( (r = fr.read(chars)) !=-1){
        System.out.print(new String(chars,0,r));
    }
    fr.close();
}

7.4 字符输出流的缓冲流

BufferedWriter : 字符流的缓冲流,继承Writer，写入文本文件

  • 特殊的方法 : newLine() 写入文本换行符，平台无关性

  • 构造方法: BufferedWriter(Writer w)可以传递任意字符输出流

    /**
     * 字符输出流的缓冲区,写入换行
     */
    public static void write() throws IOException {
        //创建字符输出流的便捷类
        FileWriter fw = new FileWriter("day20/xixi.txt");
        //创建字符输出流的缓冲流,构造方法传递 fw流
        BufferedWriter bfw = new BufferedWriter(fw);
        bfw.write("第一行");
        bfw.newLine();
        bfw.write("第二行");
        bfw.flush();
        bfw.close();
    }

7.6 字符流复制文本文件

错误的应用，不能保证复制后和源文件是一致的！

8. 字符流和字节流的区别

（1）字节流的write和read方法的传参只能是字节，而字符流可以的write和read方法的传参可以是字符串。

（2）各自的“父亲”不一样。

9. 打印流

  • PrintStream : 字节输出流

  • PrintWriter : 字符输出流

  • 打印流特性 :

    • 打印流负责输出打印，不关心数据源

    • 方便的打印各种形式数据

    • 打印流永远不会抛出IOException

    • 具有自动刷新，需要加上参数true

/**
* 打印流输出,在打印流的构造方法中,传递流(字节,字符)
* 自动刷新 : 构造方法第二个参数写true,第一个参数必须是IO流对象,不能是字符串
* 调用方法: println,printf,format 三个其中的一个,启用自动刷新
*/
public static void print()throws IOException {
    //便捷类
    FileWriter fw = new FileWriter("day20/print.txt");
    //创建打印流对象,传递便捷类
    PrintWriter pw = new PrintWriter(fw,true);
    pw.println(1.5); //方便打印,原样输出
}

10. 基本数据类型流（现阶段作用不大）

  • DataInputStream

    • 基本数据类型读取流

    • 构造方法,传递字节输入流

  • DataOutputStream

    • 基本数据类型的写入流

    • 构造方法,传递字节输出流

 public static void main(String[] args) throws IOException {
        read();
    }
    /**
     * DataInputStream读取基本类型
     * readInt() 读取到文件结束 : 抛出 EOFException
     */
    public static void read()throws IOException{
        //创建基本类型输入流,构造方法绑定字节输入流
        DataInputStream dis = new DataInputStream(new FileInputStream("day20/data.txt"));
        //读取基本类型
        while (true) {
            try {
                int i = dis.readInt();
                System.out.println("i = " + i);
            }catch (IOException ex){
                //ex.printStackTrace();
                break;
            }
        }
        dis.close();
    }

    /**
     *  DataOutputStream写入基本类型
     */
    public static void write()throws IOException {
        //创建基本数据类型输出流
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("day20/data.txt"));
        //写入基本数据类型
        dos.writeInt(6);
        dos.writeInt(16);
        dos.writeInt(26);
        dos.writeInt(-1);
        dos.writeInt(100);

        dos.close();
    }

木子斤欠木同
关注
  • 6
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
介绍输入输出字节流，完成文件的读取和写入操作，最后完成综合案例：文件的复制和完成字符流读写
aoteman_6的博客
12-09 609
IO流的概述和分类IO流介绍：IO：输入/输出(Input/Output)流：数据在设备间的传输称为流，流的本质是数据传输IO流就是用来处理设备间数据传输问题的。常见的应用: 文件复制;文件上传;文件下载IO流的分类 ：输入输出都是相对于内存而言：输入流：读数据（内存读入数据）输出流：写数据（内存向磁盘写数据）按照数据类型来分字节流：字节输入流和字节输出流字符流：字符输入流和字符输出流（字符流：纯文本文件，可以用记事本打开）
用 Java 的 IO 流进行读写文件操作
Huangjiazhen711的博客
11-17 5351
在计算机领域里 IO，有时也写作I/O，是的缩写，也就是输入和输出。这里的输入和输出是指不同系统之间的数据输入和输出，比如读写文件数据，读写网络数据等等。本文内容大纲如下:同步阻塞 IO 即 BIO（blocking IO），指的主要是传统的 java.io 包，它基于流模型实现。java.io 包提供了我们最熟知的一些 IO 功能，比如 File 对象提供的文件和目录操作，还有一大块就是通过输入输出流读写文件等。
IO流-文件字节和字符输入输出流
我热爱学习，也乐于分享。无论是科技前沿的洞见，还是生活中的小技巧，我都会在这里与你分享。我相信，知识就是力量，而分享则能让这份力量得到更好的传递。
02-28 510
/第二种方案，字符数组来读取文件//定义变量接收需要读取文件的路径//定义一个字符数组//抽取Filereader对象名try {= -1){//这个地方在关闭字符读取流之前，加了一个非空的判断，就是为了避免在创建字符读取流的时候，报空指针异常= null){try {
java-io流 超详细！
最新发布
weixin_74886498的博客
05-05 1052
public class 拷贝 {// 字节基本流 一次读取一个字节// 1.创建对象FileInputStream fis=new FileInputStream("D:\\测试安全\\d.txt");FileOutputStream fos=new FileOutputStream("D:\\测试安全\\dd.txt");// 2.读数据// 依次读取读取一个数据 指针后移 返回值是字符对应的ASCII码值 如果全部读取完 返回-1// ascii码表中不存在acsii码值为-1的字符。
【Java】文件的操作与输入输出流
qq_43243800的博客
06-21 4003
硬盘上保存的数据，都是“文件”来组织的，本质上都是二进制或是字符组织的数组，被打包成一个文件存在硬盘上。常见的文件有图片，文本，可执行文件，音频，视频…文件夹也是一种特殊的文件，也叫目录通常所说的文件都是存储在硬盘上面的，硬盘的特点:1硬盘容量大，内存容量小。4.硬盘上的数据断电不丢失，内存中的数据断电丢失。对于Linux来讲，所有的计算设备(网卡、键盘、打印机…)都会被描述(抽象)成文件。当一个进程启动后去申请计算机资源时，系统会把他所有用到的资源以文件的形式分配给进程，并加入到对应的文件描述符表中。
java方法与Java 流(Stream)、文件(File)和IO（第五章）
weixin_65376296的博客
08-04 71
Java方法是语句的集合，它们在一起执行一个功能。方法是解决一类问题的步骤的有序组合方法包含于类或对象中方法在程序中被创建，在其他地方被引用一般情况下，定义一个方法包含以下语法：修饰符 返回值类型 方法名(参数类型 参数名){ ... 方法体 ... return 返回值;方法包含一个方法头和一个方法体。修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。方法可能会返回值。returnValueType 是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。
Java IO：文件读写、流操作与常用技巧
rqz__的博客
04-01 8753
Java IO提供了许多用于文件读写和数据流操作的类和接口，本文将介绍如何使用这些工具来处理输入输出操作。首先，我们将讨论File类，它允许您在Java程序中操作文件和文件夹。我们还将介绍如何使用Java输入输出流（InputStream和OutputStream）和字符输入输出流（Reader和Writer）来读写数据。我们将研究各种不同类型的流，包括字节流、字符流和缓冲流，并介绍如何使用它们来优化性能。
java IO流学习笔记——(1)文件字节流
12-21
java IO流学习笔记——(1) IO流总述 • 输入流：数据源到程序(InputStream、Reader读进来) • 输出流：程序到目的地(OutputStream、Writer写出去) 流分类 : • 节点流：可以直接从数据源或目的地读写数据 • 处理...
Java IO流和文件操作实现过程解析
08-25
Java IO流和文件操作实现过程解析是Java语言中的一种基本操作，IO流是Java中处理输入输出的基础。Java中的IO流主要包括两种类型：字节流和字符流。字节流用于处理二进制数据，而字符流用于处理文本数据。 Java中的...
java IO流将一个文件拆分为多个子文件代码示例
08-28
Java IO流是一个文件流处理的基础组件，它提供了基本的文件读取和写入操作。将一个文件拆分为多个子文件是文件处理中一个常见的需求，例如上传大文件时，可以先分割成小块，传到服务器后，再进行合并。 下面是Java ...
Java中String类和IO流——学习小结
12-22
String类在java.lang包中，java使用String类创建一个字符串变量，字符串变量属于对象。String类对象创建后是一个常量，有final修饰，不能被修改。字符串重新赋值不是修改，而是生成了一个新的字符串，原先的字符串...
Java IO流 文件传输基础
09-02
文件传输基础是Java IO流应用的一个核心场景，通过IO流可以实现对文件的读写操作，包括创建、打开、修改和删除文件。在本文中，我们将深入探讨Java IO流在文件传输中的基础知识，特别是涉及文件编码的概念。 文件的...
Java字节流-文件字节输出流:写字节数据到文件
qq_45659397的博客
08-21 1154
【代码】Java字节流-文件字节输出流:写字节数据到文件。
21.文件读写：使用IO流的步骤
c1776167012的博客
01-13 2218
该方法从源中试图读取len个字节到字节数组b中，并返回实际读取的字节数目。参数off指定从字节数组的某个位置开始存放读取的数据。此方法使用给定的文件名name创建FileOutputStream流。该方法从源中读取单个字节的数据，返回0~225之间的一个整数，如果未读出字节就返回-1，每调用一次，读取游标向后移动一位。该方法从源中试图读取b.length个字节到字节数组b中，返回实际的读取字节数目。该方法给定字节数组中起始于偏移量off处取len个字节写到目的地。此方法为关闭流的方法。
Java第六章第4节：输入输出流（ I/O流） 文件 读写二进制文件
upc_ws云边牧风是文森
10-11 1125
写二进制文件 读二进制文件 抽象类OutputStream 派生类BufferedOutputStream
java文件和流的相关知识点总结
qq_45929569的博客
12-04 570
java文件和流的相关知识点总结
简单介绍Java中I/O流进行文件的读写操作
like455的博客
08-28 873
本文章的性质是学习笔记，因此在不断学习下持续更新~
Java 流(Stream)、文件(File)和IO
笔记
03-12 492
Java中的流(Stream)提供了一个统一的接口来处理输入和输出数据，文件(File)提供了一种简单的方式来操作磁盘上的文件，而I/O则允许我们在Java程序中读写数据。Java 提供了多个输入流和输出流的实现，其中最常用的是 InputStream 和 OutputStream。字节流是Java中处理二进制数据的流，通常用于读取和写入文件。本文将详细解释Java中流、文件和I/O的概念，包括如何创建、读取和写入文件，如何使用流处理输入和输出数据，以及如何使用I/O来进行网络编程。
java编写程序实现文件拷贝_Java IO编程——文件拷贝
06-01
好的，我可以为你介绍一下如何使用 Java 编写程序实现文件拷贝。 Java 提供了非常方便的 I/O 类来处理文件读写操作。文件拷贝的基本思路是读取源文件中的数据，然后将数据写入到目标文件中。下面是一个简单的文件拷贝程序示例： ```java import java.io.*; public class FileCopy { public static void main(String[] args) throws IOException { // 源文件路径 String srcFilePath = "C:/temp/source.txt"; // 目标文件路径 String destFilePath = "C:/temp/dest.txt"; // 创建输入流和输出流 FileInputStream fis = new FileInputStream(srcFilePath); FileOutputStream fos = new FileOutputStream(destFilePath); // 定义缓冲区，每次读取 1024 个字节 byte[] buffer = new byte[1024]; int len; // 循环读取源文件中的数据，并将数据写入到目标文件中 while ((len = fis.read(buffer)) != -1) { fos.write(buffer, 0, len); } // 关闭输入流和输出流 fis.close(); fos.close(); System.out.println("文件拷贝完成！"); } } ``` 在上面的示例中，我们首先定义了源文件路径和目标文件路径。然后创建了输入流和输出流，用于读取源文件和向目标文件写入数据。我们定义了一个缓冲区，每次从输入流中读取 1024 个字节，并将这些字节写入到输出流中。最后，我们关闭输入流和输出流，并输出一条完成信息。 需要注意的是，上面的代码中使用了 try-catch 语句来捕获可能出现的 IOException 异常。这是因为在文件读写过程中可能会出现异常，比如文件不存在、文件无法读取等等。为了保证程序的健壮性，我们需要使用 try-catch 语句来处理这些异常。 希望这个简单的示例可以帮助你了解如何使用 Java 编写文件拷贝程序。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

木子斤欠木同

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值