IO框架（Java）

IO框架

流的概念

• 概念：内存与存储设备之间传输数据的通道

流的分类

• 按方向

  • 输入流：将<存储设备>中的内容读入到<内存>中(read)

  • 输出流：将<内存>中的内容写入到<存储设备>中(write)

• 按单位：

  • 字节流：以字节为单位，可以读写所有数据

  • 字符流：以字符为单位，只能读写文本数据

• 按功能：

  • 节点流：具有实际传输数据的读写功能

  • 过滤流：在节点流的基础之上增强功能

字节流

• 字节流的父类（抽象类）：

  • InputStream：字节输入流

  • 方法：

    • public int read(){}

    • public int read(byte[] b){}

    • public int read(byte[] b,int off,int len){}

  • OutputStream：字节输出流

  • 方法：

    • pulic void write(int n){}

    • public void write(byte[] b){}

    • public void weite(byte[] b,int off,int len){}

• 文件字节流

  • FileInputStream：

    • public int read(byte[] b)从流中读取多个字节，将内容存入b数组，返回实际读到的字节数；如果达到文件的尾部则返回-1

       //创建FileInputStream，并指定文件路径
       FileInputStream fis = new FileInputStream("d:\\aaa.txt");
       //读取文件  fis.read()
       //单个字节读取
       int data = 0;
       while((data = fis.read()) != -1){
           System.out.print((char)data);
       }
       //一次读取多个字节
       byte[] buf = new byte[3];
       int count = 0;
       while((count = fis.read(buf)) != -1){
           System.out.println(new String(buf,0,count));
       }
       ​
       fis.close();

  • FileOutputStream：

    • public void write(byte[] b)一次写多个字节，将b数组中所有字节，写入输出流

       //创建一个文件字节输出流对象
       FileOutputStream fos = new FileOutStream("d\\bbb.txt");
       //写入文件 
       fos.write(97);
       fos.write('b');
       fos.write('c');
       //一次写入多个
       String str = "helloworld";
       fos.write(str.getBytes());
       //关闭
       fos.close();

字节缓冲流

• 缓冲流：BufferedInputStream/BufferOutputStream

  • 提高IO效率，减少访问磁盘的次数

  • 数据存储在缓冲区中，flush是将缓冲区的内容写入文件中，也可以直接close

     //创建BufferedInptStream
     FileInputStream fis = new FileInputStream("d:\\aaa.txt");
     BufferedInputStream bis = new BufferedInputStream(fis);
     //读取
     int data = 0;
     while((data = bis.read()) != -1){
         System.out.print((char)data);
     }
     //关闭
     bis.close();

     //创建字节输出缓冲流
     FileOutputStream fos = new FileOutputStream("d:\\buffer.txt");
     BufferedOutputStream bos = new BufferedOutputStream(fos);
     //写文件
     for(int i = 0;i < 10;i++){
         bos.write("helloworld\r\n".getBytes);//写入8k缓冲区
         bos.flush();//刷新到硬盘
     }
     //关闭（内部调用flush方法）
     bos.close();

对象流

• 对象流：ObjectOutputStream/ObjectInputStream

  • 增强了缓冲区功能

  • 增强了读写8种基本数据类型和字符串功能

  • 增强了读写对象的功能：

    • writeObject(Object obj) 向流中写入一个对象（序列化）

     //要求：序列化类必须实现Serializable接口
     //创建对象流
     FileOutputStream fos = new FileOutputStream("d:\\stu.bin");
     ObjectOutputStream oos = new ObjectOutputStream(fos);
     //序列化（写入操作）
     Student zhangsan = new Student("张三"，20);
     oos.writeObject(zhangsan);
     //关闭
     oos.close();

    • readObject() 从流中读取一个对象（反序列化）

     //使用ObjectInputStream实现反序列化(读取重构对象)
     //创建对象流
     FileInputStream fis = new FileInputStream("d://stu.bin");
     ObjectInputStream ois = new ObjectInputStream(fis);
     //读取文件(反序列化)
     Student s = (Student)ois.readObject();
     //关闭
     ois.close();
     System.out.println(s.toString());

• 注意：

  • 序列化类必须要实现Serializable接口

  • 序列化类中对象属性要求实现Serializable接口

  • 序列化版本号IDserialVersionUID，保证序列化的类和反序列化的类是同一个类

  • 使用transient<瞬间的>修饰属性，这个属性不能序列化

  • 静态属性不能序列化

  • 序列化多个对象，可以借助集合实现

编码方式

• ISO-8859-1 ：收录除ASCII外，还包括西欧、希腊语、泰语、阿拉伯语、希伯来语对应的文字符号

• UTF-8 ：针对Unicode码表的可变长字符编码

