Java IO 学习笔记

2023-08-26 11:15:10

1.核心类
  • File                     文件类
  • InputStream       字节输入流
  • OutputStream     字节输出流
  • Reader               字符输入流
  • Writer                字符输出流
  • Closeable           关闭流接口
  • Flushable           刷新流接口
  • Serializable        序列化接口


2.流分类
  • 输入流：数据源到程序(InputStream、Reader读进来)
  • 输出流：程序到目的地(OutputStream、Writer写进去)
  • 节点流：可以直接从数据源或 目的地读写数据
  • 处理流：不直接连接到数据源或目的地，是其他流进行封装。目的主要是简化操作和提高性能
  • 节点流和处理流的关系：
    • 节点流处于IO操作的第一线，所有操作必须用过他们进行
    • 处理流可以对其他流进行处理（提高效率或操作灵活性）
  • 字节流：按照字节读取数据(InputStream、OutputStream)
  • 字符流：按照字符读取数据(Reader、Writer)，因为文件编码的不同，从而有了对字符进行高效操作的字符流对象。
    • 原理：底层还是基于字节流操作，自动搜寻了指定的码表

Java IO 学习笔记

Java IO 学习笔记

3.File常用API及文件编码

文件路径推荐表示法：

          1.path= “D:/XXX/XXX/XXX.png”;

          2.path=”D:”+File.separator+”java300”+File.separator+”XXX.png”;

API

  • pathSeparator   separator                               路径|路径分隔符
  • File(String parent,String child)                        构造器
  • File(File parent,String child)                           
  • File(String name)
  • getName()                                                    文件名、路径名
  • getPath()
  • getAbsolutePath()
  • getParent
  • exists()                                                       判断状态
  • isFile()
  • isDirectorv()
  • length()                                                     文件长度
  • createNewFile()                                         创建新文件
  • delete()                                                    删除文件
  • mkdir()                                                    创建目录，需要确保上级目录存在，不存在时创建失败
  • mkdirs()                                                   创建目录，当父目录不存在时一同创建
  • list()                                                        下级名称
  • listFiles()                                                  下级File
  • listRoots()                                                根路径



4.IO流读写操作
  • InputStream                字节输入流的父类，数据单位为字节
    • int  read()
    • void  close()
  • OutputStream              字节输出流的父类，数据单位为字节
    • void  write(int)
    • void flush()
    • void close()
  • Reader                        字符输入流的父类，数据单位为字符
    • int  read()
    • void close()
  • Writer                         字符输出流的父类，数据单位为字符
    • void  write(String)
    • void  flush()
    • void  close()


5.代码段

输入流代码演示

  1 package wangyue;
  2 
  3 import java.io.*;
  4 
  5 public class IoStudy02 {
  6     public static void main(String[] args) {
  7         //1.创建源
  8         File file = new File("test");
  9         //2.创建流
 10         InputStream is = null;
 11         try {
 12             is = new FileInputStream(file);
 13             byte[] flush = new byte[30];//缓冲容器
 14             int len;//接收长度
 15             while ((len = is.read(flush)) != -1) {
 16                 String str = new String(flush, 0, len);
 17                 System.out.println(str);
 18             }
 19         } catch (FileNotFoundException e) {
 20             e.printStackTrace();
 21         } catch (IOException e) {
 22             e.printStackTrace();
 23         }finally {
 24             if (is != null) {
 25                 try {
 26                     is.close();
 27                 } catch (IOException e) {
 28                     e.printStackTrace();
 29                 }
 30             }
 31         }
 32     }
 33 }
 34

输出流代码演示

  1 package wangyue;
  2 
  3 import java.io.*;
  4 
  5 public class IoStudy03 {
  6     public static void main(String[] args) {
  7         //1.创建源
  8         File dest = new File("output.txt");
  9         //2.选择流
 10         OutputStream os = null;
 11         try {
 12             os = new FileOutputStream(dest);
 13             //3.操作
 14             String msg = "向文件中写入一些没什么用的东西";
 15             byte[] datas = msg.getBytes();//字符串--》字节数组  (编码)
 16             os.write(datas, 0, datas.length);
 17             //刷新流，避免有数据存在在缓存中。即使os.close() 也会刷新流，此处也再刷新一次
 18             os.flush();
 19         } catch (FileNotFoundException e) {
 20             e.printStackTrace();
 21         } catch (IOException e) {
 22             e.printStackTrace();
 23         }finally {
 24             if (os != null) {
 25                 try {
 26                     os.close();
 27                 } catch (IOException e) {
 28                     e.printStackTrace();
 29                 }
 30             }
 31         }
 32 
 33     }
 34 }
 35

