Java IO 流学习

1： File 文件操作类

file 常用 api 案例

package my.io.test;

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

public class DemoFile01 {
    public static void main(String[] args) {
        System.out.println(File.separator); //获取路径分隔符
        System.out.println(File.pathSeparator); // path 环境变量分隔符

        // public File(String pathname)
        File file = new File("D:"+File.separator+"iotest"+File.separator+"a.txt");
        System.out.println(file);// 重写了 toString() 并没有真的生成文件到 路径

        //public File(String parent, String child)
        File file2 = new File("D:"+File.separator,"iotest"+File.separator+"B.txt");
        System.out.println(file2);

        String path = file2.getAbsolutePath();  //获取绝对路径
        System.out.println(path);

        String name = file.getName();// 获取文件名
        System.out.println(name);

        String path2 = file.getPath();
        System.out.println(path2);

        //============================================
        File file3 = new File("D:"+File.separator,"iotest"+File.separator+"1.PNG");
        System.out.println(file3.length());  //获取文件大小
        File file4 = new File("D:"+File.separator,"iotest"+File.separator+"2.PNG");
        System.out.println(file4.length());// 文件不存在 输出大小为0

        boolean exist = file3.exists();//判断文件或目录是否存在
        System.out.println(exist);
        boolean isDirectory = file3.isDirectory();// 是否是路径
        System.out.println(isDirectory);
        boolean isfile = file3.isFile();  //是否是 文件
        System.out.println(isfile);

        File file5 = new File("D:"+File.separator);
        File[]  fileList = file5.listFiles();// 获取文件和目录列表
        for (int i = 0; i < fileList.length; i++) {
            File tempFile = fileList[i];
            if(tempFile.isFile()){
                System.out.println(tempFile.getName()+" is File "+tempFile.isFile());  //判断是否是文件
            }else {
                System.out.println(tempFile.getName()+" is Directory "+tempFile.isDirectory()); //判断是否是目录
            }

        }

        File file6 = new File("D:"+File.separator,"iotest");
        System.out.println(file6.getParent()); // 获取父级路径

        //====================================
        File file7 = new File("D:"+File.separator+"iotest"+File.separator+"a.txt");
        try {
            boolean flag = file7.createNewFile();
            // 创建文件 ，不存在创建 存在时重复执行，也不会再创建 或者覆盖原来的
            //如果路径不存在 还会抛io异常
            System.out.println(flag);
        } catch (IOException e) {
            e.printStackTrace();
        }

        File file8 = new File("D:"+File.separator+"iotest\tttt");
        boolean flag2 = file8.mkdir();//创建单个目录
        System.out.println(flag2);

        File file9 = new File("D:"+File.separator+"iotest\aaa\bbb\ccc");
        boolean flag3 = file9.mkdirs();//创建多个递归目录
        System.out.println(flag3);


        File file10 =  new File("D:"+File.separator+"iotest");
        String[] file10s = file10.list();
        for (String names : file10s) {
            System.out.println(names);
        }

        File file11 =  new File("D:"+File.separator+"iotest");
        File[] fils = file11.listFiles();
        for (File f: fils) {
            System.out.println(f);
        }
    }
}

案例2：

递归获取文件加下的目录 和文件

package my.io.test;

import java.io.File;

public class DemoFile02 {
// 递归获取文件加下的目录 和文件
    public static void main(String[] args) {
        File file9 = new File("D:"+File.separator+"iotest\aaa");
        getAllFiles(file9);
    }

    public static void getAllFiles(File f){
        if(null != f ){
            File[] tempFiles = f.listFiles();
            for (File ff : tempFiles) {
                if(ff.isDirectory()){
                    System.out.println(ff.getName());
                    getAllFiles(ff);
                }else  {
                    System.out.println(ff.getName());
                }
            }

        }
    }
}

案例3: 文件过滤器的使用

package my.io.test;

import java.io.File;

public class DemoFile03 {
// 递归获取文件加下的目录 和文件
    public static void main(String[] args) {
        File file9 = new File("D:"+File.separator+"iotest\aaa");
        getAllFiles(file9);
    }