• GB2312 ：简体中文（国标）

• GBK ：简体中文、扩充

• BIG5 ：台湾，繁体中文

• 当编码方式和解码方式不一致时，会出现乱码

字符流

• 字符流的父类（抽象类）

  • Reader：字符输入流

    • public int read(){}

    • publlic int read(char[] c){}

    • public int read(char[] b,int off,int len){}

  • Writer：字符输出流

    • public void write(int n){}

    • public void write(String str){}

    • public void write(char[] c){}

• 文件字符流

  • FileReader：

    • public int red(char[] c) 从流中读取多个字符，将读到内容存入c数组，返回实际读到的字符数；如果达到文件尾部，返回-1

   //创建FileReader 文件字符输入流
   FileReader fr = new FileReader("d:\hello.txt");
   //读取
   //单个字符读取
   int data = 0;
   while((data = fr.read()) !=-1){
       System.out.print((char)data);
   }
   //多个字符读取
   char[] buf = new char[1024];
   int count = 0;
   while((count = fr.read(buf)) != -1){
       System.out.print(new String(buf,0,count));
   }
   //关闭
   fr.close();

  • FileWrite：

    • public void write(String str)一次写多个字符，将b数组中多有字符，写入输出流

   //创建FileWriter对象
   FileWriter fw = new FileWriter("d:\\writer.txt");
   //写入
   for(int i = 0;i < 10;i++){
       fw.write("java是世界上最好的语言\r\n");
       fw.flush();
   }
   //关闭
   fw.close();

• 使用FileReader和FileWriter复制文本文件，不能复制图片和二进制文件

• 使用字节流可以复制任意文件

• 字符缓冲流

  • 缓冲流：BufferedReader/BufferedWriter

  • 优点：

    • 高效读写

    • 支持输入换行符

    • 可一次写一行、读一行

  //创建缓冲流
  FileReader fr = new FileReader("d:\\write.txt");
  BufferedReader br = new BufferReader(fr);
  //读取
  //第一种方式
  charp[] buf = new char[1024];
  int count = 0;
  while((count = br.read(buf)) != -1){
      System.out.print(new String(buf,0,count));
  }
  //第二种方式，一行一行的读取
  String line = null;
  while ((line = br.readLine()) != null){
      System.out.println(line);
  }
  //关闭
  br.close();

  //创建BufferedWriter
  FileWriter fw = new FileWriter("d\\buffer.txt");
  BufferedWriter bw = new BufferedWriter(fw);
  //写入
  for(int i = 0;i < 10;i++){
      bw.write("hhxx,ttxs");
      bw.newLine();//写入一个换行符 windows \r\n  linux \n
      bw.flush();
  }
  //关闭
  bw.close();

打印流

• PrintWriter:

  • 封装了print()/println()方法，支持写入换行

  • 支持数据原样打印

//创建打印流
PrintWriter pw = new PrintWriter("d:\\print.txt");
//打印
pw.println(97);
pw.println(true);
pw.println(3.14);
pw.print('a');
//关闭
pw.close();

转换流

• 桥转换流：InputStreamReader/OutputStreamWriter

  • 可将字节流转换为字符流

  • 可设置字符的编码方式

• 使用InputStreamReader读取文件，指定使用的编码

//创建InputStreamReader对象
FileInputStream fis = new FileInputStream("d:\\write.txt");
InputStream isr = new InputStreamReader(fis,"utf-8");
//读取文件
ilnt data = 0;
while((data = isr.read()) != -1){
    System.out.print((char)data);
}
//关闭
isr.close();

• 使用OutputStreamWriter写入文件，使用指定编码

//创建OutputStreamWriter
FileOutputStream fos = new FileOutputStream("d:\\info.txt");
OutputStreamWriter osw = new OutputStreamWriter(fos,"gbk");
//写入
for(int i = 0;i < 10;i++){
    osw.writer("我爱北京，我爱故乡\r\n");
    osw.flush();
}
//关闭
osw.close();

File类

• 概念：代表物理盘符中的一个文件或文件夹

• 方法：

  • creatNewFile()---创建一个新文件

  • mkdir()---创建一个新目录

  • delete()---删除文件或空目录

  • exists()---判断File对象是否存在

  • getAbsolutePath()---获取文件的绝对路径

  • getName()---获取名字

  • getParent()---获取文件/目录所在的目录

  • isDirectory()---是否是目录

  • isFile()---是否是文件

  • length()---获得文件的长度

  • listFiles()---列出目录中的所有内容

  • renameTo()---修改文件名为

