java核心编程——IO流

目录

一、File

1.创建File对象

2、File构造方法

3.常用方法

二、IO流概述

三、字节流

1.FIS和FOS

2.BIS和BOS

---

一、File

• java.io.File表示文件(目录)，操作本地的文件和目录。
• File对象只能操作文件的基本信息(名称、大小等)。不能对文件内容进行访问。

1.创建File对象

     1.1 相对路劲和绝对路劲

                相对路劲：相对于当前书写目录的位置

../demo/a.txt//上级目录的a.txt

                绝对路径：指文件在硬盘上真正存在的路径

D:\IdeaProjects\javase

2、File构造方法

•  File:文件路径或文件对象，不描述文件本身！
•  文件和目录路径名的抽象表示

import java.io.File;

public class TestFile {

    public static void main(String[] args) {

        //1.构造方法

        //-- File(String  pathname)
        File file = new File("D:\\program\\A_hqyj\\ideaprojects\\javase-220302\\java-coreprogramming\\src\\com\\hqyj\\qpi\\io\\TestFile.java");
        System.out.println(file);      //  抽象表示
        System.out.println(file.exists());

        //-- File(String parent,String child)
        String parent = "D:\\program\\A_hqyj\\ideaprojects\\javase-220302\\java-coreprogramming\\src\\com\\hqyj\\qpi\\io";
        File file2 = new File(parent, "TestFile.java");
        System.out.println(file2.exists());


        //- File(File parent,String child)
        File parentPath = new File(parent);
        File file3 = new File(parentPath, "TestFile.java");
        System.out.println(file3.exists());

        /*
        2.问题来了路径如果传入绝对路径很复杂
           --绝对路径：从盘符开始的路径
           --相对路径：从Module（子工程）开始的   ！！！类路径
             -".":系统默认路径
         */
        File file4 = new File("java-coreprogramming\\src\\com\\hqyj\\qpi\\io\\TestFile.java");
        System.out.println(file4.exists());   //相对路径

        //测试相对路径
        File file5 = new File("textFile.txt");
        System.out.println(file5.exists());

        //系统的默认路径
        File file6 = new File(".");
        System.out.println(file6.exists());
        System.out.println(file6.getAbsolutePath());

        /*
            路径分隔符
            -- 正斜杠 /（建议使用）
            -- 反斜杠 \\（win独有）
         */

        File file7 = new File("java-coreprogramming/src/com/hqyj/qpi/io/TestFile.java");
        System.out.println(file7.exists());
        


    }

}

3.常用方法

import java.io.File;
import java.util.Arrays;
import java.util.Date;

/**
 *
 * 常用方法
 */
public class TestFile2 {

    public static void main(String[] args) throws  Exception {
        //0.准备工作，在io包下创建文件和目录

        
        File file = new File("java-coreprogramming/src/com/hqyj/qpi/io/testfile");
        file.mkdir();
        System.out.println(file.exists());

        //创建一个文件名
        File file2 = new File("java-coreprogramming/src/com/hqyj/qpi/io/testfile/demo.properties");
        file2.createNewFile();

        //测试此文件是否可读
        System.out.println(file2.canRead());

        //4.测试是不是一个文件或者目录
        System.out.println(file2.isFile());
        System.out.println(file2.isDirectory());

        //5.返回路径或者文件最后一次被修改的时间
        System.out.println(new Date(file2.lastModified()));

        //6.获取此抽象文件或者目录的名称
        System.out.println(file2.getName());

        //7.判断当前文件是否可写
        System.out.println(file2.canWrite());

        //8.获取文件的长度
        System.out.println(file2.length());

        //9.创建多级目录
        File file3 = new File(file, "a");
        System.out.println(file3.mkdirs());

        //10.删除一个路径
        file3.delete();

        //问题：File对象操作的是文件内容还是文件的基本信息呢？ 操作的是文件的基本信息
           //File 就是该文件路径表示的对象，而不是操作内容本身。

        //11.打印当前目录下的所有内容
        File file4 = new File(".");
        File[] files = file4.listFiles();
        System.out.println(Arrays.toString(files));

        String[] list = file4.list();
        System.out.println(Arrays.toString(list));



    }
}

二、IO流概述

• IO:指输入输出

       Input：输入，从外界到程序，读取数据

       Output：输出，从程序到外界，写出数据

