IO流、文本文件和非文本文件的读、写、复制

最新推荐文章于 2024-08-23 15:54:50 发布
最新推荐文章于 2024-08-23 15:54:50 发布
阅读量146 收藏
点赞数
分类专栏： java java语法基础 文章标签： java jvm servlet
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_54397364/article/details/128552261
版权

Java IO流 原理：

 

 

一、IO流的分类：
①：按流向不同：输入流、输出流（以程序<内存>为主体）
②：按数据类型不同：字节流、字符流（字符流用于操作文本文件：txt .java）（字节流用于操作非文本文件 .avi  .jpg  .mp3）
③：按角色不同：节点流、处理流
二、IO流的体系结构
抽象基类             节点流
InputStream         FileInputStream
OutputStream        FileOutputStream
Reader              FileReader
Writer              FileWriter

 

package IO;

import org.testng.annotations.Test;

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

/*
一、IO流的分类：
①：按流向不同：输入流、输出流（以程序<内存>为主体）
②：按数据类型不同：字节流、字符流（字符流用于操作文本文件：txt .java）（字节流用于操作非文本文件 .avi  .jpg  .mp3）
③：按角色不同：节点流、处理流
二、IO流的体系结构
抽象基类             节点流
InputStream         FileInputStream
OutputStream        FileOutputStream
Reader              FileReader
Writer              FileWriter
 */
public class IOTest {
    @Test
    public void test1() throws IOException {
        //1、创建FileInputStream 的实例，同时打开指定文件
        FileInputStream fis=new FileInputStream("D:\\IdeaProjects\\JavaSE\\Java.IO\\src\\IO\\hello.txt");
        //2、读取指定文件的内容
        int read = fis.read();
        System.out.println(read);
        //3、关闭流
        fis.close();
    }
}

 

 

 

package IO;

import org.testng.annotations.Test;

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

/*
一、IO流的分类：
①：按流向不同：输入流、输出流（以程序<内存>为主体）
②：按数据类型不同：字节流、字符流（字符流用于操作文本文件：txt .java）（字节流用于操作非文本文件 .avi  .jpg  .mp3）
③：按角色不同：节点流、处理流
二、IO流的体系结构
抽象基类             节点流
InputStream         FileInputStream
OutputStream        FileOutputStream
Reader              FileReader
Writer              FileWriter
 */
public class IOTest {
    @Test
    public void test1() throws IOException {
        //1、创建FileInputStream 的实例，同时打开指定文件
        FileInputStream fis=new FileInputStream("D:\\IdeaProjects\\JavaSE\\Java.IO\\src\\IO\\hello.txt");
        //2、读取指定文件的内容
        int i = fis.read();
        while (i!=-1){
            System.out.println((char) i);
            i=fis.read();
        }
        //3、关闭流
        fis.close();
    }
}

 

 

 

出现乱码

package IO;

import org.testng.annotations.Test;

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

/*
一、IO流的分类：
①：按流向不同：输入流、输出流（以程序<内存>为主体）
②：按数据类型不同：字节流、字符流（字符流用于操作文本文件：txt .java）（字节流用于操作非文本文件 .avi  .jpg  .mp3）
③：按角色不同：节点流、处理流
二、IO流的体系结构
抽象基类             节点流
InputStream         FileInputStream
OutputStream        FileOutputStream
Reader              FileReader
Writer              FileWriter
 */
public class IOTest {
    @Test
    public void test1() throws IOException {
        //1、创建FileInputStream 的实例，同时打开指定文件
        FileInputStream fis=new FileInputStream("D:\\IdeaProjects\\JavaSE\\Java.IO\\src\\IO\\hello.txt");
        //2、读取指定文件的内容
        int i = fis.read();
        while (i!=-1){
            System.out.println((char) i);
            i=fis.read();
        }
        //3、关闭流
        fis.close();
    }
    @Test
    public void test2() throws IOException {
        //1、创建FileInputStream实例，同时打开指定文件
        FileInputStream fis=new FileInputStream("D:\\IdeaProjects\\JavaSE\\Java.IO\\src\\IO\\hello.txt");
        //2、读取指定文件的内容
        byte[] b=new byte[3];//{a、b、c}=>{d、e、c}
        int len = fis.read(b);
        while (len!=-1){
           // System.out.print(new String(b));//abcdec
            System.out.print(new String(b,0,len));
            len=fis.read(b);
        }
        //3、关闭流
        fis.close();
    }
}

 

