深入理解Java IO流:从File类到字节流与字符流


深入理解Java IO流:从File类到字节流与字符流

引言
在Java中,IO(输入/输出)操作是程序与外部世界交互的重要方式。
其中,File类是进行文件操作的基础,而字节流和字符流则是数据传输的两种主要方式。
本文将深入探讨这些概念及其应用。

一、 File类详解:

介绍:

File类是Java中表示文件和文件路径名的抽象表示形式。它不仅仅代表一个存在的文件或目录,还可以代表一个不存在的文件或目录,用于表示未来可能创建的文件或目录。

概念:

  1. 什么是文本文档?
    • 能用记事本打开不乱码 就是文本文档,如 txt、html 、 css,.doc 不属于文本文档
  2. 路径
    • D:\XiuLian\java\1.txt 中的父路径是谁?
    • 父路径是:D:\XiuLian\java ,而非 java,java只是 1,txt 的文件夹
  3. 分隔符
    • 路径名称分隔符
      • Windows : \
      • Linux : /
    • 路径分隔符:一个路径和其他路径之间的分隔符
      • ;
  4. 文件和目录(文件)路径名的抽象表示
  5. 简单理解
    -. 我们在创建 File 对象的时候,需要传递一个路径,这个路径定为到哪个文件或者文件夹上,我们的 File就代表哪个对象,如 File fle = new File(“D:\XiuLian\java\1.txt”)

1、File类中的静态成员:

  • pathSeparator:
    • static string pathSeparator: 与系统有关的路径分隔符,用于分隔文件路径。
  • separator :
    • static String separator: 与系统有关的名称分隔符,用于分隔目录和文件名。
  /**
    * File中的静态方法
    * static string pathSeparator;
    * static String separator;
    * */
   @Test
   public void file01() {
       // static string pathSeparator: 与系统有关的路径分隔符,为了方便,它被表示为一个字符串。
       String pathSeparator = File.pathSeparator;
       System.out.println("pathSeparator = " + pathSeparator); //  ;

       // static String separator: 与系统有关的默认名称分隔符,为了方便,它被表示为一个字符串。
       String separator = File.separator;
       System.out.println("separator = " + separator);   //  \
   }
运行结果:
pathSeparator = ;
separator = \

2、File类的构造方法

File 类提供了多种构造方法,用于创建File对象。其中,最常见的是通过文件路径字符串或父路径与子路径组合来创建。

parent  : 父路径
child   :子路径
File(string parent,string child)  根据所填写的路径创建 File 对象



parent  : 父路径,是一个 File 对象
child   :子路径
File(File parent,string child)  根据所填写的路径创建 File 对象

pathnam : 直接指定路径
File(String pathname)  根据所填写的路径创建 File 对象
   @Test
   public void file02(){
       File file1 = new File("C:\\Users\\11111\\OneDrive\\图片\\本机照片","01.jpg");
       System.out.println("file4 : "+file1);

       File file2 = new File("C:\\Users\\11111\\OneDrive\\图片\\本机照片");
       File file3 = new File(file2,"01.jpg");
       System.out.println("file3 : "+file3);


       File file4 = new File("C:\\Users\\11111\\OneDrive\\图片\\本机照片\\01.jpg");
       System.out.println("file : "+file4);
   	   // 注意 :  File 对象可以传递不存在的路径 
   }
运行结果:
file1 : C:\\Users\\11111\\OneDrive\\图片\\本机照片\\01.jpg
file3 : C:\\Users\\11111\\OneDrive\\图片\\本机照片\\01.jpg
file4 : C:\\Users\\11111\\OneDrive\\图片\\本机照片\\01.jpg

3、File类的主要方法:

string getAbsolutePath()->获取文件的绝对路径
string getPath() -> 获取封装时的路径
String getName() ->获取文件或目录的名称
Long length() -> 获取文件的长度(以字节为单位)
   @Test
   public void file03(){
       File file1 = new File("1.txt");
       System.out.println("file1.getAbsolutePath() : "+file1.getAbsolutePath());

       File file2 = new File("IO\\1.txt");
       System.out.println("file2.getPath() : "+file2.getPath());

       File file3 = new File("C:\\Users\\29170\\OneDrive\\图片\\本机照片\\01.jpg");
       System.out.println("file3.length() : "+file3.length());

   }
运行结果:
file1.getAbsolutePath() : D:\XiuLian\Work\practice\1.txt
file2.getPath() : IO\1.txt
file3.length() : 334591

4、File 创建方法:

