• JavaIO流： IO流原理即流的分类

    目录

    IO流原理

    流的分类 ：

    四个抽象类：

    （1）字节流：

     FileInputStream：字节输入流

     FileOutputStream：字节输出流：

    FileInputStream 和 FileOutputStream小案例：copy文件

     （2）字符流

    FileReader：

    FileWriter:

    IO流原理

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

    2. Java程序中，对于数据的输入/输出操作以”流(stream)"的方式进行

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

    4.输入input: 读取外部数据(磁盘、 光盘等存储设备的数据)到程序(内存)中。

    5.输出output:将程序(内存)数据输出到磁盘、光盘等存储设备中

    流的分类 ：

    按操作数据单位不同分为:字节流(8 bit),字符流(按字符)

    按数据流的流向不同分为:输入流，输出流

    按流的角色的不同分为:节点流，处理流/包装流

     1) Java的IO流共涉及40多个类，实际上非常规则，都是从如上4个抽象基类派生的。

     2)由这四个类派生出来的子类名称都是以其父类名作为子类名后缀。   

    四个抽象类：

    （1）字节流：

    InputStream抽象类是所有类字节输入流的超类

    InputStream 常用的子类：

    1. FilelnputStream:文件输入流

    2. BufferedInputStream:缓冲字节输入流

    3. ObjectlnputStream:对象字节输入流

     FileInputStream：字节输入流

    输入流读取hello.txt文件内容：

    直接看代码： 

    1. package com.io.inputSteam;
    2.  
    3. import org.junit.jupiter.api.Test;
    4.  
    5. import java.io.FileInputStream;
    6. import java.io.IOException;
    7.  
    8. public class Demo01 {
    9.     public static void main(String[] args) {
    10.  
    11.     }
    12.     /**
    13.      * 单个字节的读取
    14.      * 字节流
    15.      */
    16.     @Test
    17.     public void readFile01(){
    18. //        获取文件路径
    19.         String filePath = "e:\\hello.txt";
    20. //        readData 存放数据
    21.         int readData = 0;
    22. //        扩大fileInputStream作用域，用于关闭资源
    23.         FileInputStream fileInputStream =null;
    24.         try {
    25.              fileInputStream = new FileInputStream(filePath);
    26. //             从该输入流读取一个字节的数据，如果没有输入可用，此方法停止
    27. //            结果返回-1，表示读取完毕
    28.             while ((readData=fileInputStream.read())!=-1){
    29.                 System.out.print((char)readData);
    30.             }
    31.             System.out.println("读取成功");
    32.         } catch (IOException e) {
    33.             System.out.println("读取失败");
    34.         }
    35. //       finally关闭资源
    36.         finally {
    37.             try {
    38.                 fileInputStream.close();
    39.             } catch (IOException e) {
    40.                 System.out.println("关闭成功");
    41.             }
    42.         }
    43.  
    44.     }
    45.  
    46.     /**
    47.      * 使用read(byte[] b),多字节读取
    48.      */
    49.     @Test
    50.     public void readFile02(){
    51. //        获取文件路径
    52.         String filePath = "e:\\hello.txt";
    53. //        readData 存放数据
    54.         int readData = 0;
    55.         byte [] buf = new byte[8];//一次读取8个字节
    56.         int readLen = 0;
    57. //        扩大fileInputStream作用域，用于关闭资源
    58.         FileInputStream fileInputStream =null;
    59.         try {
    60.             fileInputStream = new FileInputStream(filePath);
    61.             while((readLen=fileInputStream.read(buf))!=-1){
    62.                 System.out.print(new String(buf,0,readLen));
    63.             }
    64.             System.out.println("读取成功");
    65.         } catch (IOException e) {
    66.             System.out.println("读取失败");
    67.         }
    68. //       finally关闭资源
    69.         finally {
    70.             try {
    71.                 fileInputStream.close();
    72.             } catch (IOException e) {
    73.                 System.out.println("关闭成功");
    74.             }
    75.         }
    76.     }
    77. }

    两种方法：一种是单字节读取，一个一个读，第二种是一次多个读取。

    运行结果：

     注意 new FileInputStream是会有异常，记得抛出异常。

     FileOutputStream：字节输出流：

    主要方法：写入数据

    案例：在E盘中创建a.txt文件并写入数据。

    1. package com.io.outputstream_;
    2.  
    3. import org.junit.jupiter.api.Test;
    4. import java.io.FileOutputStream;
    5. import java.io.IOException;
    6. import java.io.OutputStream;
    7.  
    8. /**
    9.  * 在E盘中创建a.txt文件并写入数据
    10.  */
    11. public class Demo01 {
    12.     public static void main(String[] args) {
    13.  
    14.     }
    15.     @Test
    16.     public void writerFile(){
    17.         String filePath = "e:\\a.txt";
    18.         OutputStream outputStream = null;
    19.         try {
    20. //            获取outputStream对象 new FileOutputStream(filePath);（这种创建方式会覆盖原来文件的内容）
    21. //            new FileOutputStream(filePath，true);则进行追加
    22.             outputStream = new FileOutputStream(filePath);
    23. //            写入一个数据
    24. //            outputStream.write('a');
    25. //            写入字符创
    26.             outputStream.write(new String("Hello,World!").getBytes());
    27.             System.out.println("写入成功");
    28.         } catch (IOException e) {
    29.             System.out.println("写入失败");
    30.         } finally {
    31.             try {
    32.                 outputStream.close();
    33.             } catch (IOException e) {
    34.                 System.out.println("资源关闭成功");
    35.             }
    36.         }
    37.     }
    38. }

    运行结果：

    注意：写入内容时，默认时覆盖掉原有的内容，可以在使用new  FileOutputStream(filePath,true)实现写入数据追加。

    FileInputStream 和 FileOutputStream小案例：copy文件

    把e盘中的图片文件拷贝到c盘

    主要实现过程：
     1.定义一个输入流，读取bg.jpg的信息
     2.定义一个输出流，将输入流读取到的信息写入到e盘中

    看代码：

    1. package com.io.outputstream_;
    2.  
    3. import java.io.FileInputStream;
    4. import java.io.FileOutputStream;
    5. import java.io.IOException;
    6.  
    7. /**
    8.  * @author 华子
    9.  * 使用输入输出流完成文件拷贝
    10.  * 把bg.jpg 从e盘拷贝到d盘
    11.  * 1.定义一个输入流，读取bg.jpg的信息
    12.  * 2.定义一个输出流，将输入流读取到的信息写入到e盘中
    13.  */
    14. public class FileCopy {
    15.     public static void main(String[] args) {
    16.         String filePath1 = "e:\\bg.jpg";
    17.         String filePath2 = "d:\\bg.jpg";
    18.         byte[] buf = new byte[1024];
    19.         int readLen = 0;
    20.         FileInputStream fileInputStream = null;
    21.         FileOutputStream fileOutputStream = null;
    22.         try {
    23.             fileInputStream = new FileInputStream(filePath1);
    24.             fileOutputStream = new FileOutputStream(filePath2);
    25.             while ((readLen = fileInputStream.read(buf))!=-1){
    26.                 fileOutputStream.write(buf,0,readLen);
    27.             }
    28.             System.out.println("copy成功");
    29.         } catch (IOException e) {
    30.             System.out.println("copy失败");
    31.         } finally {
    32.  
    33.             try {
    34.                 if (fileInputStream!=null){
    35.                     fileInputStream.close();
    36.                 }
    37.                 if (fileOutputStream!=null){
    38.                     fileOutputStream.close();
    39.                 }
    40.                 System.out.println("关闭成功");
    41.             } catch (IOException e) {
    42.                 System.out.println("关闭失败");
    43.             }
    44.         }
    45.     }
    46. }

     （2）字符流

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

    FileReader：

    相关方法：

    1) new FileReader(File/String)

    2) read:每次读取单个字符，返回该字符，如果到文件末尾返回-1

    3) read(char[):批量读取多个字符到数组，返回读取到的字符数，如果到文件末尾返回-1

    相关API:

    1) new String(char[]):将char[]转换成String

    2) new String(harljofflen):将char[]的指定部分转换成String

    FileReader案例：

    从story.txt中读取内容，并显示：

    story里放的是上面复制图片程序的代码。 

    看代码：

    1. package com.io.reader;
    2.  
    3. import org.junit.jupiter.api.Test;
    4.  
    5. import java.io.FileReader;
    6. import java.io.IOException;
    7.  
    8. /**
    9.  * fileReader的使用，读取e盘中story.txt文件
    10.  */
    11. public class Demo01 {
    12.     public static void main(String[] args) {
    13.  
    14.  
    15.     }
    16. //       单个字符读取
    17.     @Test
    18.     public void readFile01(){
    19.         String filePath = "e:\\story.txt";
    20.         FileReader fileReader = null;
    21.         int readData = 0;
    22.         try {
    23.             fileReader = new FileReader(filePath);
    24. //            循环读取，单个字符读取
    25.             while ((readData = fileReader.read())!=-1){
    26.                 System.out.print((char)readData);
    27.             }
    28.  
    29.         } catch (IOException e) {
    30.             e.printStackTrace();
    31.         } finally {
    32.             try {
    33.                 fileReader.close();
    34.             } catch (IOException e) {
    35.                 e.printStackTrace();
    36.             }
    37.         }
    38.     }
    39. //    使用字符数组读取文件
    40.     @Test
    41.     public void fileReader02(){
    42.         String filePath = "e:\\story.txt";
    43.         FileReader fileReader = null;
    44.         int readLen = 0;
    45.         char[] chars = new char[8];
    46.         try {
    47.             fileReader = new FileReader(filePath);
    48. //            循环读取，单个字符读取
    49.             while ((readLen = fileReader.read(chars))!=-1){
    50.                 System.out.print(new String(chars,0,readLen));
    51.             }
    52.  
    53.         } catch (IOException e) {
    54.             e.printStackTrace();
    55.         } finally {
    56.             try {
    57.                 fileReader.close();
    58.             } catch (IOException e) {
    59.                 e.printStackTrace();
    60.             }
    61.         }
    62.     }
    63. }
    64.

     两种读取方式：

    第一种单个字符读取，第二种使用字符数组读取文件。

    运行结果：

    FileWriter:

    1) new FileWriter(File/String):覆盖模式，相当于流的指针在首端

    2) new FileWriter(File/String,true):追加模式，相当于流的指针在尾端

    ●3) write(int):写入单个字符

    4) write(char[):写入指定数组

    5) write(charDjoff,len):写入指定数组的指定部分

    6) write (string) ;写入整个字符串

    7) write(string,off,len):写入字符串的指定部分

    相关API: String类: toCharArray:将String转换成char[]

    注意：FileWriter使用后，必须要关闭(close)或刷新(flush), 否则写入不到指定的文件!

     FileWriter案例：

    上代码：

    创建note.txt文件，并写入内容。

    5种写入方法：

    1. package com.io.writer;
    2.  
    3. import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;
    4.  
    5. import java.io.FileWriter;
    6. import java.io.IOException;
    7.  
    8. /**
    9.  * FileWriter的使用：将"风雨之后，必有彩虹"写入note.txt文件中
    10.  * 1.write(int):写入单个字符
    11.  * 2.write(char[]):写入指定数组
    12.  * 3.write(char[],off,Len):写入指定数组的指定部分
    13.  * 4.write(string):写入整个字符串
    14.  * 5.write(string, off, Len):写入字符串的指定部分
    15.  */
    16. public class Demo01 {
    17.     public static void main(String[] args) {
    18.         String filePath = "e:\\note.txt";
    19.         char[] chars = {'a', 'b', 'c'};
    20.         String str = "你好北京";
    21.         FileWriter fileWriter = null;
    22.         try {
    23.             fileWriter = new FileWriter(filePath, true);
    24. //            1.write(int):写入单个字符
    25.             fileWriter.write('H');
    26. //            2.write(char[]):写入指定数组
    27.             fileWriter.write(chars);
    28. //            3.write(char[],off,Len):写入指定数组的指定部分
    29.             fileWriter.write(chars,0,3);
    30. //            4.write(string):写入整个字符串
    31.             fileWriter.write(str);
    32. //            5.write(string, off, Len):写入字符串的指定部分
    33.             fileWriter.write(str, 0, 2);
    34.  
    35.         } catch (IOException e) {
    36.             e.printStackTrace();
    37.         } finally {
    38.             try {
    39.                 fileWriter.close();
    40.             } catch (IOException e) {
    41.                 e.printStackTrace();
    42.             }
    43.         }
    44.         System.out.println("程序运行完成...");
    45.     }
    46. }

    运行结果：

    这里采用了追加的写入方式。

     

  • 相关阅读:
    我的创作纪念日
    Unity之手游UI的点击和方向移动
    Android学习笔记 75. 单元测试
    运维知识点-Windows操作系统cmd/Dos批处理命令与脚本手册bat
    【无标题】
    java毕业设计企业售后服务管理系统mybatis+源码+调试部署+系统+数据库+lw
    显著性目标检测（一）——与图像分割、目标检测的区别
    经过物联网技术的设备改造有“大脑”,更智能
    uniapp使用多列布局显示图片，一行两列
    【C++】STL容器适配器入门：【堆】【栈】【队列】（16）
  • 原文地址：https://blog.csdn.net/qq_59212867/article/details/125464445