package IO;

import org.testng.annotations.Test;

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

/*
一、IO流的分类：
①：按流向不同：输入流、输出流（以程序<内存>为主体）
②：按数据类型不同：字节流、字符流（字符流用于操作文本文件：txt .java）（字节流用于操作非文本文件 .avi  .jpg  .mp3）
③：按角色不同：节点流、处理流
二、IO流的体系结构
抽象基类             节点流
InputStream         FileInputStream
OutputStream        FileOutputStream
Reader              FileReader
Writer              FileWriter
 */
public class IOTest {
    //字节流操作文本文件的弊端：一次读取一个字节的效率低
    @Test
    public void test1() throws IOException {
        //1、创建FileInputStream 的实例，同时打开指定文件
        FileInputStream fis=new FileInputStream("D:\\IdeaProjects\\JavaSE\\Java.IO\\src\\IO\\hello.txt");
        //2、读取指定文件的内容
        int i = fis.read();
        while (i!=-1){
            System.out.println((char) i);
            i=fis.read();
        }
        //3、关闭流
        fis.close();
    }

    //异常处理的方式不能保证close()一定执行
    @Test
    public void test2() throws IOException {
        //1、创建FileInputStream实例，同时打开指定文件
        FileInputStream fis=new FileInputStream("D:\\IdeaProjects\\JavaSE\\Java.IO\\src\\IO\\hello.txt");
        //2、读取指定文件的内容
        byte[] b=new byte[3];//{a、b、c}=>{d、e、c}
        int len = fis.read(b);
        while (len!=-1){
           // System.out.print(new String(b));//abcdec
            System.out.print(new String(b,0,len));
            len=fis.read(b);
        }
        //3、关闭流
        fis.close();
    }
    @Test
    public void test3(){
        FileInputStream fis=null;
        try {
            //1、创建FileInputStream实例，同时打开指定文件
            fis=new FileInputStream("D:\\IdeaProjects\\JavaSE\\Java.IO\\src\\IO\\hello.txt");
            //2、读取指定文件的内容
            byte[] b=new byte[3];
            int len=0;
            while ((len=fis.read(b))!=-1){
                System.out.print(new String(b,0,len));
            }
        }catch (FileNotFoundException e){
            e.printStackTrace();
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            //3、关闭流
           if (fis!=null){
               try {
                   fis.close();//null.close()
               } catch (IOException e) {
                   e.printStackTrace();
               }
           }
        }
    }
}

 

package IO;

import org.testng.annotations.Test;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

/*
一、IO流的分类：
①：按流向不同：输入流、输出流（以程序<内存>为主体）
②：按数据类型不同：字节流、字符流（字符流用于操作文本文件：txt .java）（字节流用于操作非文本文件 .avi  .jpg  .mp3）
③：按角色不同：节点流、处理流
二、IO流的体系结构
抽象基类             节点流
InputStream         FileInputStream
OutputStream        FileOutputStream
Reader              FileReader
Writer              FileWriter
 */
public class IOTest {
    //字节流操作文本文件的弊端：一次读取一个字节的效率低
    @Test
    public void test1() throws IOException {
        //1、创建FileInputStream 的实例，同时打开指定文件
        FileInputStream fis=new FileInputStream("D:\\IdeaProjects\\JavaSE\\Java.IO\\src\\IO\\hello.txt");
        //2、读取指定文件的内容
        int i = fis.read();
        while (i!=-1){
            System.out.println((char) i);
            i=fis.read();
        }
        //3、关闭流
        fis.close();
    }