/**
    * 创建方法
    * boolean createNewFile() -> 创建文件
    *      如果要创建的文件之前有,创建失败,返回 false
    *      如果要创建的文件之前没有,创建成功,返回 true
    * boolean mkdirs() -> 创建文件夹 (目录) 既可以创建多级文件夹,还可以创建单级文件夹
    *      如果要创建的目录之前有,创建失败,返回 false
    *      如果要创建的目录之前没有,创建成功,返回 true
    * */

   @Test
   public void file04() throws IOException {
       File file1 = new File("D:\\XiuLian\\Work\\1.txt");

       boolean newFile = file1.createNewFile();
       System.out.println("file.createNewFile : "+newFile);

       File file2 = new File("D:\\XiuLian\\Work\\nb");
       boolean mkdir = file2.mkdirs();
       System.out.println("file.mkdirs : "+ mkdir);
   }
运行结果
file.createNewFile : false
file.mkdirs : true

在这里插入图片描述


5、File 删除方法:

   /**
    * boolean delete()->删除文件或者文件,删除文件不走回收站
    * 					如果删除的是文件夹,只能删除空的,删除文件夹不走回收站
    * */
   @Test
   public void file05() {
       File file1 = new File("D:\\XiuLian\\Work\\1.txt");
       System.out.println("file1.delete : " +file1.delete());
   }
运行结果
file1.delete : true

在这里插入图片描述


6、File 类的判断方法:

   /**
    * boolean isDirectory() -> 判断是否为文件夹
    * boolean isFile() -> 判断是否为文件
    * boolean exists() -> 判断文件或者文件夹是否存在
    * */
   @Test
   public void file06() throws IOException {
       File file1 = new File("D:\\XiuLian\\Work\\1.txt");
       System.out.println("file1.isDirectory : " + file1.isDirectory());

       boolean newFile = file1.createNewFile();

       System.out.println("file1.isFile : " + file1.isFile());

       System.out.println("file1.exists : " + file1.exists());


   }
运行结果:
file1.isDirectory : false
file1.isFile : true
file1.exists : true

7、File类的遍历方法:

   /**
    * String[] list() -> 遍历指定的文件夹,返回的是string数组
    * File[] ListFiLes()-> 遍历指定的文件夹,返回的是Fi1e数组 ->这个推荐使用
    * */
   @Test
   public void file07() throws IOException {
       File file1 = new File("C:\\Users\\29170\\OneDrive\\图片\\本机照片");


       String[] list = file1.list();
       Arrays.stream(list).forEach(System.out::println);

       System.out.println("--------------------------");
       File[] files = file1.listFiles();
       Arrays.stream(files).forEach(System.out::println);

   }
运行结果:
01.jpg
02.jpg
03.png
04.jpg
05.jpg
--------------------------
C:\Users\xxx\OneDrive\图片\本机照片\01.jpg
C:\Users\xxx\OneDrive\图片\本机照片\02.jpg
C:\Users\xxx\OneDrive\图片\本机照片\03.png
C:\Users\xxx\OneDrive\图片\本机照片\04.jpg
C:\Users\xxx\OneDrive\图片\本机照片\05.jpg

8、File 的练习:

  1. 创建 File 对象,指定要遍历的文件夹路径
  2. 调用 File 遍历方法,遍历文件夹,返回 File 数组
  3. 遍历File数组,在遍历的过程中判断,如果是文件,获取文件名,判断是否是已 .jpg 结尾的,并打印
@Test
   public void file08() throws IOException {
       // 1.创建 File 对象,指定要遍历的文件夹路径
       File file = new File("C:\\Users\\29170\\OneDrive\\图片\\本机照片");
       method(file);

   }
   public static void method(File file){
       File[] files = file.listFiles();
       assert files != null;
       for (File i : files) {
           if (i.isFile()){
               String path = i.getPath();
               if (path.endsWith(".jpg")) System.out.println(path);
           }else {
               method(i);
           }
       }
   }
 

