IO流学习笔记

1.File类

文件和目录路径名的抽象表示形式。

4种构造方法

File(File parent, String child)

File(File parent, String child)

File(String parent, String child)

File(URI uri)

 

创建一个文件

案例【1】

import java.io.File;
import java.io.IOException;

public class FileDemo {

    /**
     * 创建一个文件
     */
    public static void main(String[] args) {
        // TODO 自动生成的方法存根
     File f = new File("F:\\file.txt"); 
     System.out.println(f.exists());
     try {
        f.createNewFile();
    } catch (IOException e) {
        // TODO 自动生成的 catch 块
        e.printStackTrace();
    }
     System.out.println(f.exists());
    }

}

运行结果：

false

true

打开F盘会发现存在一个0字节的file.txt文件

 

 

 路径分隔符

在不同的系统中路径分隔符是不同的，所以想要代码有更好的移植性，我们采用pathSeparator和separator公共静态字段。

案例【2】

import java.io.File;
import java.io.IOException;

public class FileDemo {

    /**
     * 创建一个文件
     */
    public static void main(String[] args) {
        // TODO 自动生成的方法存根
     String filename ="F:"+File.separator+"file.text2";
     File f = new File(filename); 
     File f2 = new File("1.txt");
     
     try {
        f.createNewFile();
        f2.createNewFile();
    } catch (IOException e) {
        // TODO 自动生成的 catch 块
        e.printStackTrace();
    }
     System.out.println(f.getName());
     System.out.println(f.getAbsolutePath());
     System.out.println(f.getPath());
     System.out.println(f2.getName());
     System.out.println(f2.getAbsolutePath());
     System.out.println(f2.getPath());
    }

}

输出结果：

file.text2
F:\file.text2
F:\file.text2
1.txt
F:\ec\HelloWorld\1.txt
1.txt
注意体会AbsolutePath和Path（我的项目写在F:\ec\HelloWorld文件夹中）

 

创建多级文件夹

File类中的mkdir()和mkdirs()可以用来创建目录，区别是mkdirs()可以创建多层目录，即同时创建这个目录的父目录和父目录的目录，而mkdir()

要求创建目录的父目录已经存在。

案例【3】

import java.io.File;

public class FileDemo {

    /**
     * 创建一个多级文件夹
     */
    public static void main(String[] args) {
     String filename ="F:"+File.separator+"a"+File.separator+"b";
     File f = new File(filename); 
     f.mkdirs();
     
    }

}

运行完打开F盘发现多了文件夹a，打开文件夹a。里面有空文件夹b。

 

列出指定目录的全部文件(不包括子目录)

File类中存在list和Filelist方法，返回的分别是String类型的数组和File类型的数组

案例【4】

import java.io.File;

public class FileDemo {

    /**
     * 列出指定目录文件(不包括子目录)
     */
    public static void main(String[] args) {
     String filename ="F:"+File.separator+"src";
     File f = new File(filename); 
     File[] f2 = f.listFiles();
     for(int i=0;i<f2.length;i++)
     {
         System.out.println(f2[i]);
     } 
    }

}

输出：

F:\src\A.class
F:\src\abc.java
F:\src\B$1.class
F:\src\B$C.class
F:\src\B.class
F:\src\back
F:\src\Car.class
F:\src\day01.class
F:\src\pack

列出指定目录的全部文件(包括子目录)

对于这个问题，我们需要用到isDirectory()方法和递归。

对于isDirectory()方法，当且仅当此抽象路径名表示的文件存在且是一个目录时，返回 true；否则返回 false。

因此我们可以对文件夹列出使用递归，如果文件夹下还有文件夹，则对后者接着使用列出方法。

案例【5】

import java.io.File;

public class FileDemo {

    /**
     * 列出指定目录文件(包括子目录)
     */
    public static void main(String[] args) {
     String filename ="F:"+File.separator+"src";
     File f = new File(filename); 
     listAll(f);
    }

    public static  void listAll(File f)
    {
        File[] f2 =f.listFiles();
        for(int i=0;i<f2.length;i++)
        {
            if(f2[i].isDirectory())
            {
                System.out.println(f2[i]);
                listAll(f2[i]);
            }
            else
            {
                System.out.println(f2[i]);
            }
        }
    }
}