    public static void getAllFiles(File f){
        if(null != f ){
            //添加过滤器 实现 只查询出 .PNG 结尾的文件
            File[] tempFiles = f.listFiles(new FileFilterImpl());
            for (File ff : tempFiles) {
                if(ff.isDirectory()){
                    //System.out.println(ff.getName());
                    getAllFiles(ff);
                }else  {
                    System.out.println(ff.getName());
                }
            }
        }
    }
}



package my.io.test;


import java.io.File;
import java.io.FileFilter;

public class FileFilterImpl implements FileFilter {

    @Override
    public boolean accept(File pathname) {
        //过滤出 。PNG 结尾的文件
        if(pathname.isDirectory() || pathname.getName().endsWith(".PNG")){
            return true;
        }
        return false;
    }

}

使用匿名内部类来实现

package my.io.test;

import java.io.File;
import java.io.FileFilter;

public class DemoFile03 {
// 递归获取文件加下的目录 和文件
    public static void main(String[] args) {
        File file9 = new File("D:"+File.separator+"iotest\aaa");
        getAllFiles(file9);
    }

    public static void getAllFiles(File f){
        if(null != f ){
            //添加过滤器 实现 只查询出 .PNG 结尾的文件
           // File[] tempFiles = f.listFiles(new FileFilterImpl());  //使用接口实现类的方式来实现
            File[] tempFiles = f.listFiles(
                    new FileFilter() {  //使用匿名内部类的方式来实现
                        @Override
                        public boolean accept(File pathname) {
                            if(pathname.isDirectory() || pathname.getName().endsWith(".PNG")){
                                return true;
                            }
                            return false;
                        }
                    }
            );
            for (File ff : tempFiles) {
                if(ff.isDirectory()){
                    //System.out.println(ff.getName());
                    getAllFiles(ff);
                }else  {
                    System.out.println(ff.getName());
                }
            }
        }
    }
}

2：IO 流介绍 2.1：字节输出流

        //java.io.OutputStream  字节输出流的父类
        // 子类
        //          ByteArrayOutputStream
        //          FileOutputStream
        //          FilterOutputStream
        //          ObjectOutputStream
        //          PipedOutputStream

这里以 FilterOutputStream 为例 ,其他几个实现类的使用方式大体是一致的

package my.io.test;


import java.io.*;

public class DemoIO01 {
    //字节输出流
    public static void main(String[] args) throws IOException {
        //java.io.OutputStream  字节输出流的父类
        // 子类
        //          ByteArrayOutputStream
        //          FileOutputStream
        //          FilterOutputStream
        //          ObjectOutputStream
        //          PipedOutputStream

        String path = "D:"+File.separator+"iotest\aaa\output\output01.txt";
        //FileOutputStream fos = new FileOutputStream(path); //append 参数默认为false 生成文件未被替换
        FileOutputStream fos = new FileOutputStream(path,true);//append 参数默认为true生成文件未被追加
        //fos.write(97);  // 一次写入一个字节
        byte[] out = "你好中国123456".getBytes("UTF-8");
        fos.write(out);
        //fos.write(out,0,12); //一次使用多个字节 按指定的返回来写入指定的字节大小
        //  换行符 windows rn   linux n   mac r
        fos.write(out,0,out.length);
        fos.close();
    }
}

案例二

package my.io.test;

import java.io.*;

public class DemoIO02 {
    public static void main(String[] args) throws IOException {
        String path = "D:"+ File.separator+"iotest\aaa\output\output02.txt";
        FileOutputStream fos = new FileOutputStream(new File(path));  //这里和案例一不同，使用的事文件类作为参数
        //byte[] output = "11111我是中国人".getBytes("UTF-8");
        byte[] output = {65,66,67,68};  //正数会查询 对应的码表 转化为对应的字符 ABCD
        fos.write(output);
        fos.close();
    }
}

2.2字节输入流

也是用FileInputStream 为例

package my.io.test;

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

public class DemoIO03 {
    public static void main(String[] args) throws IOException {
        String path = "D:"+ File.separator+"iotest\aaa\output\output01.txt";
        FileInputStream fis = new FileInputStream(path);
        int len = 0;
        while ((len = fis.read()) != -1){ //判断 是否读取到字节的最后一位
            System.out.println((char)len);//一个一个字节的读取数据
        }
        fis.close();
    }
}