练习二:删除日志文件

  1. 删除指定文件的日志文件(日志只保存七天,超过七天的文件删除)
  2. 日志的命名格式位 ABC.2024-01-01.txt
  3. 要求文件夹下的子文件夹中的日志也要删除
	@Test
    public void testFileDelete() {

        LocalDate today = LocalDate.now();
        // 减去7天得到7天前的日期
        LocalDate sevenDaysAgo = today.minusDays(7);
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd"); // 注意这里使用小写dd
        String formattedDate = sevenDaysAgo.format(formatter);
        method(new File("D:\\logs"), formattedDate);
    }
    
    public static void method(File file, String cutoffDateStr) {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        LocalDate cutoffDate = LocalDate.parse(cutoffDateStr, formatter);

        File[] files = file.listFiles();
        if (files == null) return; // 目录为空或访问权限问题等情况,直接返回
        // 创建一个正则表达式模式,用于从文件名中提取日期部分
        Pattern datePattern = Pattern.compile("(\\d{4})-(\\d{2})-(\\d{2})");
        // 遍历目录下的所有文件和子目录
        for (File f : files) {
            // 如果是文件
            if (f.isFile()) {
                // 检查文件扩展名是否为.txt
                if (f.getName().endsWith(".txt")) {
                    // 使用正则表达式匹配文件名中的日期部分
                    Matcher matcher = datePattern.matcher(f.getName());
                    // 如果找到了匹配的日期
                    if (matcher.find()) {
                        // 提取文件名中的日期字符串
                        String fileDateStr = matcher.group(0);

                        // 将提取的日期字符串解析为LocalDate对象
                        LocalDate fileDate = LocalDate.parse(fileDateStr, formatter);
                        // 如果文件日期早于截止日期
                        if (fileDate.isBefore(cutoffDate)) {
                            // 尝试删除文件
                            boolean deleted = f.delete();
                            // 根据删除结果输出相应的信息
                            if (deleted) System.out.println("Deleted file: " + f.getPath());

                        }
                    }
                }
            } else if (f.isDirectory()) {
                // 如果是目录,则递归调用method函数
                method(f, cutoffDateStr);
            }
        }
    }
  • 12
    点赞
  • 9
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
IO流: Input Output 输入输出流 自己去扩展: 1. 对象序列化和反序列化生成一个 2. 流的种类: io包下 扩展nio包下 1. IO分类: 输入流 输出流 字节流 InputStream(抽象类) OutputStream(抽象类) 字符流 Reader (抽象类) Writer(抽象类) 2.字节流:(重点) * 使用场景: * 1.字节流处理除了文本、文字相关所有的流问题,如,png/jpg/avi/map4/mp3/exe * 2.字符流只处理文本、文字相关(编码乱码问题) * * 1.输入流 abstract class InputStream:这个抽象类是表示输入字节流的所有类的超类。 * | * FileInputStream 子类:文件字节输入流 * 1. 构造方法 * FileInputStream(String name) name:表示(绝对路径、相对路径)文件名 * FileInputStream(File file) * * 2. 普通方法: //1. int read(byte[] b) 从输入流读取一些字节数,并将它们存储到缓冲区 b 。 最常用 * //2. int read() 从输入流读取数据的下一个字节。 //3. int read(byte[] b, int off, int len) 从输入流读取最多 len字节的数据到一个字节数组。 * 2.输出流 abstract class OutputStream:这个抽象类是表示输出字节流的所有类的超类。 * | * FileOutputStream 子类:文件字节输出流 * 1. 构造方法 FileOutputStream(String name) name:表示(绝对路径、相对路径)文件名 FileOutputStream(String name, boolean append) append:表示是否在该文件末尾追加数据,如果为true,表示追加,false,表示从头开始覆盖 * FileOutputStream(File file) FileOutputStream(File file, boolean append) * * 2. 普通方法: //1. void write(byte[] b, int off, int len) 将 len字节从位于偏移量 off的指定字节数组写入此文件输出流。 最常用 * //2. void write(byte[] b)将 b.length个字节从指定的字节数组写入此文件输出流。 //3. void write(int b) 将指定的字节写入此文件输出流。 3. 注意事项: 1. 必须要关闭IO流,节约资源开销 2. 关闭IO流原则,先开后关 3. IO流工具类的抽取,将所有的关流(字节流字符流)方法抽取出来,优化代码 4. 字符流:(重点) * 使用场景:使用于处理文本相关的文件 * * Reader 抽象类: * |子类 * InputStreamReader(转换流) * |子类 * FileReader:适用于读取字符相关的文件 * 1. 构造方法: * 1.FileReader(File file) 2.FileReader(String fileName) fileName:文件名(相对路径/绝对路径) * * 2. 读取方法: * 3. int read(char[] c)读取字符到char数组中 最常用 * 2. int read()读取一个字符 * 3. int read(char[] c,int start,int length)读取制定长度的字符到char数组中 * * Writer 抽象类: * |子类 * OutputStreamWriter(转换流) * |子类 * FileWriter:适用于写出字符相关的文件 * 1. 构造方法: * 1.FileWriter(File file) 默认是false 2.FileWriter(File file, boolean append) append:表示是在文件末尾追加还是从头覆盖,如果true追加,false覆盖,默认是false 3.FileWriter(String fileName) 默认是false 4.FileWriter(String fileName, boolean append) fileName:文件名(相对路径/绝对路径) * 2. 写出方法: * 1. public Writer append(CharSequence csq,int start,int end) * 2. public Writer append(char c) * 3. public Writer append(CharSequence csq) * 4. public void write(char[] c) * 5. public void write(String str) * 6. public void write(String str,int start,int end) 5. 乱码问题:(掌握) GBK: 中文2个字节 英文、数字:1字节 UTF-8: 中文3~6个字节 英文、数字:1字节 编码:将字符串转换为字节 * 1. byte[] getBytes() 根据默认字符集将当前字符串转换为字节数组 * 2. byte[] getBytes(String charsetName) UTF-8/GBK * 按照指定的字符集将将当前字符串转换为字节数组 * * 解码:将字节转换为字符 * 1.String(byte[] bytes, int offset, int length) * 根据默认字符集将字节数组中从指定下标开始到指定长度结束的数据转换为字符串 * * 2.String(byte[] bytes, int offset, int length, String charsetName) * 根据指定字符集将字节数组中从指定下标开始到指定长度结束的数据转换为字符串 * charsetName:字符集名 例如 : "GBK"、"UTF-8" 、"ISO-8859-1" * * 不常用 * 3.String(byte[] bytes) 根据默认字符集将字节数组转换为字符串 * 4.String(byte[] bytes, String charsetName) * 根据默认字符集将字节数组转换为字符串 * * 这里会有乱码问题: * 产生的原因: * 1、因为字符集不统一,即编码和解码new String(b,0,read,"gbk")字符集不一致 * 2、因为字节流读取汉字的时候,字节数组长度不够,将一个汉字拆开了 * 解决: * 1. 用字符流用统一的字符集(最常用) * * 浏览器 : UTF-8 * 前台: * HTML :UTF-8 * CSS :UTF-8 * JS、JSP :UTF-8 * * 后台: * java :UTF-8 * * 数据库: * mysql、oracle、DB2 :UTF-8 * * 开发工具:UTF-8 * 2. 文本文件用统一的字符集 且用字符流读取和写出文本相关文件(最常用) * 3. 用一个大的字节数组(一般不用) 6. 转换流:(重点) 目前唯一一个可以设置字符集的流 (简单的理解为包装流,就是将字节流包装以下,方便操作文本相关的文件) * 使用场景: * 别人给提供了字节流,而需要处理文本文件,这时候,就需要用转换流转换一下,更方便处理文本文件 * * 作用:就是一字符流的方式读取或写出文本相关的数据 * * InputStreamReader:将字节输入流包装一下,让其更适合读取文本文件 * 构造方法: * 1.InputStreamReader(InputStream in) 创建一个使用默认字符集的InputStreamReader。 * 2.InputStreamReader(InputStream in, String charsetName) 创建一个使用指定字符集的InputStreamReader。 * 普通方法: * public int read(char[] cbuf) * int read(char[] cbuf, int offset, int length) * OutputStreamWriter:将字节输出流包装一下,让其更适合写出文本文件 * 构造方法: * 1. OutputStreamWriter(OutputStream out) 创建一个使用默认字符编码的OutputStreamWriter。 * 2. OutputStreamWriter(OutputStream out, String charsetName) 创建一个使用指定字符集的OutputStreamWriter。 普通方法: void write(char[] cbuf, int off, int len) append(CharSequence csq,int start,int end) 只有转换流可以设置字符集 7. jdk7关流的新方式: 用新结构可以自动关流 前提:该流必须是实现了一个接口 AutoCloseable 语法: try( //只能写创建流的操作,不能写其他业务操作 ){ //可能有异常的代码 }catch(异常类型1 e){ }...不需要finally关流了 8. 缓冲流:(重点)包装流 * 1.概念: 提高读取和写出效率的流 * 2.作用: 提高效率 3.使用场景:以后一律都要使用,以提高效率 建议以后都是用字节或者字符数组的方式复制文件,这样效率最高 * 4. * BufferedInputStream * 字节输入缓冲流构造方法: 1.BufferedInputStream(InputStream
Java IO流学习总结 Java流操作有关的类或接口: Java流类图结构: 流的概念和作用 流是一组有顺序的,有起点和终点的字节集合,是对数据传输的总称或抽象。即数据在两设备间的传输称为流,流的本质是数据传输,根据数据传输特性将流抽象为各种类,方便更直观的进行数据操作。 IO流的分类 根据处理数据类型的不同分为:字符流字节流 根据数据流向不同分为:输入流和输出流 字符流字节流 字符流的由来: 因为数据编码的不同,而有了对字符进行高效操作的流对象。本质其实就是基于字节流读取时,去查了指定的码表。 字节流字符流的区别: 读写单位不同:字节流以字节(8bit)为单位,字符流以字符为单位,根据码表映射字符,一次可能读多个字节。 处理对象不同:字节流能处理所有类型的数据(如图片、avi等),而字符流只能处理字符类型的数据。 结论:只要是处理纯文本数据,就优先考虑使用字符流。 除此之外都使用字节流。 输入流和输出流 对输入流只能进行读操作,对输出流只能进行写操作,程序中需要根据待传输数据的不同特性而使用不同的流。 Java IO流对象 1.输入字节流InputStreamIO 中输入字节流的继承图可见上图,可以看出: InputStream 是所有的输入字节流的父类,它是一个抽象类。 ByteArrayInputStream、StringBufferInputStream、FileInputStream 是三种基本的介质流,它们分别从Byte 数组、StringBuffer、和本地文件中读取数据。PipedInputStream 是从与其它线程共用的管道中读取数据,与Piped 相关的知识后续单独介绍。 ObjectInputStream 和所有FilterInputStream 的子类都是装饰流(装饰器模式的主角)。 2.输出字节流OutputStream IO 中输出字节流的继承图可见上图,可以看出: OutputStream 是所有的输出字节流的父类,它是一个抽象类。 ByteArrayOutputStream、FileOutputStream 是两种基本的介质流,它们分别向Byte 数组、和本地文件中写入数据。PipedOutputStream 是向与其它线程共用的管道中写入数据, ObjectOutputStream 和所有FilterOutputStream 的子类都是装饰流。 3.字节流的输入与输出的对应 图中蓝色的为主要的对应部分,红色的部分就是不对应部分。紫色的虚线部分代表这些流一般要搭配使用。从上面的图中可以看出Java IO 中的字节流是极其对称的。“存在及合理”我们看看这些字节流中不太对称的几个类吧! LineNumberInputStream 主要完成从流中读取数据时,会得到相应的行号,至于什么时候分行、在哪里分行是由改类主动确定的,并不是在原始中有这样一个行号。在输出部分没有对应的部分,我们完全可以自己建立一个LineNumberOutputStream,在最初写入时会有一个基准的行号,以后每次遇到换行时会在下一行添加一个行号,看起来也是可以的。好像更不入流了。 PushbackInputStream 的功能是查看最后一个字节,不满意就放入缓冲区。主要用在编译器的语法、词法分析部分。输出部分的BufferedOutputStream 几乎实现相近的功能。 StringBufferInputStream 已经被Deprecated,本身就不应该出现在InputStream 部分,主要因为String 应该属于字符流的范围。已经被废弃了,当然输出部分也没有必要需要它了!还允许它存在只是为了保持版本的向下兼容而已。 SequenceInputStream 可以认为是一个工具类,将两个或者多个输入流当成一个输入流依次读取。完全可以从IO 包中去除,还完全不影响IO 包的结构,却让其更“纯洁”――纯洁的Decorator 模式。 PrintStream 也可以认为是一个辅助工具。主要可以向其他输出流,或者FileInputStream 写入数据,本身内部实现还是带缓冲的。本质上是对其它流的综合运用的一个工具而已。一样可以踢出IO 包!System.out 和System.out 就是PrintStream 的实例! 4.字符输入流Reader 在上面的继承关系图中可以看出: Reader 是所有的输入字符流的父类,它是一个抽象类。 CharReader、StringReader 是两种基本的介质流,它们分别将Char 数组、String中读取数据。PipedReader 是从与其它线程共用的管道中读取数据。 BufferedReader 很明显就是一个装饰器,它和其子类负责装饰其它Reader 对象。 FilterReader 是所有自定义具体装饰流的父类,其子类PushbackReader 对Reader 对象进行装饰,会增加一个行号。 InputStreamReader 是一个连接字节流字符流的桥梁,它将字节流转变为字符流FileReader 可以说是一个达到此功能、常用的工具类,在其源代码中明显使用了将FileInputStream 转变为Reader 的方法。我们可以从这个类中得到一定的技巧。Reader 中各个类的用途和使用方法基本和InputStream 中的类使用一致。后面会有Reader 与InputStream 的对应关系。 5.字符输出流Writer 在上面的关系图中可以看出: Writer 是所有的输出字符流的父类,它是一个抽象类。 CharArrayWriter、StringWriter 是两种基本的介质流,它们分别向Char 数组、String 中写入数据。PipedWriter 是向与其它线程共用的管道中写入数据, BufferedWriter 是一个装饰器为Writer 提供缓冲功能。 PrintWriter 和PrintStream 极其类似,功能和使用也非常相似。 OutputStreamWriter 是OutputStream 到Writer 转换的桥梁,它的子类FileWriter 其实就是一个实现此功能的具体类(具体可以研究一SourceCode)。功能和使用和OutputStream 极其类似,后面会有它们的对应图。 6.字符流的输入与输出的对应 7.字符流字节流转换 转换流的特点: 其是字符流字节流之间的桥梁 可对读取到的字节数据经过指定编码转换成字符 可对读取到的字符数据经过指定编码转换成字节 何时使用转换流? 当字节和字符之间有转换动作时; 流操作的数据需要编码或解码时。 具体的对象体现: InputStreamReader:字节到字符的桥梁 OutputStreamWriter:字符到字节的桥梁 这两个流对象是字符体系中的成员,它们有转换作用,本身又是字符流,所以在构造的时候需要传入字节流对象进来。 8.FileFile类是对文件系统中文件以及文件夹进行封装的对象,可以通过对象的思想来操作文件和文件夹。 File类保存文件或目录的各种元数据信息,包括文件名、文件长度、最后修改时间、是否可读、获取当前文件的路径名,判断指定文件是否存在、获得当前目录中的文件列表,创建、删除文件和目录等方法。 9.RandomAccessFile类 该对象并不是流体系中的一员,其封装了字节流,同时还封装了一个缓冲区(字符数组),通过内部的指针来操作字符数组中的数据。 该对象特点: 该对象只能操作文件,所以构造函数接收两种类型的参数:a.字符串文件路径;b.File对象。 该对象既可以对文件进行读操作,也能进行写操作,在进行对象实例化时可指定操作模式(r,rw) 注意:该对象在实例化时,如果要操作的文件不存在,会自动创建;如果文件存在,写数据未指定位置,会从头开始写,即覆盖原有的内容。 可以用于多线程下载或多个线程同时写数据到文件。
io流简介 File类 createNewFile() File.pathSwparator 与系统有关的路径分隔符,它被表示为一个字符串 windows为 分号";" File.pathSwparatorChar 与系统有关的路径分割符,它被表示为一个字符 File.separator 与系统有关的 默认名称分隔符 ,它被表示为一个字符串 windows为 斜杠"\" File.separatorChar 与系统有关的 默认名称分隔符 ,它被表示为一个字符 获取目录和文件 File.list() 返回String[] File.listFile() 返回File[] 字节流 FileInputStream("文件路径") FileOutputStream(File file) 逐个读取 存入字节read() write() close() 字符流 FileReader("文件路径") FileWriter("文件路径") 逐个读取 存入字符read() 无缓冲的输入、输出流每一次读写都肯引发磁盘的读写操作,占用大量资源 缓冲流(装饰器模式) 缓冲流是一种装饰器类 可实现按规定字符数、按行等方式的高效读写 缓冲区的大写可指定 也可使用默认大小 FileInputStream fis = new FileInputStream("Car.java"); 装饰器类 in = new 装饰器类(fis); BufferedReader in = new BufferedReader(new FileReader("Car.java")); BufferedWriter out = new BufferedWriter(new FileReader("Car2.java")); 利用缓冲流读取的时候是逐行读取 存入字符串 in.readLine() out.write("") out.newLine()写入分行符 需要即时写入的时候 调用 flush()方法,手动刷新缓冲流 注意 关闭流的时候也会自动刷新缓冲流中的数据 字节流转换为字符流 InputStreamReader(System.in) 适配器模式的使用 其意图是将一个类的接口转换成客户希望的另外一个接口 数据流 简单来说就是容许字节流直接操作基本数据类型和字符串 DataInputStream out = new DataInputStream(new BufferedInputStream(new FileInputStream("数据存储文件路径"))) DataOutputStream out = new DataOutputStream(new BufferedOutputStream(new FileOutputStream("数据存储文件路径")))

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值