输出结果：

F:\src\A.class
F:\src\abc.java
F:\src\B$1.class
F:\src\B$C.class
F:\src\B.class
F:\src\back
F:\src\back\packageDemo.class
F:\src\Car.class
F:\src\day01.class
F:\src\pack
F:\src\pack\abc.class

我们可以发现虽然列出了所有的文件夹和文件夹下的文件，但是我们直观上并不好看出哪些是一级目录下的，哪些是子目录下的文件，

所以我们对此进行改进。

案例【6】

import java.io.File;

public class FileDemo {

    /**
     * 列出指定目录文件(包括子目录)
     */
    public static int level =0;
    public static void main(String[] args) {
     String filename ="F:"+File.separator+"src";
     File f = new File(filename); 
     listAll(f);
    }

    public static  void listAll(File f)
    {
        File[] f2 =f.listFiles();
        for(int i=0;i<f2.length;i++)
        {
            if(f2[i].isDirectory())
            {    
                print(level);
                System.out.println(f2[i]);
                level++;
                listAll(f2[i]);
            }
            else
            {   
                print(level);
                System.out.println(f2[i]);
            }    
        }
        level--;
    }

    private static void print(int level) {
        for(int i=0;i<level;i++)
        System.out.print("——");    
    }
}

输出：

F:\src\A.class
F:\src\B$1.class
F:\src\B$C.class
F:\src\B.class
F:\src\back
+F:\src\back\abc.java
+F:\src\back\packageDemo.class
F:\src\Car.class
F:\src\day01.class
F:\src\pack
+F:\src\pack\abc.class

我们可以清楚的看到一级目录下的文件和文件夹是没有+号的，二级目录有个+号，如果有三级目录的话，会出现两个+号。

 

 

文件过滤

当我们需要在一堆文件中找到我们需要的特定类型文件时我们可以根据后缀名过滤。

public String[] list(FilenameFilter filter)

public File[] listFiles(FilenameFilter filter)
这两个方法需要FilenameFilter对象参数。

FilenameFilter是一个接口，其中声明了一个方法
boolean accept（File dir ，String name）
我在F盘src文件夹中添加了2个txt文本文件，并将其过滤去。
案例【7】

import java.io.*;

//后缀名文件过滤器
public class SuffixFilter implements FilenameFilter {

    public boolean accept(File dir, String name) {
        
        return name.endsWith(".txt");
    }
    
}


import java.io.File;

public class FileDemo {

    /**
     * 列出指定目录文件(不包括子目录)下的txt格式文件
     */
    public static void main(String[] args) {
     String filename ="F:"+File.separator+"src";
     File f = new File(filename); 
     File[] f2 = f.listFiles(new SuffixFilter());
     for(int i=0;i<f2.length;i++)
     {
         System.out.println(f2[i]);
     } 
    }

}

运行结果：

F:\src\新建文本文档 (2).txt
F:\src\新建文本文档.txt

我们可以看到成功筛选出txt文档文件。

 

2字符流

Reader和Writer是字符流的超类，直接继承自Object类的抽象类。

以字符为单位进行读写。

这些体系的子类都以父类名作为后缀。
而且子类名的前缀就是该对象的功能。

以子类FileReader和FileWriter为例作为说明

案例【8】

import java.io.*;

public class FileDemo {

