文件，IO流，FileInputStream，FileOutputStream，FileReader和FileWriter是字符流

最新推荐文章于 2024-01-30 17:16:06 发布
最新推荐文章于 2024-01-30 17:16:06 发布
阅读量470 收藏 1
点赞数
文章标签： java junit jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43669384/article/details/130260579
版权
  1. 文件就是保存数据的地方
  2. 文件流：文件在程序中是以流的形式来操作的
    1. java程序（内存）<-----输入流-----文件（磁盘，光盘等）
    2. java程序（内存）------输出流----->文件（磁盘）
    3. 流：数据在数据源（文件）和程序（内存）之间经历的路径
    4. 输入流：数据从数据源（文件）到程序（内存）的路径
    5. 输出流：数据从程序（内存）到数据源（文件）的路径
  3. 常用的文件操作 
    1. package com.jshedu.file;

import org.junit.jupiter.api.Test;

import java.io.*;

/**
 * @author 韩顺平
 * @version 1.0
 * 演示创建文件
 */
public class FileCreate {
    public static void main(String[] args) {

    }

    //方式1 new File(String pathname)
    @Test
    public void create01() {
        String filePath = "e:\\news1.txt";
        File file = new File(filePath);

        try {
            file.createNewFile();
            System.out.println("文件创建成功");
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
    //方式2 new File(File parent,String child) //根据父目录文件+子路径构建
    //e:\\news2.txt
    @Test
    public  void create02() {
        File parentFile = new File("e:\\");
        String fileName = "news2.txt";
        //这里的file对象，在java程序中，只是一个对象
        //只有执行了createNewFile 方法，才会真正的，在磁盘创建该文件
        File file = new File(parentFile, fileName);

        try {
            file.createNewFile();
            System.out.println("创建成功~");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //方式3 new File(String parent,String child) //根据父目录+子路径构建
    //这种方式有可能创建多个子文件比较方便
    @Test
    public void create03() {
        //String parentPath = "e:\\";
        String parentPath = "e:\\";
        String fileName = "news4.txt";
        File file = new File(parentPath, fileName);

        try {
            file.createNewFile();
            System.out.println("创建成功~");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //下面四个都是抽象类
    //
    //InputStream
    //OutputStream
    //Reader //字符输入流
    //Writer  //字符输出流
}

      创建文件的3种方法

    2. 获取文件相关信息

      package com.jshedu.file;

import org.junit.jupiter.api.Test;

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

/**
 * @author 韩顺平
 * @version 1.0
 */
public class FileInformation {
    public static void main(String[] args) {

    }

    //获取文件的信息
    @Test
    public void info() {
        //先创建文件对象
        File file = new File("d:\\news1.txt");
        try {
            file.createNewFile();//注意这个命令否则没有在磁盘创建文件
        } catch (IOException e) {
            e.printStackTrace();
        }
        //调用相应的方法，得到对应信息
        System.out.println("文件名字=" + file.getName());
        //getName、getAbsolutePath、getParent、length、exists、isFile、isDirectory
        System.out.println("文件绝对路径=" + file.getAbsolutePath());
        System.out.println("文件父级目录=" + file.getParent());
        System.out.println("文件大小(字节)=" + file.length());
        System.out.println("文件是否存在=" + file.exists());//T
        System.out.println("是不是一个文件=" + file.isFile());//T
        System.out.println("是不是一个目录=" + file.isDirectory());//F


    }
}

      注意创建file.createNewFile();//注意这个命令否则没有在磁盘创建文件

    3. 目录操作

      package com.jshedu.file;

import org.junit.jupiter.api.Test;

import java.io.File;
import java.io.InputStream;
import java.io.OutputStream;

/**
 * @author 韩顺平
 * @version 1.0
 */
public class Directory_ {
    public static void main(String[] args) {

        //
    }

    //判断 d:\\news1.txt 是否存在，如果存在就删除
    @Test
    public void m1() {

        String filePath = "e:\\news1.txt";
        File file = new File(filePath);
        if (file.exists()) {
            if (file.delete()) {
                System.out.println(filePath + "删除成功");
            } else {
                System.out.println(filePath + "删除失败");
            }
        } else {
            System.out.println("该文件不存在...");
        }

    }

    //判断 D:\\demo02 是否存在，存在就删除，否则提示不存在
    //这里我们需要体会到，在java编程中，目录也被当做文件
    @Test
    public void m2() {

        String filePath = "D:\\demo02";
        File file = new File(filePath);
        if (file.exists()) {
            if (file.delete()) {
                System.out.println(filePath + "删除成功");
            } else {
                System.out.println(filePath + "删除失败");
            }
        } else {
            System.out.println("该目录不存在...");
        }

    }

    //判断 D:\\demo\\a\\b\\c 目录是否存在，如果存在就提示已经存在，否则就创建
    @Test
    public void m3() {

        String directoryPath = "D:\\demo\\a\\b\\c";
        File file = new File(directoryPath);
        if (file.exists()) {
            System.out.println(directoryPath + "存在..");
        } else {
            if (file.mkdirs()) { //创建一级目录使用mkdir() ，创建多级目录使用mkdirs()
                System.out.println(directoryPath + "创建成功..");
            } else {
                System.out.println(directoryPath + "创建失败...");
            }
        }



    }
}

      注意创建文件File file = new File(filePath);

  4. IO流原理及流的分类

    1. I/O是Input/Output的缩写，I/O技术用于处理数据传输。如读/写文件，网页通讯

    2. java程序中，对于数据的输入/输出操作以“流（stream）”的方式进行

    3. java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过方法输入或输出数据

    4. 抽象类不能直接实例化，流（外卖小哥）不是数据是搬运数据的交通工具，文件就相当于物品（数据）

  5.  

  6. FileInputStream:用于读取诸如图像数据的原始字节流。

    1. package com.hspedu.inputstream_;

import org.junit.jupiter.api.Test;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/**
 * @author 韩顺平
 * @version 1.0
 * 演示FileInputStream的使用(字节输入流 文件--> 程序)
 */
public class FileInputStream_ {
    public static void main(String[] args) {

    }

    /**
     * 演示读取文件...
     * 单个字节的读取，效率比较低
     * -> 使用 read(byte[] b)
     */
    @Test
    public void readFile01() {
        String filePath = "e:\\hello.txt";
        int readData = 0;
        FileInputStream fileInputStream = null;
        try {
            //创建 FileInputStream 对象，用于读取 文件
            fileInputStream = new FileInputStream(filePath);
            //从该输入流读取一个字节的数据。 如果没有输入可用，此方法将阻止。
            //如果返回-1 , 表示读取完毕
            while ((readData = fileInputStream.read()) != -1) {
                System.out.print((char)readData);//转成char显示
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭文件流，释放资源.因为流是用来运输数据的嘛
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

    /**
     * 使用 read(byte[] b) 读取文件，提高效率
     */
    @Test
    public void readFile02() {
        String filePath = "e:\\hello.txt";
        //字节数组
        byte[] buf = new byte[8]; //一次读取8个字节.
        int readLen = 0;
        FileInputStream fileInputStream = null;
        try {
            //创建 FileInputStream 对象，用于读取 文件
            fileInputStream = new FileInputStream(filePath);
            //从该输入流读取最多b.length字节的数据到字节数组。 此方法将阻塞，直到某些输入可用。
            //如果返回-1 , 表示读取完毕
            //如果读取正常, 返回实际读取的字节数
            //读入缓冲区的总字节数，如果没有更多的数据，因为文件的结尾已经到达，返回-1 。
            while ((readLen = fileInputStream.read(buf)) != -1) {
                System.out.print(new String(buf, 0, readLen));//显示
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭文件流，释放资源.
            try {
                fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

      使用 read(byte[] b) 读取文件，提高效率,返回读取了多少字节，最后一次返回-1

  7. FileOutputStream

    package com.hspedu.outputstream_;

import org.junit.jupiter.api.Test;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * @author 韩顺平
 * @version 1.0
 */
public class FileOutputStream01 {
    public static void main(String[] args) {

    }

    /**
     * 演示使用FileOutputStream 将数据写到文件中,
     * 如果该文件不存在，则创建该文件
     */
    @Test
    public void writeFile() {

        //创建 FileOutputStream对象
        String filePath = "e:\\a.txt";
        FileOutputStream fileOutputStream = null;
        try {
            //得到 FileOutputStream对象 对象
            //老师说明
            //1. new FileOutputStream(filePath) 创建方式，当写入内容是，会覆盖原来的内容
            //2. new FileOutputStream(filePath, true) 创建方式，当写入内容是，是追加到文件后面
            fileOutputStream = new FileOutputStream(filePath, true);
            //这里和创建文件那不一样，不用单独file.createNewFile();
            
            //写入一个字节
            //fileOutputStream.write('H');//
            //写入字符串
            String str = "hsp,world!";
            //str.getBytes() 可以把 字符串-> 字节数组
            //fileOutputStream.write(str.getBytes());
            /*
            write(byte[] b, int off, int len) 将 len字节从位于偏移量 off的指定字节数组写入此文件输出流
             */
            fileOutputStream.write(str.getBytes(), 0, 3);

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fileOutputStream.close();//关闭流
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

    写入字符串的方法，覆盖和追加的方式

  8. 在完成程序时，应该是读取部分数据，就写入指定文件

    package com.hspedu.outputstream_;

import com.hspedu.inputstream_.FileInputStream_;

import java.io.*;

/**
 * @author 韩顺平
 * @version 1.0
 */
public class FileCopy {
    public static void main(String[] args) {
        //完成 文件拷贝，将 e:\\Koala.jpg 拷贝 c:\\
        //思路分析
        //1. 创建文件的输入流 , 将文件读入到程序
        //2. 创建文件的输出流， 将读取到的文件数据，写入到指定的文件.
        String srcFilePath = "e:\\Koala.jpg";
        String destFilePath = "e:\\Koala3.jpg";
        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;

        try {

            fileInputStream = new FileInputStream(srcFilePath);
            fileOutputStream = new FileOutputStream(destFilePath);
            //定义一个字节数组,提高读取效果
            byte[] buf = new byte[1024];
            int readLen = 0;
            while ((readLen = fileInputStream.read(buf)) != -1) {
                //读取到后，就写入到文件 通过 fileOutputStream
                //即，是一边读，一边写
                fileOutputStream.write(buf, 0, readLen);//一定要使用这个方法

            }
            System.out.println("拷贝ok~");


        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                //关闭输入流和输出流，释放资源
                if (fileInputStream != null) {
                    fileInputStream.close();
                }
                if (fileOutputStream != null) {
                    fileOutputStream.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }
}

    将文件读入java程序【输入流】，再从java程序将文件写入到指定的文件【输出流】

  9.  FileReader和FileWriter是字符流，即按照字符来操作io

  10.  FileReader的两种读取方式

    package com.jshedu.file;

import org.junit.jupiter.api.Test;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/**
 * @author 韩顺平
 * @version 1.0
 */
public class FileReader_ {
    public static void main(String[] args) {


    }

    /**
     * 单个字符读取文件
     */
    @Test
    public void readFile01() {
        String filePath = "e:\\story.txt";
        FileReader fileReader = null;
        int data = 0;
        //1. 创建FileReader对象
        try {
            fileReader = new FileReader(filePath);
            //循环读取 使用read, 单个字符读取
            while ((data = fileReader.read()) != -1) {
                System.out.print((char) data);
            }

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

    /**
     * 字符数组读取文件
     */
    @Test
    public void readFile02() {
        System.out.println("~~~readFile02 ~~~");
        String filePath = "e:\\story.txt";
        FileReader fileReader = null;

        int readLen = 0;
        char[] buf = new char[8];
        //1. 创建FileReader对象
        try {
            fileReader = new FileReader(filePath);
            //循环读取 使用read(buf), 返回的是实际读取到的字符数
            //如果返回-1, 说明到文件结束
            while ((readLen = fileReader.read(buf)) != -1) {
                System.out.print(new String(buf, 0, readLen));
                //这个位置和读取一个字符的地方不一样，String构造器，传入相应的参数
                //把buf数组，从0开始读取readLen这么多的字符
            }

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

}

  12. FileWriter案例

    package com.jshedu.file;

import java.io.FileWriter;
import java.io.IOException;

/**
 * @author 韩顺平
 * @version 1.0
 */
public class FileWriter_ {
    public static void main(String[] args) {

        String filePath = "d:\\note.txt";
        //创建FileWriter对象
        FileWriter fileWriter = null;

        char[] chars = {'a', 'b', 'c'};
        try {
            fileWriter = new FileWriter(filePath);//默认是覆盖写入
            //注意覆盖是还在fileWriter对象基础上操作write方法参数内容更改，
            //在执行就把上次执行的参数内容覆盖了。

//            3) write(int):写入单个字符
            fileWriter.write('M');

//            4) write(char[]):写入指定数组
            fileWriter.write(chars);
//            5) write(char[],off,len):写入指定数组的指定部分
            fileWriter.write("韩顺平教育".toCharArray(), 0, 3);
//            6) write（string）：写入整个字符串
            fileWriter.write(" 你好北京~");

            fileWriter.write("风雨之后，定见彩虹");
//            7) write(string,off,len):写入字符串的指定部分
            fileWriter.write("上海天津", 0, 2);
            //在数据量大的情况下，可以使用循环操作.



        } catch (IOException e) {
            e.printStackTrace();
        } finally {

            //对应FileWriter , 一定要关闭流，或者flush才能真正的把数据写入到文件
            //老韩看源码就知道原因.
            /*
                看看代码
                private void writeBytes() throws IOException {
        this.bb.flip();
        int var1 = this.bb.limit();
        int var2 = this.bb.position();

        assert var2 <= var1;

        int var3 = var2 <= var1 ? var1 - var2 : 0;
        if (var3 > 0) {
            if (this.ch != null) {
                assert this.ch.write(this.bb) == var3 : var3;
            } else {
                this.out.write(this.bb.array(), this.bb.arrayOffset() + var2, var3);
            }
        }

        this.bb.clear();
    }
             */
            try {
                //fileWriter.flush();
                //关闭文件流，等价 flush() + 关闭
                fileWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }

        System.out.println("程序结束...");


    }
}

    对应FileWriter , 一定要关闭流，或者flush才能真正的把数据写入到文件
枯寂麻辣
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JAVA IO流缓冲字节流缓冲字符流等流经典代码示例加注释总结.rar
11-30
1、博客地址：https://blog.csdn.net/gongjin28_csdn/article/details/121636558 2、常用21个IO流：FileWriter、FileReader、CharArrayReader、CharArrayWriter、CharSequence、OutputStreamWriter、FileOutputStream、InputStreamReader、PrintWriter、BufferedReader、InputStream、FileInputStream、OutputStream、ByteArrayOutputStream、SequenceInputStream、BufferedOutputStream、BufferedInputStream、PipedReader、PipedWriter、PipedInputStream、PipedOutputStream。 3、JAVA IO流经典代码示例，示例从易到难。代码功能涉及字节、字符、字符串、文本文件、图片、音频、视频。演示错误用法和经典用法。 4、代码的结构可查看README文件。
【IO】读写文件(FileInputStream、FileOutputStream、FileReader、FileWriter、RandomAccessFile)
热门推荐
yhl_jxy的博客
02-07 1万+
读写文件(FileInputStream、FileOutputStream、FileReader、FileWriter、RandomAccessFile)
FileReader/FileInputStream 和 FileWriter/OutputStream
蜕变的快乐
04-24 3202
一、FileReader、FileInputStream、InputStreamReader、BufferedReader java.io 下面有两个抽象类InputStream类 和 Reader类 ----InputStream是所有字节输入流的超类  ----Reader是字符输入流的抽象类 --------两个最主要的区别就是InputStream是字节流的读取，Reader是字符
File类的使用；IO流(FileInputStream、FileOutputStream、FileReader、FileWriter)的概述及使用；缓冲流的使用
qq_39044046的博客
07-14 760
一、File类： 1、java.io下的File类 （1）、凡是与输入、输出相关的类、接口等都定义在java.io包下。 （2）、File是一个类，可以有构造器创建其对象。此对象对应着一个文件(.txt, .avi, .doc, .ppt, .mp3, .jpg)等等。 （3）、File类对象是与平台无关的。 （4）、File中的对象，仅仅涉及到如何创建、删除、重命名...
Java:FileOutputStream与FileWriter的区别
cassiePython的专栏
11-09 7138
Java:FileOutputStream与FileWriter的区别 在看他们的区别之前，首先我们先来理解字节流和字符流的概念。 Java对于文件处理是按照流的方式进行操作的（和C++ 类似 都会用到一个缓冲区），按照处理数据的单位可以分为字节流和字符流。按照输入输出的方向可以分为输入流和输出流。所谓字节流：每次读入或输出的是8位二进制。字符流：每次读入或输出的是16位二进制，即两个字节。
Java基础学习——Java流（二）FileReader和FileWriter、FileInputStream和FileOutputStream
skx1102195517的博客
12-12 2418
一、
FileReader && FileWriter && FileInputStream && FileOutputStream
博客的博客
01-17 4304
目录 一、读入数据的基本操作 将day09下的hello.txt文件内容读入程序中，并输出到控制台 1.步骤： 2.完整代码 3.异常的处理：为了保证流资源一定可以执行关闭操作，需要使用try-catch-finally处理 注意 二、对read()操作升级：使用read的重载方法 ⚪步骤 1.File类的实例化 2.FileReader流的实例化 3.读入操作 4.资源的关闭 三、FileWriter写出数据的操作 ————从内存中写出数据到硬盘的文件里 （一）步骤 ...
Java:FileOutputStream与FileWriter
阿志同学
03-20 512
当我们使用Java向文件中写入内容时，可以通过以下两种方式来实现。一个使用FileOutputStream，另一个使用FileWriter。 使用FileOutputStream： File fout = new File(file_location_string);FileOutputStream fos = new FileOutputStream(fout);BufferedWriter o...
java中IO（二）：FileInputstream、FileOutstream、FileReader、FileWriter等简单讲解
bugcat的博客
03-30 1152
java中IO（二）：FileInputstream、FileOutstream、FileReader、FileWriter等简单讲解 介绍 在IO（一）当中介绍了四个父类，但是四个类都是抽象类，无法直接使用，所以本次讲解一下可以直接使用FileInputstream、FileOutstream、FileReader、FileWriter等，还会讲解一下InputStreamReader和Out...
FileInputStream，FileOutputStream 和 FileReader ，FileWriter 类的基本使用【 File类+IO流知识回顾②】
最新发布
m0_63622279的博客
01-30 974
一个流可以理解为一个数据的序列。输入流表示从一个源读取数据，输出流表示向一个目标写数据。1. Java语言中的所有字节流都以Stream结尾。所有的字符流都含有Reader或Writer。2. 字节流适合读取：视频，声音，图片等二进制文件3. 字符流适合读取：纯文本文件。4. Java中一个字符占两个字节，即字符流一次读取两个字节，字节流一次读取一个字节。
Java中的IO流
12-22
IO流按照流向分类可分为输入和输出，按照文件操作处理单元分类可分为字节流和字符流。 FileInputStream 文件操作输入字节流 FileOutputStream 文件操作输出字节流 FileReader 文件操作输入字符流 FileWriter 文件...
基础深化和提高-IO流技术学习大全
11-11
另外，Java还提供了一些高级的流类，如缓冲流、对象流、数据流等，它们在底层字节流和字符流的基础上提供了更多的功能和便利。 除了基本的文件和网络I/O之外，Java的NIO（New I/O）技术也是I/O流领域的重要发展。...
Java之IO流学习总结
10-19
InputStreamReader 是一个连接字节流和字符流的桥梁，它将字节流转变为字符流。FileReader 可以说是一个达到此功能、常用的工具类，在其源代码中明显使用了将FileInputStream 转变为Reader 的方法。我们可以从这个类...
day019-io笔记和代码.rar
03-13
文本文件用统一的字符集 且用字符流读取和写出文本相关文件（最常用） * 3. 用一个大的字节数组（一般不用） 6. 转换流：（重点） 目前唯一一个可以设置字符集的流 （简单的理解为包装流，就是将...
java中FileOutputStream()和FileWriter()的不同
L-BAKE
11-23 1869
1.生成文件的过程： FileOutputStream(): 使用FileOutputStream（），每次程序运行后会产生一个新的文件，如果这个新的文件在相同目录下已经有同名文件存在，则覆盖掉该文件，只显示本次执行的结果。 FileWriter(): 使用FileWriter（）时，每次程序运行后如果产生的文件在相同目录下有同名文件存在，则在原来文件内容后面续写，而不是覆盖【public
java基础 ---- FileOutputStream类, FileOutputStream类，FileReader类，FileWriter类
m0_46523928的博客
07-14 912
FileOutputStream的理解概述： 写入数据的原理(内存-->硬盘) java程序-->JVM(java虚拟机)-->OS(操作系统)-->OS调用写数据的方法-->把数据写入到文件中 FileOutputStream的使用概述： 抽象类java.io.OutputStream:字节输出流,表示输出字节流的所有类的超类。 定义了一些子类共性的成员方法: - public void close() ：关闭此输出流并释放与此流相关联的任何系统资源。 - ...
Java中IO流中字节流（FileInputStream（read、close）、FileOutputStream（write、close、换行写、续写））
Jackmat的博客
03-10 803
时，使用FileOutputStream对象调用write方法时，会清空文本文件中的数据，达到重写的效果，那么我们怎么样能达到续写的目的呢？FileInputStream：操作本地文件的字节输入流，可以把本地文件中的数据读取到程序中来。FileOutputStream：操作本地文件的字节输出流，可以把程序中的数据写到本地文件中。如果不释放资源，Java会占用被写入的文件的资源，使其无法进行其他操作。②写数据（在路径的地方开始写数据）那是因为每循环一次，指针将会移动两位，将会跳过我们想要读取的数据。
File类、字节流、字符流、编码解读整理
Aisnice的博客
12-15 1682
介绍了字节流、字符流的关系，讲解了字符与字节之间的编码解码过程，以及相关类如File、FileInputStream和FileOutputStream、OutputStreamWriter和InputStreamReader、FileRead、FileWrite、BufferdReader、BufferdWriter的应用
IO流，字节流，字符流，序列流，内存流，对象流，打印流，随机访问流，Properties类
无区新手的博客
08-09 168
流（Stream）就是计算机中数据的流动 IO流是单词Input Output Stream的缩写 Java提供了单独的一个包java.io来处理输入输出流 java.io包中定义了多个流类型（类或抽象类）来实现输入/输出功能 流的分类 从流的流动方向来看，可以将IO流分为输入流和输出流 从流的数据处理单位来看，可以将IO流分为字节流和字符流 从流的功能来看，还可...
编写一个程序，分别使用字节流和字符流复制一个文件。要求如下： 1、使用FileInputStream、FileOutputStream和FileReader、FileWriter分别进行复制 2、使用字节流复制时，定义一个长度为1024的字节数组作为缓冲区。
06-07
好的，下面是使用字节流和字符流分别复制文件的示例代码： 使用字节流复制文件： ```java import java.io.*; public class ByteStreamCopy { public static void main(String[] args) { String srcFile = ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值