Java IO--字节流与字符流OutputStream/InputStream/Writer/Reader

最新推荐文章于 2024-05-22 17:20:49 发布
转载 最新推荐文章于 2024-05-22 17:20:49 发布 · 315 阅读 · 2

本文详细介绍了Java中的IO流概念及其实现方式，包括字节流和字符流的基本操作，如写入、读取、追加等，并对比了字节流与字符流之间的区别。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

流的概念

这里写图片描述

程序中的输入输出都是以流的形式保存的，流中保存的实际上全都是字节文件。

字节流与字符流

这里写图片描述

内容操作就四个类：OutputStream、InputStream、Writer、Reader

这里写图片描述

字节流

这里写图片描述

  • 字节输出流OutputStream 
    这里写图片描述

Clonseable表示可以关闭的操作，因为程序运行到最后肯定要关闭。 
Fluashable表示刷新，清空内存中的数据。

这里写图片描述

import java.io.File ;
import java.io.OutputStream ;
import java.io.FileOutputStream ;
public class OutputStreamDemo01{
    public static void main(String args[]) throws Exception{    // 异常抛出，不处理
        // 第1步、使用File类找到一个文件
        File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象
        // 第2步、通过子类实例化父类对象
        OutputStream out = null ;   // 准备好一个输出的对象
        out = new FileOutputStream(f)  ;    // 通过对象多态性，进行实例化
        // 第3步、进行写操作
        String str = "Hello World!!!" ;     // 准备一个字符串
        byte b[] = str.getBytes() ;         // 只能输出byte数组，所以将字符串变为byte数组
        out.write(b) ;                      // 将内容输出，保存文件
        // 第4步、关闭输出流
        out.close() ;                       // 关闭输出流
    }
};
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

在操作的时候，如果文件本身不存在，则会为用户自动创建新文件。 
在操作输出流的时候，也可以使用write(int i)的方法写出数据。

import java.io.File ;
import java.io.OutputStream ;
import java.io.FileOutputStream ;
public class OutputStreamDemo02{
    public static void main(String args[]) throws Exception{    // 异常抛出，不处理
        // 第1步、使用File类找到一个文件
        File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象
        // 第2步、通过子类实例化父类对象
        OutputStream out = null ;   // 准备好一个输出的对象
        out = new FileOutputStream(f)  ;    // 通过对象多态性，进行实例化
        // 第3步、进行写操作
        String str = "Hello World!!!" ;     // 准备一个字符串
        byte b[] = str.getBytes() ;         // 只能输出byte数组，所以将字符串变为byte数组
        for(int i=0;i<b.length;i++){        // 采用循环方式写入
            out.write(b[i]) ;   // 每次只写入一个内容
        }
        // 第4步、关闭输出流
        out.close() ;                       // 关闭输出流
    }
};
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

以上的操作中在写入数据之后，文件之前的内容应经不存在了，因为在io操作中默认的情况是将其进行覆盖的，那么如果现在要想执行追加的功能，则必须设置追加的操作。

这里写图片描述

import java.io.File ;
import java.io.OutputStream ;
import java.io.FileOutputStream ;
public class OutputStreamDemo03{
    public static void main(String args[]) throws Exception{    // 异常抛出，不处理
        // 第1步、使用File类找到一个文件
        File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象
        // 第2步、通过子类实例化父类对象
        OutputStream out = null ;   // 准备好一个输出的对象
        out = new FileOutputStream(f,true)  ;   // 此处表示在文件末尾追加内容
        // 第3步、进行写操作
        String str = "Hello World!!!" ;     // 准备一个字符串
        byte b[] = str.getBytes() ;         // 只能输出byte数组，所以将字符串变为byte数组
        for(int i=0;i<b.length;i++){        // 采用循环方式写入
            out.write(b[i]) ;   // 每次只写入一个内容
        }
        // 第4步、关闭输出流
        out.close() ;                       // 关闭输出流
    }
};
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

程序本身是可以追加内容了，但是没有换行，是直接追加到末尾的。 
如果在文件中想换行的话，使用“\r\n”完成。