    /**
     *  字符流读写
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
        String filename ="F:"+File.separator+"字符流.txt";
        
            FileWriter fw =new FileWriter(filename);
            fw.write("zerocoin你好");
            fw.close();
            FileReader fr =new FileReader(filename);
            System.out.println((char)fr.read());
            int ch=0;
            while((ch=fr.read())!=-1)
            {
                System.out.print((char)ch);
            }
            fr.close();
     
    }

输出结果：

z
erocoin你好

F盘中出现字符流.txt,内容是zerocoin你好。

不难发现read()方法返回的是int型，当所有数据读完时，返回—1。

read方法中也可以添加参数。

案例【9】

import java.io.*;

public class FileDemo {

    /**
     *  字符流读写
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
        String filename ="F:"+File.separator+"字符流.txt";
        
            FileWriter fw =new FileWriter(filename);
            fw.write("zerocoin你好");
            fw.close();
            FileReader fr =new FileReader(filename);
            //System.out.println((char)fr.read());
            char[] ch=new char[1024];
            int len=0;
            while((len=fr.read(ch))!=-1)//数组作为参数，读取到数组中
            {
                System.out.print(new String(ch,0,len));
            }
            fr.close();
     
    }

}

zerocoin你好

 

我们在往已存在内容的文件中用Write方法的话，会从头开始写，文件内容会被覆盖，

我们可以使用FileWriter另一个构造器生成对象进行续写。

即FileWriter(String fileName,  true)。

 

3字节流

字节流按字节读写

案例【9】

import java.io.*;

public class FileDemo {

    /**
     *  字节流读写
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
            String filename ="F:"+File.separator+"字节流.txt";
            FileOutputStream fo =new FileOutputStream(filename);
            FileInputStream fi = new FileInputStream(filename);
            //fo.write("zerocoin你好");错误，字节流没有write(string s)方法
            fo.write("zerocoin你好".getBytes());
            fo.close();
            byte [] ch=new byte[1024];
            int len=0;
            while((len=fi.read(ch))!=-1)//数组作为参数，读取到数组中
            {
                System.out.print(new String(ch,0,len));
            }
            fi.close();
     
    }

}

输出

zerocoin你好

F盘中出现字节流.txt

关于字节流和字符流的区别（参考于Rollen博客）

实际上字节流在操作的时候本身是不会用到缓冲区的，是文件本身的直接操作的，但是字符流在操作的 时候下后是会用到缓冲区的，是通过缓冲区来操作文件的。

读者可以试着将上面的字节流和字符流的程序的最后一行关闭文件的代码注释掉，然后运行程序看看。你就会发现使用字节流的话，文件中已经存在内容，但是使用字符流的时候，文件中还是没有内容的，这个时候就要刷新缓冲区。

使用字节流好还是字符流好呢？

答案是字节流。首先因为硬盘上的所有文件都是以字节的形式进行传输或者保存的，包括图片等内容。但是字符只是在内存中才会形成的，所以在开发中，字节流使用广泛。

 

 

4. BufferedReader和BufferedWriter流

从字符输入流中读写文本，缓冲各个字符，从而实现字符、数组和行的高效读写。

存在newLine()，readLine(),reset(),skip()等新方法

案例【10】

import java.io.*;

public class FileDemo {

    /**
     *  
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
        String filename ="F:"+File.separator+"字符流.txt";
        
            FileWriter fw =new FileWriter(filename);
            BufferedWriter bfw = new BufferedWriter(fw);
            bfw.write("第一行");
            bfw.newLine();//分行符
            bfw.write("012345", 0, 3);//从0读到2位
            bfw.close();
            FileReader fr =new FileReader(filename);
            BufferedReader bfr =new BufferedReader(fr);
            
            String str=null;
            //readLine()返回String类型,读完返回null
            while((str=bfr.readLine())!=null)
            {
                System.out.println(str);
            }
            bfr.close();
     
    }

}

输出结果：

第一行
012

F盘中字符流.txt也被写入这输出。

BufferedInputStream和BufferOutputStream类似。
缓冲区中无非就是封装了一个数组，
 并对外提供了更多的方法对数组进行访问。
 其实这些方法最终操作的都是数组的角标。
缓冲的原理：
 其实就是从源中获取一批数据装进缓冲区中。
 在从缓冲区中不断的取出一个一个数据。

好处:效率更高。

 

5转换流

InputStreamReader和OutputStreamWriter 字节流转字符流

转换流的出现方便了对文件的读写，她在字符流与字节流之间架起了一座桥梁，使原本毫无关联的两种流操作能够进行转化，提高了程序的灵活性

import java.io.*;

public class FileDemo {

   
    public static void main(String[] args) throws IOException {
        String filename ="F:"+File.separator+"转换流.txt";
        File f =new File(filename);
        FileOutputStream out =new FileOutputStream(f); 
        OutputStreamWriter osw =new OutputStreamWriter(out);
        BufferedWriter bufw = new BufferedWriter(osw);
        bufw.write("hello zerocoin");
        bufw.close();
        
    }

}

F盘下出现了转换流.txt.

InputStreamReader也是同样的用法。

下面主要讲下InputStreamReader(InputStream in,String charsetName)

和 OutputStreamWriter(OutputStream out,String charsetName)两种构造器。

 

import java.io.*;

public class FileDemo {
    /**
     * 用UTF编码写，默认编码GBK读 
     */
   