• 流的分类:

        **字节流和字符流

                字节流: 传输数据的最小单位是字节         

                字符流: 传输数据的最小单位是字符

        **节点流(低级流)和处理流(高级流或过滤流)

                节点流: 可以向一个特定的地方读写数据

                处理流: 封装了节点流，通过封装的流的功能调用实现数据读写。

         **流的链接: 一个流对象经过其他流的多次包装，成为流的链接。

三、字节流

• 字节流有两个抽象类: InputStream和OutputStream
• IS(InputStream)的常用方法
• OS(OutputStream)的常用方法

1.FIS和FOS

         1.1字节流FIS和FOS

•                FIS: FileInputStream，文件输入流

FileInputStream(File file)

        通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中 的 File 对象 file 指定。

FileInputStream(String name)

        通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中 的路径名 name 指定。

•                FOS：FileOutputStream, 文件输出流

FileOutputStream(File file)

        创建一个向指定 File 对象表示的文件中写入数据的文件输出流。

FileOutputStream(File file, boolean append)

        创建一个向指定 File 对象表示的文件中写入数据的文件输出流。

FileOutputStream(String name)

        创建一个向具有指定名称的文件中写入数据的输出文件流。

FileOutputStream(String name, boolean append)

        创建一个向具有指定 name 的文件中写入数据的输出文件流。

        1.2 FileInputStream的读出与写入

/**
 * fileInputStream FileOutputSream
 *
 *
 * 字节流：凡是以Stream结尾的都是字节流
 */
public class TestFISAndFOS2 {

    public static void main(String[] args) throws  Exception{

        //读入
        InputStream inputStream = null;
        OutputStream outputStream = null;

        File file = new File("java-coreprogramming/src/com/hqyj/qpi/io/testfile/fis1.txt");
        try {
            inputStream= new FileInputStream(file);

            for (int j= 1; ; j++) {
                 int io = inputStream.read();
                if (io == -1) {
                    break;
                }
                System.out.print((char ) io);
            }
        }catch (Exception e){
            e.printStackTrace();
        } finally {
            inputStream.close();
        }
        System.out.println();


        //写出
        byte[] bytes = new byte[]{'o','u','t'};
        try {
            outputStream = new FileOutputStream(file,true);
            outputStream.write(bytes);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            outputStream.close();
        }

    }
}

    1.3 文件内容的复制

      此刻需要用到单元测试，以下为单元测试内容

      1.测试读写

                --单元(每一个方法都是一个单元)测试：

                         --@Before :同一个java中，执行@Test前必须执行的内容

                         --@After :同一个java中，执行完@Test后必须执行的内容

                         --@Test :同一个java中，必须执行@Test的内容 

      2.单元测试路径

                 绝对路径：从盘符开始

                 相对路径：单元测试编译位置和main函数不同

                         --main从module开始

                         --单元测试从Classpath开始（类路径）

                         -- 可以标记一个普通的文件目录为classpath Make Directory As 

测试：

import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.io.*;

/*
        测试读写
          --单元(每一个方法都是一个单元)测试：
             --@Before :同一个java中，执行@Test前必须执行的内容
             --@After :同一个java中，执行完@Test后必须执行的内容
             --@Test :同一个java中，必须执行@Test的内容
         */
public class TestFISAndFOS3  {

    //练习通过上面的案例尝试读取文件中所有的字节，并尝试创建OutputStream,向文件中写入内容

    File file;
    FileInputStream fis;
    FileOutputStream fos;

    //准备资源
    @Before
    public void testBefore(){
        /*
        单元测试：
            绝对路径：从盘符开始
            相对路径：单元测试编译位置和main函数不同
                    --main从module开始
                    --单元测试从Classpath开始（类路径）
                      可以标记一个普通的文件目录为classpath
                      Make Directory As
         */
        String path  = "resource\\fis1.txt";
        file = new File(path);
    }

    //写
    @Test
    public void testWirte() throws  Exception{
        /*
        构造方法中：boolean append参数如果为true表示追加
         */
        fos = new FileOutputStream(file,true);
        fos.write(65);


    }

    //读
    @Test
    public  void  testRead() throws  Exception{

        fis = new FileInputStream(file);
        int i = -1;
        while ((i = fis.read()) != -1) {
            System.out.println((char)i);
        }

    }

    //byte[]写
    @Test
    public void  testWriteByts() throws  Exception{
        fos = new FileOutputStream(file,true);
        byte[] bytes1 = new byte[]{65,66,67,68,69};
        fos.write(bytes1);
    }

    //byte[]读
    @Test
    public void  testReadByts() throws  Exception{
        fis = new FileInputStream(file);
        byte[] bytes2 = new byte[100];
        int i = fis.read(bytes2);
        System.out.println(new String(bytes2));
    }