文件拷贝

  1 package wangyue;
  2 
  3 import java.io.*;
  4 
  5 public class IoStudy04 {
  6     public static void main(String[] args) {
  7         //1.创建源
  8         File src = new File("C:/Users/86178/Desktop/微信截图_20191006134845.png");
  9         File dest = new File("C:/Users/86178/Desktop/copy.png");
 10         //2.选择流
 11         InputStream is = null;
 12         OutputStream os = null;
 13         try {
 14             is = new FileInputStream(src);
 15             os = new FileOutputStream(dest,false);
 16             //3.操作
 17             byte[] flush = new byte[1024];
 18             int len;
 19             while ((len = is.read(flush)) != -1) {
 20                 os.write(flush, 0, len);
 21             }
 22             //刷新流，避免有数据存在在缓存中。即使os.close() 也会刷新流，此处也再刷新一次
 23             os.flush();
 24         } catch (FileNotFoundException e) {
 25             e.printStackTrace();
 26         } catch (IOException e) {
 27             e.printStackTrace();
 28         }finally {
 29             if (os != null && is != null) {
 30                 //4.关闭资源，先打开的后关闭。注意要分别关闭
 31                 try {
 32                     is.close();
 33                 } catch (IOException e) {
 34                     e.printStackTrace();
 35                 }
 36                 try {
 37                     os.close();
 38                 } catch (IOException e) {
 39                     e.printStackTrace();
 40                 }
 41             }
 42         }
 43 
 44     }
 45 }
 46
6.字节数组流   ByteArrayInputStream & ByteArrayOutputStream

字节数组流无需关闭，由java虚拟机gc进行回收.

7.IO工具类
  1 package wangyue;
  2 
  3 import java.io.*;
  4 
  5 /**
  6  * 1、封装拷贝
  7  * 2、封装释放资源
  8  */
  9 public class FileUtils {
 10 
 11     public static void main(String[] args) {
 12 
 13         byte[] datas = null;
 14         //文件到文件
 15         try {
 16             InputStream is = new FileInputStream("test");
 17             OutputStream os = new FileOutputStream("test-copy.txt");
 18             copy(is, os);
 19         } catch (IOException e) {
 20             e.printStackTrace();
 21         }
 22         //文件到字节数组
 23         try {
 24             InputStream is = new FileInputStream("test.png");
 25             ByteArrayOutputStream os = new ByteArrayOutputStream();
 26             copy(is, os);
 27             datas = os.toByteArray();
 28             System.out.println(datas.length);
 29         } catch (IOException e) {
 30             e.printStackTrace();
 31         }
 32         //字节数组到文件
 33         try {
 34             InputStream is = new ByteArrayInputStream(datas);
 35             OutputStream os = new FileOutputStream("test-copy.png");
 36             copy(is,os);
 37         } catch (FileNotFoundException e) {
 38             e.printStackTrace();
 39         }
 40     }
 41 
 42     /**
 43      * 对接输入输出流
 44      * @param is
 45      * @param os
 46      */
 47     public static void copy(InputStream is, OutputStream os) {
 48         try {
 49             byte[] flush = new byte[2014];//缓冲容器
 50             int len;
 51             while ((len = is.read(flush)) != -1) {
 52                 os.write(flush, 0, len);
 53             }
 54             os.flush();
 55         } catch (IOException e) {
 56             e.printStackTrace();
 57         }finally {
 58             close(is,os);
 59         }
 60     }
 61 
 62     /**
 63      * 释放资源
 64      * @param is
 65      * @param os
 66      */
 67     public static void close(InputStream is,OutputStream os) {
 68         try {
 69             if (is != null) {
 70                 is.close();
 71             }
 72         } catch (IOException e) {
 73             e.printStackTrace();
 74         }
 75 
 76         try {
 77             if (os != null) {
 78                 os.close();
 79             }
 80         } catch (IOException e) {
 81             e.printStackTrace();
 82         }
 83     }
 84 
 85     /**
 86      * 释放资源
 87      * @param ios
 88      */
 89     public static void close(Closeable... ios) {
 90         for (Closeable io : ios) {
 91             try {
 92                 if (null != io) {
 93                     io.close();
 94                 }
 95             } catch (IOException e) {
 96                 e.printStackTrace();
 97             }
 98         }
 99     }
100 
101 }
102 
  1 package wangyue;
  2 
  3 import java.io.*;
  4 
  5 public class FileUtils2 {
  6     /**
  7      * 对接输入输出流
  8      * try...with...resource
  9      * 不需要在finally中释放资源，只要try(is,os)即可，系统自动释放资源，不需要关心释放顺序
 10      * @param is
 11      * @param os
 12      */
 13     public static void copy(InputStream is, OutputStream os) {
 14         try (InputStream iss = new FileInputStream("sdf");
 15             OutputStream oss = new FileOutputStream("test")) {
 16 
 17             byte[] flush = new byte[2014];//缓冲容器
 18             int len;
 19             while ((len = is.read(flush)) != -1) {
 20                 os.write(flush, 0, len);
 21             }
 22             os.flush();
 23         } catch (IOException e) {
 24             e.printStackTrace();
 25         }
 26     }
 27 }
 28