import java.io.File ;
import java.io.OutputStream ;
import java.io.FileOutputStream ;
public class OutputStreamDemo04{
    public static void main(String args[]) throws Exception{    // 异常抛出，不处理
        // 第1步、使用File类找到一个文件
        File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象
        // 第2步、通过子类实例化父类对象
        OutputStream out = null ;   // 准备好一个输出的对象
        out = new FileOutputStream(f,true)  ;   // 此处表示在文件末尾追加内容
        // 第3步、进行写操作
        String str = "\r\nHello World!!!" ;     // 准备一个字符串
        byte b[] = str.getBytes() ;         // 只能输出byte数组，所以将字符串变为byte数组
        for(int i=0;i<b.length;i++){        // 采用循环方式写入
            out.write(b[i]) ;   // 每次只写入一个内容
        }
        // 第4步、关闭输出流
        out.close() ;                       // 关闭输出流
    }
};
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 字节输入流InputStream

这里写图片描述

import java.io.File ;
import java.io.InputStream ;
import java.io.FileInputStream ;
public class InputStreamDemo01{
    public static void main(String args[]) throws Exception{    // 异常抛出，不处理
        // 第1步、使用File类找到一个文件
        File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象
        // 第2步、通过子类实例化父类对象
        InputStream input = null ;  // 准备好一个输入的对象
        input = new FileInputStream(f)  ;   // 通过对象多态性，进行实例化
        // 第3步、进行读操作
        byte b[] = new byte[1024] ;     // 所有的内容都读到此数组之中
        input.read(b) ;     // 读取内容
        // 第4步、关闭输出流
        input.close() ;                     // 关闭输出流
        System.out.println("内容为：" + new String(b)) ;    // 把byte数组变为字符串输出
    }
};
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

功能虽然实现了，但是存在问题？ 数据的长度、数组的空间。

import java.io.File ;
import java.io.InputStream ;
import java.io.FileInputStream ;
public class InputStreamDemo02{
    public static void main(String args[]) throws Exception{    // 异常抛出，不处理
        // 第1步、使用File类找到一个文件
        File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象
        // 第2步、通过子类实例化父类对象
        InputStream input = null ;  // 准备好一个输入的对象
        input = new FileInputStream(f)  ;   // 通过对象多态性，进行实例化
        // 第3步、进行读操作
        byte b[] = new byte[1024] ;     // 所有的内容都读到此数组之中
        int len = input.read(b) ;       // 读取内容
        // 第4步、关闭输出流
        input.close() ;                     // 关闭输出流\
        System.out.println("读入数据的长度：" + len) ;
        System.out.println("内容为：" + new String(b,0,len)) ;  // 把byte数组变为字符串输出
    }
};
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

这里写图片描述

import java.io.File ;
import java.io.InputStream ;
import java.io.FileInputStream ;
public class InputStreamDemo03{
    public static void main(String args[]) throws Exception{    // 异常抛出，不处理
        // 第1步、使用File类找到一个文件
        File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象
        // 第2步、通过子类实例化父类对象
        InputStream input = null ;  // 准备好一个输入的对象
        input = new FileInputStream(f)  ;   // 通过对象多态性，进行实例化
        // 第3步、进行读操作
        byte b[] = new byte[(int)f.length()] ;      // 数组大小由文件决定
        int len = input.read(b) ;       // 读取内容
        // 第4步、关闭输出流
        input.close() ;                     // 关闭输出流\
        System.out.println("读入数据的长度：" + len) ;
        System.out.println("内容为：" + new String(b)) ;    // 把byte数组变为字符串输出
    }
};
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

以上是直接使用byte数组的方式完成的。 
现在使用public abstract int read() throws IOException读取内容。

import java.io.File ;
import java.io.InputStream ;
import java.io.FileInputStream ;
public class InputStreamDemo04{
    public static void main(String args[]) throws Exception{    // 异常抛出，不处理
        // 第1步、使用File类找到一个文件
        File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象
        // 第2步、通过子类实例化父类对象
        InputStream input = null ;  // 准备好一个输入的对象
        input = new FileInputStream(f)  ;   // 通过对象多态性，进行实例化
        // 第3步、进行读操作
        byte b[] = new byte[(int)f.length()] ;      // 数组大小由文件决定
        for(int i=0;i<b.length;i++){
            b[i] = (byte)input.read() ;     // 读取内容
        }
        // 第4步、关闭输出流
        input.close() ;                     // 关闭输出流\
        System.out.println("内容为：" + new String(b)) ;    // 把byte数组变为字符串输出
    }
};
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

以上的操作只适合于知道输入流的大小，如果现在不知道输入流大小。