案例2

package my.io.test;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class DemoIO04 {
    public static void main(String[] args) throws IOException {
        java.lang.String path = "D:"+ File.separator+"iotest\aaa\output\output01.txt";
        FileInputStream fis = new FileInputStream(path);
        byte[] bytes = new byte[1024]; //创建一个字节缓冲区,一次读取多个字节,可以提高读取效率
//        int len = fis.read(bytes);
//        System.out.println(len);
//        System.out.println(new String(bytes));
        int len = 0 ;
        while((len = fis.read(bytes)) != -1){ // 读取到文件末尾
            System.out.println(new String(bytes,0,len)); // 只读取文件有效的位数的数据
        }
        fis.close();
    }
}

案例3: 字节流实现文件复制

方式1 一次一个字节一个字节的处理

package my.io.test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class DemoIO05 {
    //文件复制
    public static void main(String[] args) throws IOException {
        String inputPath = "D:"+ File.separator+"iotest\174.PNG";
        String outputPath = "D:"+ File.separator+"iotest\aaa\174.PNG";
        FileInputStream fileInputStream =  new FileInputStream(inputPath);
        FileOutputStream  fileOutputStream = new FileOutputStream(outputPath);
        //一个字节一个字节的读写
        int len = 0;
        while ((len = fileInputStream.read())!=-1){
            fileOutputStream.write(len);
        }
        fileOutputStream.close();
        fileInputStream.close();
    }
}

优化一下上面的代码采用一次读取多个字节的方式对比执行时间

package my.io.test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class DemoIO06 {
    //文件复制
    public static void main(String[] args) throws IOException {
        String inputPath = "D:"+ File.separator+"iotest\174.PNG";
        String outputPath = "D:"+ File.separator+"iotest\aaa\175.PNG";
        FileInputStream fileInputStream =  new FileInputStream(inputPath);
        FileOutputStream  fileOutputStream = new FileOutputStream(outputPath);
        //一个字节一个字节的读写
        int len = 0;

        long start = System.currentTimeMillis();
        byte[] bytes = new byte[1024];
        while ((len = fileInputStream.read(bytes))!=-1){
            fileOutputStream.write(bytes,0,len); //每次读取有效的长度
        }
        long end = System.currentTimeMillis();
        System.out.println((end-start)+".ms");
        fileOutputStream.close();
        fileInputStream.close();
    }
}

2.3: 字符输入流

案例1

package my.io.test;

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

public class DemoIO07 {
    //字符流
    public static void main(String[] args) throws IOException {
        String path = "D:"+ File.separator+"iotest\aaa\output\output01.txt";
        FileReader fileReader = new FileReader(path);
        int len = 0;
        while ((len = fileReader.read())!=-1){
            System.out.println((char)len);
        }
        fileReader.close();
    }
}

案例2：

package my.io.test;

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

public class DemoIO08 {
    //字符流
    public static void main(String[] args) throws IOException {
        String path = "D:"+ File.separator+"iotest\aaa\output\output01.txt";
        FileReader fileReader = new FileReader(path);
        char[]  chars = new char[1024]; //创建有一个字符缓冲区来保存读取数据
        int len = 0;
        while ((len = fileReader.read(chars))!=-1){ //循环读取一直到文件末尾
            System.out.println(new String(chars,0,len)); //读取有效的字符长度
        }
        fileReader.close();
    }
}

2.4: 字符输出流

package my.io.test;

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

public class DemoIO09 {
    //字符输出流
    public static void main(String[] args) throws IOException {
        String path = "D:"+ File.separator+"iotest\aaa\output\output02.txt";
        FileWriter fileWriter = new FileWriter(path);
        fileWriter.write("你好 范冰冰");
        fileWriter.flush();  //将内存缓存区的数据刷新到文件中 流对象可以继续使用
        fileWriter.write("你好 杨幂");
        fileWriter.close();  //close 将内存缓存区的数据刷新到文件中 流对象不可以继续使用
        fileWriter.write("你好 赵粤");
        // close 之后流已经关闭 会出现异常 java.io.IOException: Stream closed
        //但是 前两个 数据写入成功

    }
}

案例2