8.装饰器设计模式，原理剖析

Java IO 学习笔记

  1 package wangyue;
  2 
  3 /**
  4  * 模拟咖啡
  5  * 1、抽象组件：需要装饰的抽象对象（接口或抽象父类）
  6  * 2、具体组件：需要装饰的对象
  7  * 3、抽象装饰类：包含了对抽象组件的引用，以及装饰者共有的方法
  8  * 4、具体装饰类：被装饰的对象
  9  */
 10 public class DecorateTest02 {
 11 
 12     public static void main(String[] args) {
 13         Drink coffee = new Coffee();
 14         Drink sugar = new Sugar(coffee);
 15         System.out.println(sugar.info() + "-->" + sugar.cost());
 16         Drink milk = new Milk(coffee);
 17         System.out.println(milk.info() + "-->" + milk.cost());
 18     }
 19 }
 20 //抽象组件
 21 interface Drink {
 22     double cost();//费用
 23     String info();//说明
 24 }
 25 
 26 //具体组件
 27 class Coffee implements Drink {
 28     private String name = "原味咖啡";
 29 
 30     @Override
 31     public double cost() {
 32         return 10;
 33     }
 34 
 35     @Override
 36     public String info() {
 37         return name;
 38     }
 39 }
 40 
 41 //抽象装饰类
 42 abstract class Decorate implements Drink {
 43 
 44     //对抽象组件的引用
 45     private Drink drink;
 46 
 47     public Decorate(Drink drink) {
 48         this.drink = drink;
 49     }
 50 
 51     @Override
 52     public double cost() {
 53         return this.drink.cost();
 54     }
 55 
 56     @Override
 57     public String info() {
 58         return this.drink.info();
 59     }
 60 }
 61 
 62 //具体的装饰类
 63 class Milk extends Decorate {
 64 
 65     public Milk(Drink drink) {
 66         super(drink);
 67     }
 68     @Override
 69     public double cost() {
 70         return super.cost() * 4;
 71     }
 72 
 73     @Override
 74     public String info() {
 75         return super.info() + "牛奶";
 76     }
 77 }
 78 //具体的装饰类
 79 class Sugar extends Decorate {
 80 
 81     public Sugar(Drink drink) {
 82         super(drink);
 83     }
 84     @Override
 85     public double cost() {
 86         return super.cost() * 2;
 87     }
 88 
 89     @Override
 90     public String info() {
 91         return super.info() + "加入优质方糖";
 92     }
 93 }
 94 
 95
上一篇：代码实现排列组合【Java】


下一篇：java学习（150）：文本缓冲流