import java.io.File ;
import java.io.InputStream ;
import java.io.FileInputStream ;
public class InputStreamDemo05{
    public static void main(String args[]) throws Exception{    // 异常抛出，不处理
        // 第1步、使用File类找到一个文件
        File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象
        // 第2步、通过子类实例化父类对象
        InputStream input = null ;  // 准备好一个输入的对象
        input = new FileInputStream(f)  ;   // 通过对象多态性，进行实例化
        // 第3步、进行读操作
        byte b[] = new byte[1024] ;     // 数组大小由文件决定
        int len = 0 ; 
        int temp = 0 ;          // 接收每一个读取进来的数据
        while((temp=input.read())!=-1){
            // 表示还有内容，文件没有读完
            b[len] = (byte)temp ;
            len++ ;
        }
        // 第4步、关闭输出流
        input.close() ;                     // 关闭输出流\
        System.out.println("内容为：" + new String(b,0,len)) ;  // 把byte数组变为字符串输出
    }
};
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24

当不知道读取内容多大的时候，可以使用读取内容返回值为-1 为读完的标志。

字符流

这里写图片描述

  • 字符输出流Writer

    这里写图片描述

字符流的操作比字节流操作好在一点，就是可以直接输出字符串了。不用再进行转换操作了。

import java.io.File ;
import java.io.Writer ;
import java.io.FileWriter ;
public class WriterDemo01{
    public static void main(String args[]) throws Exception{    // 异常抛出，不处理
        // 第1步、使用File类找到一个文件
        File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象
        // 第2步、通过子类实例化父类对象
        Writer out = null ; // 准备好一个输出的对象
        out = new FileWriter(f)  ;  // 通过对象多态性，进行实例化
        // 第3步、进行写操作
        String str = "Hello World!!!" ;     // 准备一个字符串
        out.write(str) ;                        // 将内容输出，保存文件
        // 第4步、关闭输出流
        out.close() ;                       // 关闭输出流
    }
};
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

使用字符流默认情况下依然是覆盖已有的文件，如果想要追加的话，则直接在FileWriter上增加一个可追加的标记即可。

import java.io.Writer ;
import java.io.FileWriter ;
public class WriterDemo02{
    public static void main(String args[]) throws Exception{    // 异常抛出，不处理
        // 第1步、使用File类找到一个文件
        File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象
        // 第2步、通过子类实例化父类对象
        Writer out = null ; // 准备好一个输出的对象
        out = new FileWriter(f,true)  ; // 通过对象多态性，进行实例化
        // 第3步、进行写操作
        String str = "\r\nLIXINGHUA\r\nHello World!!!" ;        // 准备一个字符串
        out.write(str) ;                        // 将内容输出，保存文件
        // 第4步、关闭输出流
        out.close() ;                       // 关闭输出流
    }
};

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 字符输入流Reader

这里写图片描述

以字符数组的形式读取数据：

import java.io.File ;
import java.io.Reader ;
import java.io.FileReader ;
public class ReaderDemo01{
    public static void main(String args[]) throws Exception{    // 异常抛出，不处理
        // 第1步、使用File类找到一个文件
        File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象
        // 第2步、通过子类实例化父类对象
        Reader input = null ;   // 准备好一个输入的对象
        input = new FileReader(f)  ;    // 通过对象多态性，进行实例化
        // 第3步、进行读操作
        char c[] = new char[1024] ;     // 所有的内容都读到此数组之中
        int len = input.read(c) ;       // 读取内容
        // 第4步、关闭输出流
        input.close() ;                     // 关闭输出流
        System.out.println("内容为：" + new String(c,0,len)) ;  // 把字符数组变为字符串输出
    }
};
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

采用循环的方式，通过文件是否读到低的形式读取：

import java.io.File ;
import java.io.Reader ;
import java.io.FileReader ;
public class ReaderDemo02{
    public static void main(String args[]) throws Exception{    // 异常抛出，不处理
        // 第1步、使用File类找到一个文件
        File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象
        // 第2步、通过子类实例化父类对象
        Reader input = null ;   // 准备好一个输入的对象
        input = new FileReader(f)  ;    // 通过对象多态性，进行实例化
        // 第3步、进行读操作
        char c[] = new char[1024] ;     // 所有的内容都读到此数组之中
        int temp = 0 ;  // 接收每一个内容
        int len = 0 ;       // 读取内容
        while((temp=input.read())!=-1){
            // 如果不是-1就表示还有内容，可以继续读取
            c[len] = (char)temp ;
            len++ ;
        }
        // 第4步、关闭输出流
        input.close() ;                     // 关闭输出流
        System.out.println("内容为：" + new String(c,0,len)) ;  // 把字符数组变为字符串输出
    }
};
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
字节流与字符流的区别