//分隔符
System.out.println("路径分隔符"+File.pathSeparator);
System.out.println("名称分隔符"+File.separator);
//输出：
//路径分隔符;
//名称分隔符\
//文件夹操作
//创建文件createNewFile()
File file = new File("d:\\file.txt");//创建了文件对象，还没有创建文件
if(file.exists()){
    boolean b = file.createNewFile();//创建成功
    System.out.println("创建结果："+b);
}
//删除文件
//直接删除
System.out.println("删除结果："+file.delete());
//使用jvm退出时删除
file.deleteOnExit();
//获取文件信息
System.out.println("获取文件的绝对路径："+file.getAbsolutePath());
System.out.println("获取路径："+file.getPath());
System.out.println("获取文件名称："+file.getName());
System.out.println("获取父目录："+file.getParent);
System.out.println("获取文件长度："+file.length());
System.out.println("文件创建时间："+new Date(file.lastModified()).toLocaleString());
//判断
System.out.println("是否可写："+file.canWrite());
System.out.println("是否是文件："+file.isFile());
System.out.println("是否隐藏："+file.isHidden());

//文件夹操作
//创建文件夹
File dir = new File("d:\\aaa\\bbb\\ccc");
if(!dr.exists()){
    //dir.mkdir();    只能创建单级目录
    System.out.println("创建结果："+dir.mkdirs());//创建多级目录
}
//删除文件夹
//直接删除  只能删除最底层目录（而且必须为空目录）
System.out.println("删除结果："+dir.delete());
//使用jvm删除
dir.deleteOnExit();
//获取文件夹信息
System.out.println("获取绝对路径："+dir.getAbsolutePath());
System.out.println("获取路径："+dir.getPath());
System.out.println("获取文件夹名称："+dir.getName());
System.out.println("获取父目录："+dir.getParent());
System.out.println("获取创建时间："+new Date(dir.lastModified()).toLocaleString());
//判断
System.out.println("是否是文件夹："+dir.isDirectory());
System.out.println("是否隐藏："+dir.isHidden());
//遍历文件夹
File dir2 = new File("d:\\图片");
String[] files = dir2.list();
for(String string : files){
    System.out.println(string);
}

• FileFilter接口

  • public interface FileFilter (接口)

    • boolean accept(File pathname) (方法)

  • 当调用File类中的listFiles()方法时，支持传入FileFilter接口实现类，对获取文件进行过滤，只有满足条件的文件才可出现在listFiles()的返回值中

 File dir2 = new File("C:\Users\xmc\Pictures\Saved Pictures");
 File[] files2 = dir2.ListFiles(new FileFilter() {
     @Override
     public boolean accept(File pathname) {
         if(pathname.getName().endsWith(".jpg")){
             return true;
         }
     }
 });
 for (File file : files2) {
     System.out.println(flie.getName());
 }

递归遍历和递归删除文件夹

 //递归遍历文件夹
 public static void listDir(File dir) {
     File[] files = dir.listFiles();
     System.out.println(dir.getAbsolutePath());
     if(files != null && files.length > 0){
         for(file file : files) {
             if(file.isDirectory()) {
                 listDir(file);//递归
             }else {
                 System.out.println(file.getAbsolutePath());
             }
         }
     }
 }
 //递归删除文件夹
 public static void deleteDir(File dir) {
     File[] files = dir.listFile();
     if(files != null && files.length > 0){
         for(File file : files){
             if(file.isDirectory()){
                 deleteDir(file);//递归
             }else {
                 //删除文件
                 System.out.println(file,getAbsolutePath()+"删除："+file.delete());
             }
         }
     }
     System.out.println(dir.getAbsolutePath()+"删除："+dir.delete());//删除文件夹
 }
 ​

Properties

• Properties:属性集合

• 特点：

  • 存储属性名和属性值

  • 属性名和属性值都是字符串类型

  • 没有泛型

  • 和流有关

• 使用

 //创建集合
 Properties properties = new Properties();
 //添加数据
 properties.setProperty("username","zhangsan");
 properties.setProperty("age","20");
 System.out.println(properties.toString());
 //遍历
 //用keySet
 //用entrySet
 //用stringPropertyNames()
 Set<String> pronames = properties.strigPropertyNames();
 for(String pro : pronames){
     System.out.println(pro+"==="+properties.getProperty(pro));
 }
 //和流有关的方法
 //list方法
 PrintWriter pw = new PrintWriter("d:\\print.txt");
 properties.list(pw);
 pw.close();
 //store方法 保存
 FileOutputStream fos = new FileOutputStream("d:\\store.properties");
 properties.store(fos,"注释");
 fos.close();
 //load方法 加载
 Properties properties2 = new Properties();
 FileInputStream fis = new FileInputStream("d:\\store.properties");
 properties2.load(fis);
 fis.close();
 System.out.println(properties2.toString());
 ​