    //异常处理的方式不能保证close()一定执行
    @Test
    public void test2() throws IOException {
        //1、创建FileInputStream实例，同时打开指定文件
        FileInputStream fis=new FileInputStream("D:\\IdeaProjects\\JavaSE\\Java.IO\\src\\IO\\hello.txt");
        //2、读取指定文件的内容
        byte[] b=new byte[3];//{a、b、c}=>{d、e、c}
        int len = fis.read(b);
        while (len!=-1){
           // System.out.print(new String(b));//abcdec
            System.out.print(new String(b,0,len));
            len=fis.read(b);
        }
        //3、关闭流
        fis.close();
    }
    //完善写法
    @Test
    public void test3(){
        FileInputStream fis=null;
        try {
            //1、创建FileInputStream实例，同时打开指定文件
            fis=new FileInputStream("D:\\IdeaProjects\\JavaSE\\Java.IO\\src\\IO\\hello.txt");
            //2、读取指定文件的内容
            byte[] b=new byte[3];
            int len=0;
            while ((len=fis.read(b))!=-1){
                System.out.print(new String(b,0,len));
            }
        }catch (FileNotFoundException e){
            e.printStackTrace();
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            //3、关闭流
           if (fis!=null){
               try {
                   fis.close();//null.close()
               } catch (IOException e) {
                   e.printStackTrace();
               }
           }
        }
    }