这里写图片描述

验证字符流使用了缓存：

import java.io.File ;
import java.io.OutputStream ;
import java.io.FileOutputStream ;
public class OutputStreamDemo05{
    public static void main(String args[]) throws Exception{    // 异常抛出，不处理
        // 第1步、使用File类找到一个文件
        File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象
        // 第2步、通过子类实例化父类对象
        OutputStream out = null ;   // 准备好一个输出的对象
        out = new FileOutputStream(f)  ;    // 实例化
        // 第3步、进行写操作
        String str = "Hello World!!!" ;     // 准备一个字符串
        byte b[] = str.getBytes() ;         // 只能输出byte数组，所以将字符串变为byte数组
        out.write(b) ;      // 写入数据
        // 第4步、关闭输出流
        // out.close() ;                        // 关闭输出流
    }
};
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

在使用字节流操作中，及时没有关闭，最终也是可以输出的。

import java.io.File ;
import java.io.Writer ;
import java.io.FileWriter ;
public class WriterDemo03{
    public static void main(String args[]) throws Exception{    // 异常抛出，不处理
        // 第1步、使用File类找到一个文件
        File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象
        // 第2步、通过子类实例化父类对象
        Writer out = null ; // 准备好一个输出的对象
        out = new FileWriter(f)  ;  // 通过对象多态性，进行实例化
        // 第3步、进行写操作
        String str = "Hello World!!!" ;     // 准备一个字符串
        out.write(str) ;                        // 将内容输出，保存文件
        // 第4步、关闭输出流
        // out.close() ;                        // 此时，没有关闭
    }
};
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

这里写图片描述

import java.io.File ;
import java.io.Writer ;
import java.io.FileWriter ;
public class WriterDemo04{
    public static void main(String args[]) throws Exception{    // 异常抛出，不处理
        // 第1步、使用File类找到一个文件
        File f= new File("d:" + File.separator + "test.txt") ;  // 声明File对象
        // 第2步、通过子类实例化父类对象
        Writer out = null ; // 准备好一个输出的对象
        out = new FileWriter(f)  ;  // 通过对象多态性，进行实例化
        // 第3步、进行写操作
        String str = "Hello World!!!" ;     // 准备一个字符串
        out.write(str) ;                        // 将内容输出，保存文件
        // 第4步、关闭输出流
        out.flush() ;   // 强制性清空缓冲区中的内容
        // out.close() ;                        // 此时，没有关闭
    }
};
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

这里写图片描述

操作范例

这里写图片描述
这里写图片描述

import java.io.* ;
public class Copy{
    public static void main(String args[]){
        if(args.length!=2){     // 判断是否是两个参数
            System.out.println("输入的参数不正确。") ;
            System.out.println("例：java Copy 源文件路径 目标文件路径") ;
            System.exit(1) ;    // 系统退出
        }
        File f1 = new File(args[0]) ;   // 源文件的File对象
        File f2 = new File(args[1]) ;   // 目标文件的File对象
        if(!f1.exists()){
            System.out.println("源文件不存在！") ;
            System.exit(1) ;
        }
        InputStream input = null ;      // 准备好输入流对象，读取源文件
        OutputStream out = null ;       // 准备好输出流对象，写入目标文件
        try{
            input = new FileInputStream(f1) ;
        }catch(FileNotFoundException e){
            e.printStackTrace() ;
        }
        try{
            out = new FileOutputStream(f2) ;
        }catch(FileNotFoundException e){
            e.printStackTrace() ;
        }
        if(input!=null && out!=null){   // 判断输入或输出是否准备好
            int temp = 0 ;  
            try{
                while((temp=input.read())!=-1){ // 开始拷贝
                    out.write(temp) ;   // 边读边写
                }
                System.out.println("拷贝完成！") ;
            }catch(IOException e){
                e.printStackTrace() ;
                System.out.println("拷贝失败！") ;
            }
            try{
                input.close() ;     // 关闭
                out.close() ;       // 关闭
            }catch(IOException e){
                e.printStackTrace() ;
            }
        }
    }   
}
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46

 

  
 

 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
原文地址

