输入输出流

Posted 2020-12-13 haifeima

一、File（文件）类

Java的标准库java.io提供了File对象来操作文件和目录。

介绍一些常用的方法，其他方法可以自行查阅API文档

        File a=new File("f:\\imooc\\io\\score.txt");//构造File对象
        a.isDirectory();//判断是否是目录
        a.isFile();//判断是否是文件
        a.exists();//判读文件或目录是否存在
        a.mkdirs();//创建目录
        a.createNewFile();//创建文件方法
        a.isAbsolute();//是否是绝对路径
        a.getPath();//获取相对路径
        a.getAbsolutePath();//获取绝对路径
        a.getName();//获取文件名

 

代码实例：

/**
 * File的常见应用
 */

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

public class FileDemo1 {

    public static void main(String[] args) {
//        要构造一个File对象，需要传入文件路径
//        注意使用作为路径分隔符，在Java字符串中需要用\\表示一个。Linux平台使用/作为路径分隔符：
        File file1=new File("f:\\imooc\\io\\score.txt");//方法1：绝对路径或相对路径，可以用.表示当前目录，..表示上级目录。
//        File file1=new File("f:\\imooc","io\\score.txt");//方法2：路径分开写
//        File file=new File("f:\\imooc");//方法3:先生成File对象，指向目录结构
//        File file1=new File(file,"io\\score.txt");

        //判断是文件还是目录
        System.out.println("是否是目录"+file1.isDirectory());
        System.out.println("是否是文件"+file1.isFile());

        //File对象既可以表示文件，也可以表示目录，创建目录
        File file2=new File("f:\\imooc\\set\\HashSet");
        if(!file2.exists()) {
            file2.mkdirs();//创建目录
        }

        //创建文件
        if(!file1.exists()) {
            try {
                file1.createNewFile();//创建文件
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    }

}

File常见方法实例

 

注意：

1. File对象既可以表示文件，也可以表示目录
2. 相对路径，可以用.表示当前目录，..表示上级目录。
3. 使用作为路径分隔符，在Java字符串中需要用\\表示一个。Linux平台使用/作为路径分隔符。

二、字节流

1、文件输入/输出流

FileInputStream(文件输入流)

FileOutputStream(文件输出流)

 代码实例：

public class FileInputDemo1 {

    public static void main(String[] args) {
        //创建一个FileInputStream对象，并捕获异常
        try {
            FileInputStream fis=new FileInputStream("E:\\javaPro\\abc");
//            int n=fis.read();//读取文件
            int n=0;//或者而是用循环读取文件
//            while(n!=-1){
//                System.out.print((char)n);
//                n=fis.read();
//            }
            while((n=fis.read())!=-1){//-1是读取到了末尾，循环结束
                System.out.print((char)n);
            }
            
            fis.close();//关闭输入流
        }catch (FileNotFoundException e) {//找不到文件异常
            e.printStackTrace();
        } catch(IOException e){
            e.printStackTrace();
        }
    }

}

FileInputDemo1

public class FileInputDemo2 {

    public static void main(String[] args) {
        // 创建一个FileInputStream对象
        try {
            FileInputStream fis = new FileInputStream("E:\\javaPro\\abc");
            byte[] b=new byte[100];//生成字节数组
            fis.read(b,0,5);//0代表从什么位置读
            System.out.println(new String(b));//转化成字符串并输出
            fis.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

FileInputDemo2

 

 

public class FileOutputDemo {

    public static void main(String[] args) {
        FileOutputStream fos;
        FileInputStream fis;
        try {
            fos = new FileOutputStream("E:\\javaPro\\abc",true);//true代表追加写，false或不写则是是覆盖写
//            fis=new FileInputStream("E:\\javaPro\\imooc");//读取看一下
            fos.write(50);
            fos.write(‘a‘);
//            System.out.println(fis.read());
//            System.out.println((char)fis.read());
            fos.close();
//            fis.close();

        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

FileOutputDemo1

 

public class FileOutputDemo2 {

    public static void main(String[] args) {
        // 文件拷贝
        try {
            FileInputStream fis=new FileInputStream("happy.gif");
            FileOutputStream fos=new FileOutputStream("happycopy.gif");
            int n=0;
            byte[] b=new byte[1024];
            while((n=fis.read(b))!=-1){
                fos.write(b,0,n);//n为实际读取的字节数，可以保证两个文件大小是一致的
            }
            fis.close();
            fos.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }catch(IOException e){
            e.printStackTrace();
        }
        

    }

}

FileOutputDemo2

 

 

2、缓冲输入/输出流

BufferedOutputStream(缓冲输出流)

BufferedInputStream(缓冲输入流)

 

1）缓冲输入流BufferedInputStream不能直接读取文件系统中的数据，需要和文件输入流FileInputStream进行结合。

2）缓冲流读文件过程如下:

FileInputStream把文件读取出来，不是直接读取到程序当中进行接收，而是通过一个缓冲的流，下一个通道继续读取，再通过缓冲流，流入到字节数组当中，而被我们的程序读取到。

3）flush()方法

主要用来清空缓冲区。

当缓冲区被填满时就会自动执行写操作，但是当缓冲区不满时，就不会执行写操作。

所以，当缓冲区未被填满但要执行写操作时就要强制清空缓冲区。

 

代码实例：

public class BufferedDemo {

    public static void main(String[] args) {
        try {
            FileOutputStream fos=new FileOutputStream("imooc.txt");//文件输出流，写操作
            BufferedOutputStream bos=new BufferedOutputStream(fos);//缓冲输出流
            FileInputStream fis=new FileInputStream("imooc.txt");//文件输入流
            BufferedInputStream bis=new BufferedInputStream(fis);//缓冲输入流
//            long startTime=System.currentTimeMillis();//读取数据之前，建议输出个当前时间，存到变量中
            bos.write(50);
            bos.write(‘a‘);
            bos.flush();
            System.out.println(bis.read());
            System.out.println((char)bis.read());
//            long endTime=System.currentTimeMillis();
//            System.out.println(endTime-startTime);//时间差
            fos.close();
            bos.close();
            fis.close();
            bis.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

BufferedDemo

 

三、字符流

Reader（字符输入流）

字符输入输出流的应用场景：字符使用的场景，如消息的发送（写），收取消息（读）

Writer（字符输出流）(父类)

字符输入输出流的应用场景：字符使用的场景，如消息的发送（写），收取消息（读）

 

四、字符字节转换流

1、InputStreamReader，从字节输入流中读取数据，然后转换成字符

2、OutputStreamWriter，将字符数据转换成字节，然后写到字节输出流中

//字节字符转换流
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class ReaderDemo {

    public static void main(String[] args) {
        try {
            FileInputStream fis=new FileInputStream("imooc.txt");
            InputStreamReader isr=new InputStreamReader(fis,"GBK");
            BufferedReader br=new BufferedReader(isr);
            FileOutputStream fos=new FileOutputStream("imooc1.txt");
            OutputStreamWriter osw=new OutputStreamWriter(fos,"GBK");
            BufferedWriter bw=new BufferedWriter(osw);
            int n=0;
            char[] cbuf=new char[10];
//            while((n=isr.read())!=-1){
//                   System.out.print((char)n);
//            }
//            while((n=isr.read(cbuf))!=-1){
//                String s=new String(cbuf,0,n);
//                System.out.print(s);
//            }
            while((n=br.read(cbuf))!=-1){
                //String s=new String(cbuf,0,n);
                bw.write(cbuf, 0, n);
                bw.flush();
            }
            fis.close();
            fos.close();
            isr.close();
            osw.close();
            br.close();
            bw.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        

    }

}

Demo