    //测试使用fis和fos实现文件的复制 将fis1.txt的内容复制到fis1_copy.txt,采用byte实现
    //byte复制
    @Test
    public void  testcopy() throws  Exception {
        //定义文件路径
        fis = new FileInputStream(file);
                            //如果没有文件，会自动生成文件
        fos = new FileOutputStream("resource\\fis1_copy.txt");
        //定义数组
        byte[] bytes = new byte[1024];
        //读
        fis.read(bytes);

        //写
        fos.write(bytes);

             /*
        int i = -1;
        while(i = fis.read(bytes) != -1) {
            fos.write(bytes);
        }
         */
    }

    //关闭资源
    @After
    public void testAfter() throws  Exception{
        if (fos != null){
            fos.close();
        }
        if (fis != null) {
            fis.close();
        }
    }

}

2.BIS和BOS

• 缓冲区的优势：减少了读写次数
• flush() : 清空缓冲区，将缓冲区中的数据全部写出
• BIS：BufferedInputStream 缓冲输入流

BufferedInputStream(InputStream in)

                创建 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。 BufferedInputStream(InputStream in, int size)

                创建具有指定缓冲区大小的 BufferedInputStream，并保存其参数，即输入流 in，以 便将来使用。

• BOS：BufferedOutputStream 缓冲输出流

BufferedOutputStream(OutputStream out)

                创建一个新的缓冲输出流，以将数据写入指定的基础输出流。 BufferedOutputStream(OutputStream out, int size)

                创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的基础输出流。

2.1 缓冲输入输出流

public class TestBISAndBOS {

    File file;
    FileInputStream fis;
    FileOutputStream fos;
    BufferedInputStream bis;
    BufferedOutputStream bos;

    @Before
    public  void  createFile() throws Exception {
        String s = "resource\\bis1.txt";
        file = new File(s);

    }

    //写出
    @Test
    public  void write() throws  Exception {
        //先去创建低级流
        fos = new FileOutputStream(file);
        bos = new BufferedOutputStream(fos,10); //以低级流fos作为载体
        //写出内容
        bos.write("I am a boy".getBytes());
        bos.flush();//立即写出
    }

    //读入
    @Test
    public  void read() throws  Exception {
        fis = new FileInputStream(file);
        bis = new BufferedInputStream(fis);
        byte[] bytes = new byte[1024];
        //读入
        bis.read(bytes);
        System.out.println(new String(bytes));
    }
   

    @After
    public  void  close() throws  Exception {
        //先关闭高级流，在关闭低级流
        if (bos != null)
            bos.close();
        if (bis != null)
            bis.close();
        if (fos != null)
            fos.close();
        if (fis != null)
            fis.close();
    }

}

2.2复制文件的内容

public class TestBISAndBOS {

    File file;
    FileInputStream fis;
    FileOutputStream fos;
    BufferedInputStream bis;
    BufferedOutputStream bos;

    @Before
    public  void  createFile() throws Exception {
        String s = "resource\\bis1.txt";
        file = new File(s);

    }

    //写出
    @Test
    public  void write() throws  Exception {
        //先去创建低级流
        fos = new FileOutputStream(file);
        bos = new BufferedOutputStream(fos,10); //以低级流fos作为载体
        //写出内容
        bos.write("I am a boy".getBytes());
        bos.flush();//立即写出
    }

    //读入
    @Test
    public  void read() throws  Exception {
        fis = new FileInputStream(file);
        bis = new BufferedInputStream(fis);
        byte[] bytes = new byte[1024];
        //读入
        bis.read(bytes);
        System.out.println(new String(bytes));
    }
    //复制文件内容
    //练习：使用bis和bos实现文件的复制，bis_copy.txt，参考fis和fos的方法
    @Test
    public void testcopy() throws Exception {
        fis = new FileInputStream(file);
        bis = new BufferedInputStream(fis);
        fos = new FileOutputStream("resource\\bis_copy.txt");
        bos = new BufferedOutputStream(fos);
        byte[] b = new byte[1024];
        int i = -1;
        while (( i = bis.read(b)) != -1) {
            bos.write(b);
        }
    }

    @After
    public  void  close() throws  Exception {
        //先关闭高级流，在关闭低级流
        if (bos != null)
            bos.close();
        if (bis != null)
            bis.close();
        if (fos != null)
            fos.close();
        if (fis != null)
            fis.close();
    }

}