原文地址：http://lib.youkuaiyun.com/article/javase/2895?knId=215 
原文作者：waldmer

LPDFIGHT
关注
I/O文件---字节流，字符流：InputStream、OutputStream 、Reader、Writer
qq_44641527的博客
09-14 2900
一、I/O基本概念 1、输入和输出---完成硬盘文件的读和写 （1）向内存输入文件---input， read---输入流 InputStream 硬盘--->内存 （2）从内存输出文件---output，write---输入流 OutputStream 内存--->硬盘 2、I/O流分类 （1）流的方向 输入流InputStream -----read 输出流OutputStream ----write （2）读取数据的方式 ...
Java基础-day12-InputStream字节输入流·Reader 字符输入流·字节输出流OutputStream·字符输出流Writer·IO的继承结构
weixin_58678891的博客
06-21 383
InputStream字节输入流·Reader 字符输入流·字节输出流OutputStream·字符输出流Writer·IO的继承结构
JAVA 的两种流 字节流 InputStream OutputStream 字符流 Reader Writer
aric60的博客
03-31 481
JAVA 的两种流 字节流 InputStream OutputStream 字符流 Reader Writer Java代码   IO分两种流       字节流 InputStream OutputStream       字符流 Reader  Writer       他们都是抽象类       具体实现    字节流 FileInputS
Java 字节流（OutputStream、InputStream）与字符流(Writer、Reader) 学习
WeideJava的博客
08-27 249
首先，如果需要针对于文件的内容进行处理操作，则必须使用两类数据流： · 字节流：OutputStream、InputStream； · 字符流：Writer、Reader。 字节流是直接进行操作，而字符流需要经过处理。所有保存在磁盘上或者网络传输的数据都是字节，而所有的字节重新在内存之中整合在一起，就是字符。 但是不管使用的是字节流还是字符流，其基本的操作流程都是类似的，以文件操作为...
字节流和字符流（即写文件）、FileOutputStream类
今天会营业的博客
12-03 926
生活中，你肯定经历过这样的场景。当你编辑一个文本文件，忘记了 ctrl+s，可能文件就白白编辑了。当你电脑上插入一个U盘，可以把一个视频，拷贝到你的电脑硬盘里，那么数据都是在那些设备上的呢?键盘、内存、硬盘、外接设备等等。 我们把这种数据的传输，可以看做是一种数据的流动，按照流动的方向，以内存为基准，分为 输入input 和 输出output，即流向内存是输入流，流出内存的输出 流。 Java中1/O操作主要是指使用 java.io 包下的内容，进行输入、输出操作。输入也叫做
Io流中字符流的使用.OutputStreamWriter InputStreamReader BufferedReader以及BufferedWriter.
HeiManBa_8的博客
06-20 688
java字符流
字节流与字符流：OutputStream、InputStream、Writer、Reader
inter_stellar的博客
08-04 1103
字节流与字符流：OutputStream、InputStream、Writer、Reader
Java基础20（文件操作 IO流 InputStream字节输入流 OutputStream字节输出流 Writer 字符输出流)
qq_52897007的博客
05-22 1212
在读取流的时候，一次读取一个字节并不是最高效的方法。当我们通过read()读取输入流的数据时，BufferedInputStream会将该输入流的数据分批的填入到缓冲区中。一种是getPath()，返回构造方法传入的路径，一种是getAbsolutePath()，返回绝对路径，一种是getCanonicalPath()，它和绝对路径类似，但是返回的是规范路径。InputStream是Java标准库提供的用于读取操作的输入流，而OutputStream是Java标准库提供的用于写入操作的基础输出流。
Java-IO流/Stream流总结
07-12
- **字符流**：字符流处理的是字符数据，基于字节流进行编码解码，包括`Reader`和`Writer`两大类。`FileReader`和`FileWriter`则是字符流的典型应用，适用于读写文本文件。 2. **转换流** - **字节流转字符流**：...
Day63.IO流复习 -Java常用类、集合、IO#
阿昌爱Java
09-28 436
IO流复习 . File类的使用 1. File类的理解 1. File类的一个对象,代表一个文件或一个文件目录(俗称: 文件夹) 2. File类声明在java.io包下 3. File类中涉及到关于文件或文件目录的创建、删除、重命名、修改时间、文件大小等方法， 并未涉及到写入或读取文件内容的操作。如果需要读取或写入文件内容。就必须使用IO流来完成 4. 后续File类的对象常会作为参数传递到流的构造器中,指明读取或写入的"终点"。 2. File的实例化 常用构造器 File(String fi
OutputStreamWrite:字符流
zllww123的博客
09-21 4394
字符流
java I/O———字节流与字符流—字节输出流(OutputStream)
qq_43223415的博客
02-09 719
File类不支持文件内容处理，如果要处理文件内容，必须要通过流的操作模式来完成。流分为输入流和输出流。 在java.io包中，流分为两种：字节流与字符流 字节流：InputStream、OutputStream 字符流：Reader、Writer 字节流与字符流操作的本质区别只有一个：字节流是原生的操作，而字符流是经过处理后的操作。 在进行网络数据传输、磁盘数据保存所保存所支持的数据类...
Java学习周记1
Hiyiin的博客
09-29 899
Java学习周记第一周Java学习周记新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 Java学习周记 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔
Java IO操作—字节流(OutputStream、InputStream)和字符流(Writer、Reader)
zjpp2580369的博客
11-10 964
流的概念 在程序中所有的数据都是以流的方式进行传输或保存的，程序中需要数据的时候就用输入流读取数据，而当程序需要将一些数据保存起来的时候，就要使用输出流完成。 程序中的输入输出都是以流的形式保存的，流中保存的实际上全部是字节文件。 字节流和字符流 在java.io包中操作文件内容的主要有两大类：字节流和字符流，两类都分为输入和输出操作。在字节流中输出数据主要是使用OutputStream完成，输...
开发界面语义化：声控 + 画图协同生成代码.doc
08-10
开发界面语义化：声控 + 画图协同生成代码.doc
LABVIEW与三菱PLC通信：实现数据批量读写的高效库解决方案
08-10
如何通过LabVIEW与三菱PLC建立高效的通信桥梁，实现数据批量读写。首先概述了LabVIEW和三菱PLC的基本概念及其在工业自动化中的重要性。接着重点讲解了利用Modbus RTU协议构建通信连接的具体步骤和技术细节，包括初始化通信、发送读写请求、处理响应数据和关闭连接等功能。文中还提供了一个简化的代码示例，展示了如何在LabVIEW环境中实现这一过程。最后对这项技术进行了总结和展望，强调其在提高数据交互效率方面的潜力以及未来的广泛应用前景。 适合人群：从事工业自动化领域的工程师和技术人员，尤其是那些熟悉LabVIEW或三菱PLC的人士。 使用场景及目标：适用于需要频繁进行数据交互的工业控制系统，如生产线监控、设备状态监测等场合。主要目的是提升数据传输的速度和可靠性，从而优化整个系统的运行效率。 阅读建议：读者可以通过本文深入了解LabVIEW与三菱PLC通信的实现方法，掌握批量数据读写库的设计思路，并将其应用于实际工程项目中。建议边阅读边尝试动手实践相关代码，以便更好地理解和吸收所学知识。
欧姆龙PLC NJ系列模切机程序：高级伺服运动与张力控制的应用实例
08-10
欧姆龙PLC NJ系列模切机项目的编程细节及其关键技术。主要内容涵盖12轴EtherCAT总线伺服运动控制，包括回零、点动、定位和速度控制；张力控制采用PID算法并进行收放卷径计算；隔膜自动纠偏控制利用模拟量数据平均化处理；同步运动控制实现凸轮表追剪和裁切；以及结构化编程和ST语言功能块的使用。项目结构规范，注释详尽，有助于理解和维护代码。通过本项目的学习，可以掌握PLC高端复杂应用的实际操作技能。 适合人群：从事工业自动化领域的工程师和技术人员，特别是对PLC编程和伺服运动控制有浓厚兴趣的人群。 使用场景及目标：适用于需要深入了解PLC编程技巧和自动化控制系统原理的技术人员。目标是提升编程能力和对复杂自动化系统的工作机制的理解。 其他说明：本文不仅提供具体的编程指导，还强调了项目管理和代码规范的重要性，为读者提供了全面的学习体验。
大班主题性区域活动计划表.doc
最新发布
08-10
大班主题性区域活动计划表.doc
Java IO流详解：从Reader Writer到InputStream OutputStream
4. 字节流和字符流的基类分别是InputStream和Reader，以及OutputStream和Writer。 Java字节流（Byte Streams）： 1. 字节流是按字节处理输入输出的基类，主要适用于非文本数据的处理。 2. InputStream是字节输入流...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值