package my.io.test;

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

public class DemoIO10 {
    public static void main(String[] args) throws IOException {
        String path = "D:"+ File.separator+"iotest\aaa\output\output03.txt";
        //append 参数 是否在文件中追加而不是覆盖
        FileWriter fileWriter = new FileWriter(path,true);
        //FileWriter fileWriter = new FileWriter(path);
        char[] chars = {'a','b','c','d','e'};
        //fileWriter.write(chars);  //按字符全部写入字符
        //fileWriter.write(chars,1,2); //按指定长度 写入字符
        fileWriter.write("刘亦菲"); //写入字符串
        fileWriter.flush();
        fileWriter.write("赵粤");
        fileWriter.close();
    }
}

案例3 使用

try{
    
}catch (){
    
}finally {
    
}  来处理异常

package my.io.test;

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

public class DemoIO11 {
    public static void main(String[] args)  {
        String path = "D:"+ File.separator+"iotest\aaa\output\output03.txt";
        FileWriter fileWriter = null;
        try{
            //append 参数 是否在文件中追加而不是覆盖
            fileWriter = new FileWriter(path,true);
            //FileWriter fileWriter = new FileWriter(path);
            char[] chars = {'a','b','c','d','e'};
            //fileWriter.write(chars);  //按字符全部写入字符
            //fileWriter.write(chars,1,2); //按指定长度 写入字符
            fileWriter.write("赵粤");
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            if(fileWriter != null){
                try {
                    fileWriter.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

2.5 Properties 集合类

可以从流中加载数据，也可以将数据保存到流中

store 方法把kv 保存到文档

使用字符流的方式可以写入中文，字节流的方式只能保存ASSIC码

package my.io.test;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;

public class DemoIO13 {
    //Properties 集合中的store  方法 可以把集合中的临时数据持久化到硬盘
    // void store(OutputStream out,String comments)  字节流不能有中文
    // void store(Writer writer,String comments)  字符流可以写中文
    public static void main(String[] args) throws IOException {
        Properties properties = new Properties();
        properties.setProperty("hh","老子今天不上班");
        properties.setProperty("ww","爽翻");
        properties.setProperty("bb","巴适的板");

        String path = "D:"+ File.separator+"iotest\aaa\output\output04.txt";
        //append 参数 是否在文件中追加而不是覆盖
        FileWriter fileWriter = new FileWriter(path,true);
        properties.store(fileWriter,"save data");
        fileWriter.close();
    }
}

package my.io.test;

import java.io.File;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;

public class DemoIO14 {
    //Properties 集合中的store  方法 可以把集合中的临时数据持久化到硬盘
    // void store(OutputStream out,String comments)  字节流不能有中文
    // void store(Writer writer,String comments)  字符流可以写中文
    public static void main(String[] args) throws IOException {
        Properties properties = new Properties();
        properties.setProperty("hh","老子今天不上班");
        properties.setProperty("ww","爽翻");
        properties.setProperty("bb","巴适的板");

        String outputPath = "D:"+ File.separator+"iotest\aaa\output\output05.txt";
        //append 参数 是否在文件中追加而不是覆盖
        FileOutputStream fileOutputStream = new FileOutputStream(outputPath);
        properties.store(fileOutputStream,"save data");
        fileOutputStream.close();
    }
}

Properties load（）方法可以将文件中的kv 读取到内存中

load（FileReader reader）可以读入中文

load（InputStream input）不能读取含有中文的kv

存储的文件中可以使用#号作为注释,被注释的kv 不能被读取

package my.io.test;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;
import java.util.Set;

public class DemoIO15 {
    public static void main(String[] args) throws IOException {
        Properties properties = new Properties();
        String outputPath = "D:"+ File.separator+"iotest\aaa\output\output05.txt";
        properties.load(new FileReader(outputPath));

        Set set = properties.stringPropertyNames();
        for (String key : set) {
            String value = properties.getProperty(key);
            System.out.println(key+"="+value);
        }
    }
}

2.6 缓冲流

都是由基本的流转化而来

字节缓存输入流案例

package my.io.test;


import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class DemoIO18 {
    //字节缓冲输如流
    public static void main(String[] args) throws IOException {
        String inputPath = "D:"+ File.separator+"iotest\aaa\output\output06.txt";
        FileInputStream fileInputStream = new FileInputStream(inputPath);
        BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
        //int len = bufferedInputStream.read();  //一次读一个
        //System.out.println((char)len);
//        int len = 0;
//        while ((len = bufferedInputStream.read())!=-1){
//            System.out.println((char)len);
//        }
        byte[] bytes = new byte[1024];
        int len = 0;
        while((len = bufferedInputStream.read(bytes))!=-1){
            System.out.println(new String(bytes,0,len));
        }
        bufferedInputStream.close();
    }
}

字节输出缓冲流

package my.io.test;

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

public class DemoIO17 {
    //字节缓冲输出流
    public static void main(String[] args) throws IOException {
        String outputPath = "D:"+ File.separator+"iotest\aaa\output\output06.txt";
        FileOutputStream fileOutputStream = new FileOutputStream(outputPath);
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
        bufferedOutputStream.write("eeeeeecfdsfn我是谁我在哪".getBytes());
        bufferedOutputStream.flush();
        bufferedOutputStream.close();

    }
}

字节缓冲输入输出流效率演示代码

package my.io.test;

import java.io.*;

public class DemoIO19 {
    //测试字节缓冲输入输出流的效率
    public static void main(String[] args) throws IOException {
        long start = System.currentTimeMillis();
        String inputPath = "D:"+ File.separator+"iotest\174.PNG";
        String outputPath = "D:"+ File.separator+"iotest\aaa\177.PNG";
        FileInputStream fileInputStream =  new FileInputStream(inputPath);
        FileOutputStream fileOutputStream = new FileOutputStream(outputPath);

        BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
//一次一个字节的读取
//        int len = 0;
//        while ((len = bufferedInputStream.read())!=-1){
//            bufferedOutputStream.write(len);
//        }
        int len = 0;
        byte[] bytes = new byte[1024];
        while ((len = bufferedInputStream.read(bytes))!=-1){
            bufferedOutputStream.write(bytes,0,len);
        }

        bufferedOutputStream.close();
        bufferedInputStream.close();
        long end = System.currentTimeMillis();
        System.out.println((end-start)+".ms");
    }
}

字符缓冲输入流

package my.io.test;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class DemoIO21 {
    //字符缓冲输入流
    public static void main(String[] args) throws IOException {
        String inputPath = "D:"+ File.separator+"iotest\aaa\output\output08.txt";
        BufferedReader bufferedReader = new BufferedReader(new FileReader(inputPath));
        int len = 0;
        char[] chars = new char[1024];
        while ((len = bufferedReader.read(chars))!=-1){
            System.out.println(new String(chars,0,len));
        }
        bufferedReader.close();
    }
}

案例2

package my.io.test;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class DemoIO21 {
    //字符缓冲输入流
    public static void main(String[] args) throws IOException {
        String inputPath = "D:"+ File.separator+"iotest\aaa\output\output08.txt";
        BufferedReader bufferedReader = new BufferedReader(new FileReader(inputPath));
//        int len = 0;
//        char[] chars = new char[1024];
//        while ((len = bufferedReader.read(chars))!=-1){
//            System.out.println(new String(chars,0,len));
//        }

//        String temp = bufferedReader.readLine();
//        System.out.println(temp);
        String line;
         while ((line = bufferedReader.readLine())!= null){  //判断是否读取到每一行的末尾
             System.out.println(line);
         }

        bufferedReader.close();
    }
}

字符缓冲输出流

void newline（）会根据不同的操作系统，获取到不同的行分隔符

package my.io.test;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

public class DemoIO20 {
    //字符缓冲输出流
    public static void main(String[] args) throws IOException {
        String outputPath = "D:"+ File.separator+"iotest\aaa\output\output08.txt";
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(outputPath));
        for (int i = 0; i <10 ; i++) {
            bufferedWriter.write("我是"+i);
            bufferedWriter.newline();
        }
        bufferedWriter.flush(); //将缓冲区数据刷新到磁盘
        bufferedWriter.close();  //关闭资源
    }
}

2.7 转换流

shushu

Java IO 流 学习

Java相关栏目本月热门文章

Java IO 流学习