    //将指定内容写到目标文件中去
    @Test
    public void test4(){
        String str="HelloWorld";
        FileOutputStream fos= null;
        try {
            //1、创建FileOutputStream实例，同时打开指定文件
            fos = new FileOutputStream("./hello2.txt");
            //2、将指定内容写入目标地点去
            fos.write(str.getBytes(StandardCharsets.UTF_8));//getBytes()：将字符串转换成字节数组
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fos != null) {
                try {
                    //3、关闭流
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    //非文本文件的复制
    @Test
    public void test5(){
        FileInputStream fis= null;
        FileOutputStream fos= null;
        try {
            //1、创建FileInputStream的实例，同时打开指定文件
            fis = new FileInputStream("D:\\IdeaProjects\\JavaSE\\Java.IO\\src\\IO\\1.jpg");
            //2、创建FileOutputStream的实例，同时打开指定文件
            fos = new FileOutputStream("D:\\IdeaProjects\\JavaSE\\Java.IO\\src\\2.jpg");
            //3、读取指定文件的内容
            byte[] b=new byte[3];
            int len=0;
            while ((len=fis.read(b))!=-1){
                //4、将读取的内容写到目标地址去
                fos.write(b);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //5、关闭流
            if (fis!=null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fos!=null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
    /*
    //非文本文件的复制
    @Test
    public void test5(){
        //1、创建FileInputStream的实例，同时打开指定文件
        FileInputStream fis=new FileInputStream("D:\\IdeaProjects\\JavaSE\\Java.IO\\src\\IO\\1.jpg");
        //2、创建FileOutputStream的实例，同时打开指定文件
        FileOutputStream fos=new FileOutputStream("D:\\IdeaProjects\\JavaSE\\Java.IO\\src\\2.jpg");
        //3、读取指定文件的内容
        byte[] b=new byte[3];
        int len=0;
        while ((len=fis.read(b))!=-1){
            //4、将读取的内容写到目标地址去
            fos.write(b);
        }
        //5、关闭流
        fis.close();
        fos.close();
    }
     */
}

 

 

package IO;

import org.testng.annotations.Test;

import java.io.*;
import java.nio.charset.StandardCharsets;

/*
一、IO流的分类：
①：按流向不同：输入流、输出流（以程序<内存>为主体）
②：按数据类型不同：字节流、字符流（字符流用于操作文本文件：txt .java）（字节流用于操作非文本文件 .avi  .jpg  .mp3）
③：按角色不同：节点流、处理流
二、IO流的体系结构
抽象基类             节点流
InputStream         FileInputStream
OutputStream        FileOutputStream
Reader              FileReader
Writer              FileWriter
 */
public class IOTest {
    //字节流操作文本文件的弊端：一次读取一个字节的效率低
    @Test
    public void test1() throws IOException {
        //1、创建FileInputStream 的实例，同时打开指定文件
        FileInputStream fis=new FileInputStream("D:\\IdeaProjects\\JavaSE\\Java.IO\\src\\IO\\hello.txt");
        //2、读取指定文件的内容
        int i = fis.read();
        while (i!=-1){
            System.out.println((char) i);
            i=fis.read();
        }
        //3、关闭流
        fis.close();
    }

    //异常处理的方式不能保证close()一定执行
    @Test
    public void test2() throws IOException {
        //1、创建FileInputStream实例，同时打开指定文件
        FileInputStream fis=new FileInputStream("D:\\IdeaProjects\\JavaSE\\Java.IO\\src\\IO\\hello.txt");
        //2、读取指定文件的内容
        byte[] b=new byte[3];//{a、b、c}=>{d、e、c}
        int len = fis.read(b);
        while (len!=-1){
           // System.out.print(new String(b));//abcdec
            System.out.print(new String(b,0,len));
            len=fis.read(b);
        }
        //3、关闭流
        fis.close();
    }
    //完善写法
    @Test
    public void test3(){
        FileInputStream fis=null;
        try {
            //1、创建FileInputStream实例，同时打开指定文件
            fis=new FileInputStream("D:\\IdeaProjects\\JavaSE\\Java.IO\\src\\IO\\hello.txt");
            //2、读取指定文件的内容
            byte[] b=new byte[3];
            int len=0;
            while ((len=fis.read(b))!=-1){
                System.out.print(new String(b,0,len));
            }
        }catch (FileNotFoundException e){
            e.printStackTrace();
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            //3、关闭流
           if (fis!=null){
               try {
                   fis.close();//null.close()
               } catch (IOException e) {
                   e.printStackTrace();
               }
           }
        }
    }

    //将指定内容写到目标文件中去
    @Test
    public void test4(){
        String str="HelloWorld";
        FileOutputStream fos= null;
        try {
            //1、创建FileOutputStream实例，同时打开指定文件
            fos = new FileOutputStream("./hello2.txt");
            //2、将指定内容写入目标地点去
            fos.write(str.getBytes(StandardCharsets.UTF_8));//getBytes()：将字符串转换成字节数组
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fos != null) {
                try {
                    //3、关闭流
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    //非文本文件的复制
    @Test
    public void test5(){
        FileInputStream fis= null;
        FileOutputStream fos= null;
        try {
            //1、创建FileInputStream的实例，同时打开指定文件
            fis = new FileInputStream("D:\\IdeaProjects\\JavaSE\\Java.IO\\src\\IO\\1.jpg");
            //2、创建FileOutputStream的实例，同时打开指定文件
            fos = new FileOutputStream("D:\\IdeaProjects\\JavaSE\\Java.IO\\src\\2.jpg");
            //3、读取指定文件的内容
            byte[] b=new byte[3];
            int len=0;
            while ((len=fis.read(b))!=-1){
                //4、将读取的内容写到目标地址去
                /*fos.write(b);*/
                fos.write(b,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //5、关闭流
            if (fis!=null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fos!=null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
    /*
    //非文本文件的复制
    @Test
    public void test5(){
        //1、创建FileInputStream的实例，同时打开指定文件
        FileInputStream fis=new FileInputStream("D:\\IdeaProjects\\JavaSE\\Java.IO\\src\\IO\\1.jpg");
        //2、创建FileOutputStream的实例，同时打开指定文件
        FileOutputStream fos=new FileOutputStream("D:\\IdeaProjects\\JavaSE\\Java.IO\\src\\2.jpg");
        //3、读取指定文件的内容
        byte[] b=new byte[3];
        int len=0;
        while ((len=fis.read(b))!=-1){
            //4、将读取的内容写到目标地址去
            fos.write(b);
        }
        //5、关闭流
        fis.close();
        fos.close();
    }
     */
    public void copyFile(String src,String dest){
        FileInputStream fis= null;
        FileOutputStream fos= null;
        try {
            //1、创建FileInputStream的实例，同时打开指定文件
            fis = new FileInputStream(src);
            //2、创建FileOutputStream的实例，同时打开指定文件
            fos = new FileOutputStream(dest);
            //3、读取指定文件的内容
            byte[] b=new byte[1024];//一般1024或者2048
            int len=0;
            while ((len=fis.read(b))!=-1){
                //4、将读取的内容写到目标地址去
                /*fos.write(b);*/
                fos.write(b,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //5、关闭流
            if (fis!=null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fos!=null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    //文本文件的复制
    @Test
    public void test6(){
        String src="你要复制文件的路径.txt";
        String dest="要复制到哪的位置/1.txt";
    }
    public void copyTextFile(String src,String dest){
        FileReader fr= null;
        FileWriter fw= null;
        try {
            fr = new FileReader(src);
            fw = new FileWriter(dest);
            char[] cb=new char[100];
            int len=0;
            while ((len=fr.read(cb))!=-1){
                fw.write(cb,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fr!=null){
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fw!=null){
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

 

Mr.易湿
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
大数据必学Java基础（七十）：不要用字符流去操作非文本文件
Lansonli（蓝深李）的博客
10-04 1287
想要完成上面的效果，单纯的靠FileInputStream、FileOutputStream是不可以完成的，这个时候就需要功能的加强。这个加强就需要引入新的流（在FileInputStream、FileOutputStream外面再套一层流）：BufferedInputStream ,BufferedOutputStream --.jpg、 .mp3 、 .mp4、.doc 、.ppt -- 建议使用字节流操作。.txt .java .c .cpp -- 建议使用字符流操作。
IO流---复制文件内容
weixin_48664287的博客
06-28 702
IO流：用来进行设备间的数据传输问题。IO流根据流向可以分为输入流和输出流，其中输出流，从一个设备向一个设备传数据，自然是先读取数据，所以输出流既是读取，同理输入流既是写入。 IO流又根据数据类型分为字节流和字符流，其中字节流又被称为万能流。字节流:(用记事本打开读不懂）输出流 InputStream（抽象类）输入流 OutputStream（抽象类）首先文件类File，创建文件有三种方式：File file = new File("E:\\demo","a.txt"); 字节输出流操作步骤：
文件的操作(纯文本文件与非纯文本文件)
qq_45594312的博客
12-26 1273
1.纯文本文件 1.文件的操作：打开—>操作—>关闭 2.r(readonly) 默认参数:只能读不能写,读取文件不存在会报错 如果不写对文件的操作方式,默认情况下是r 3.r+ 可读写，如果操作的文件不存在会报错，默认从文件指针所在位置开始写入 4.w写文件(writeonly) 文件存在时,会清空文件的内容并写入新的文件内容 文件不存在,会创建新的文件并写入内容 ...
I/O流（4） 文本文件和非文本文件的复制操作
扬帆向海的博客
11-23 5662
前两篇博客介绍了把文件中的内容读入程序中并打印到控制台和把数据从内存写出到磁盘中。这篇文章算是对节点流读写操作的综合！
Java IO流--使用缓冲流实现非文本文件和文本文件的复制
路宇的博客
06-23 454
处理流之一：缓冲流 缓冲流： BufferedInputStream BufferedOutputStream BufferedReader BufferedWriter 作用： 提供流的读取，写入的速度。 提高读写速度的原因：内部提供了一个缓冲区。 处理流就是’'套接"在已有的流的基础上 上代码： 注释都已经在代码中给出 一、实现非文本文件的复制操作 @Test public void test1() { BufferedInputStream bis = null;
字节输入流读写非文本文件 [Java]
m0_57001006的博客
12-30 162
使用FileInputStream和FileOutputStream读写非文本文件 这里我们通过一个测试来理解: — 这个例子中我们实现对图片的一个复制 eg: — 这个程序中的abc.png就是一个本项目路径下的一个图片 package IO流.fileinputstream; import java.io.File; import java.io.FileOutputStream; import java.io.FileInputStream; import java.io.IOExceptio
有关Io输入输出流以及文件的复制
m0_68758365的博客
12-09 376
流的定义：流是指一连串流动的字符,是以先进先出方式发送信息的通道。和Writer为基类和Reader为基类：字节输入流：InputStream基类字节输出流：OutputStream基类字符流：字符输入流：Reader基类字节输出流：Writer基类（字节流是 8 位通用字节流，字符流是16位Unicode字符流）1.引入相关的类：InputStream ins =null;构建输入流，例如FileInputStream：操控字节输入流的，所用的方法也是针对字节的。
IO流三种流方式的文本文件的复制
07-27
在进行文本文件复制时，如果文件包含非ASCII编码的数据，如UTF-8编码的文件，字节流可能无法正确处理字符集，可能导致乱码问题。 接着，字符流解决了字节流处理字符编码的问题，包括Reader和Writer两个类。...
Java IO流和文件操作实现过程解析
08-25
Java IO流和文件操作实现过程解析 Java IO流和文件操作实现过程解析是Java语言中的一种基本操作，IO流是Java中处理输入输出的...Java中的IO流可以用于文件传输和网络编程中，并且可以用于读写文本文件和二进制文件。
Java中IO流文件读取、写入和复制的实例
08-29
Java中IO流文件读取、写入和复制的实例 Java中的IO流是指输入/输出流，用于读取和写入文件、网络等数据。下面我们将通过一个实例来学习Java中IO流的文件读取、写入和复制。 一、Java中文件读取 要读取文件，需要...
Java IO流 文件传输基础
09-02
文件传输不仅仅是简单的字节流操作，还涉及到错误处理、文件定位（如随机访问）、文件复制和文件的元数据管理（如权限、大小等）。在实际应用中，可能需要结合NIO（New IO）或NIO.2（Java 7引入）来处理更复杂的并发...
io流复制文本文件图解
09-27
通过“io流复制文本文件图解”，我们不仅可以直观地理解文本文件复制的过程，还能深入掌握Java中字符流的使用方法。这对于任何从事Java开发的人来说都是一个重要的技能点。无论是日常的文件操作，还是复杂的数据处理...
文件的类型（编码不同分类）和文件的操作
ZJ_ikun的博客
11-27 138
1、文本文件：基于字符编码，存储的是普通字符串，不包括字体、学号、样式、颜色等信息，可通过文本编辑器显示和编辑。如：txt/.py/.html/.csv/.xls/.xlsx。2、二进制文件：基于值编码的，以字节形式存储，其编码长度根据值的大小长度可变。如：.jpg/.avi等突破、音频或视频文件。4、使用file对象的读/写方法对文件进行读/写的操作；5、使用file对象的close()方法关闭文件。一行一行读取内容并存放值列表中。打开由中文或其他语言的文本。示例1：打开纯英文文件。
Java实现复制文件(文件、文件夹)
weixin_47390965的博客
04-28 7527
Java复制文件主要是File工具类中`listFiles()`方法先列出文件夹中的文件, 然后使用`BufferedInputStream`缓冲输入流接收要复制的文件, 再用`BufferedOutputStream`缓冲输出流的`write()`方法写入文件
4种Java文件复制的方法
热门推荐
qq_30436011的博客
10-24 1万+
类是在 Java 1.4 中引入的，FileChannel 可用于在 java 中复制文件。根据transferFrom()方法 javadoc，这种复制文件的方式应该比使用 Streams 复制文件更快。这是可用于使用 FileChannel 复制文件的方法。这是可用于使用流的java复制文件的方法。如果您正在使用 Java 7 或更高版本，则可以使用Files类的copy()方法在 java 中复制文件。这是上面程序的输出，注意注释了上面的代码，以确保每次只使用一种方法进行 java 文件复制操作。
用Java读取/写入压缩和非压缩文件
最佳 Java 编程
05-26 576
这篇文章的主要原因是尝试不要重复自己（ DRY ），因为通常，我会遇到递归的需求，即读写压缩的和非压缩的文件（主要是JSON和CSV）。 首先让我们看看如何读取文本文件。 注意我正在使用（相对较小的）文本文件，因此： read方法返回一个包含全部内容的String。 我正在使用BufferedReader逐行读取。 private String readFile(Strin...
Java文件读取
mengxuanxiangu的专栏
08-14 1193
public class ReadFromFile {     /**      * 以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件。      */     public static void readFileByBytes(String fileName) {         File file = new File(fileName);
开发多线程程序时，需要注意那些问题
最新发布
OO_SEN的博客
08-23 555
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
C++文本文件操作与标准IO流详解
在东南大学的C++课程中，"对文本文件读写方法与标准输入/输出流"这一章节主要讲解了如何在C++程序中处理文件操作，特别是在处理文本文件时的关键技术。C++中的`cin`和`cout`是标准输入输出流，它们在文件操作中扮演...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值