    public static void main(String[] args) throws IOException {
        String filename ="F:"+File.separator+"转换流.txt";
        File f =new File(filename);
        OutputStreamWriter osw =new OutputStreamWriter(new FileOutputStream(f),"UTF-8");
        osw.write("hello你好吗zerocoin");
        osw.close();
        InputStreamReader isr=new InputStreamReader(new FileInputStream(f));
        char []ch = new char[1024];
        int len;
        while((len=isr.read(ch))!=-1)
        {
            System.out.println(new String(ch,0,len));
        }
       
    }
}

 

结果：hello浣犲ソ鍚梲erocoin

为什么会出现乱码呢？因为当我们InputStreamReader(InputStream in)和OutputStreamWriter(OutputStream out)的默认

都是用的系统的字符集GBK。所以当我们用UTF—8码进行写入，GBK进行读取时就会出现乱码。我们可以设置用UTF—8码读，这样

就可以解决问题。

 

import java.io.*;

public class FileDemo {
    /**
     * 用UTF-8编码写，UTF-8读 
     */
   
    public static void main(String[] args) throws IOException {
        String filename ="F:"+File.separator+"转换流.txt";
        File f =new File(filename);
        OutputStreamWriter osw =new OutputStreamWriter(new FileOutputStream(f),"UTF-8");
        osw.write("hello你好吗zerocoin");
        osw.close();
        InputStreamReader isr=new InputStreamReader(new FileInputStream(f),"UTF-8");
        char []ch = new char[1024];
        int len;
        while((len=isr.read(ch))!=-1)
        {
            System.out.println(new String(ch,0,len));
        }
       
    }
}

 

 

 

输出：hello你好吗zerocoin

 

6.标准流

JAVA语言包中有一个类System，这个类没有共有的构建器，因此我们并不能创建这个类的实例对象。

它提供了三个静态类字段。

public final static InputStream in；

public final static PrintStream out；

public final static PrintStream err；

 

import java.io.*;

public class FileDemo {
    /**
     * 控制台写入文件
     */
   
    public static void main(String[] args) throws IOException {
        String filename ="F:"+File.separator+"text.txt";
        File f =new File(filename);
        BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter  bufw  =  new  BufferedWriter(new  OutputStreamWriter(new
        FileOutputStream(f)));
        String line = null;
        while((line=bufr.readLine())!=null){
        if("over".equals(line))
        break;
        bufw.write(line);
        bufw.newLine();
        bufw.flush();
        }
        
        
       
    }
}

 

输入：

你好
zerocoin
over

 

当输入over时，程序结束。text中写入

你好
zerocoin

 

7 Properties集合

* Map
* |--Hashtable
* |--Properties

* 特点：
* 1，该集合中的键和值都是字符串类型。
* 2，集合中的数据可以保存到流中，或者从流获取。
* 通常该集合用于操作以键值对形式存在的配置文件。

Properties 类表示了一个持久的属性集。Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。

 

import java.io.FileOutputStream;
import java.util.Properties;

public class PropertiesDemo{
       public static void main(String[] args) throws Exception  {
            propertiesDemo();
      }

       public static void propertiesDemo() throws Exception {
            Properties prop = new Properties();

            prop.setProperty( "zhangsan","10" );
            prop.setProperty( "lisi","20" );
            prop.setProperty( "wangwu","30" );
            prop.setProperty( "zhaoliu","40" );
            
             //想要将这些集合中的字符串键值信息持久化存储到文件中
             //需要关联输出流
            FileOutputStream fos = new FileOutputStream("info.txt" );

             //将集合中数据存储到文件中
            prop.store(fos, "name+age");

            fos.close();
      }
}