Java学习day020-021(IO流-1)

最新推荐文章于 2022-12-07 14:08:57 发布

嘻嘻你好呀

最新推荐文章于 2022-12-07 14:08:57 发布

阅读量81

点赞数

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/weixin_46049759/article/details/119455715

版权

java 专栏收录该内容

63 篇文章 5 订阅

订阅专栏

1.file

1.File类的概述和构造方法

File：它是文件和目录路径名的抽象表示

文件和目录是可以通过File封装成对象的
对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已。它可以是存在的，也可以是不存在的。将来是要通过具体的操作把这个路径的内容转换为具体存在的。

方法名	说明
`File(String pathname)`	通过将给定的路径名字符串转换为抽象路径名来创建新的 `File`实例
`File(String parent, String child)`	从父路径名字符串和子路径名字符串创建新的 `File`实例1
`File(File parent, String child)`	从父抽象路径名和子路径名字符串创建新的 `File`实例

package com.study_01;
import java.io.File;

public class FileDemo01 {
    public static void main(String[] args) {
        // File（String pathname）：通过将给定的路径名字符串转换为抽象路径名来创建新的File实例。
        File f1 = new File("D:\\C-Java\\S-study\\biliHeiMa\\myFile\\src\\fileTest\\java.txt");
        System.out.println(f1);

        // File（String parent，String child）：从父路径名字符串和子路径名字符串创建新的File实例。
        File f2 = new File("D:\\C-Java\\S-study\\biliHeiMa\\myFile\\src\\fileTest","java.txt");
        System.out.println(f2);

        // File（File parent，String child）：从父抽象路径名和子路径名字符串创建新的File实例。
        File f3 = new File("D:\\C-Java\\S-study\\biliHeiMa\\myFile\\src\\fileTest");
        File f4 = new File(f3,"java.txt");
        System.out.println(f4);
    }
}
===输出===
D:\C-Java\S-study\biliHeiMa\myFile\src\fileTest\java.txt
D:\C-Java\S-study\biliHeiMa\myFile\src\fileTest\java.txt
D:\C-Java\S-study\biliHeiMa\myFile\src\fileTest\java.txt

2.File类创建功能

package com.study_01;

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

public class FIleDemo02 {
    public static void main(String[] args) throws IOException {
        // 创建文件 ---必修要有fileTest目录,因为creatFile只能创建文件
        File f1 = new File("D:\\C-Java\\S-study\\biliHeiMa\\myFile\\src\\fileTest\\java.txt");
        System.out.println(f1.createNewFile());
        System.out.println("-----");

        // 创建目录
        File f2 = new File("D:\\C-Java\\S-study\\biliHeiMa\\myFile\\src\\fileTest\\javaSE");
        System.out.println(f2.mkdir());
        System.out.println("-----");

        // 创建多级目录
        File f3 = new File("D:\\C-Java\\S-study\\biliHeiMa\\myFile\\src\\fileTest\\javaWeb\\Html");
//        System.out.println(f3.mkdir());
        System.out.println(f3.mkdirs());


        File f4 = new File("D:\\C-Java\\S-study\\biliHeiMa\\myFile\\src\\fileTest\\javaSE.txt");
//        System.out.println(f4.mkdir());
        System.out.println(f4.createNewFile());
    }
}
===输出===
true
-----
true
-----
true
true

package com.study_01;

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

public class FileDemo03 {
    public static void main(String[] args) throws IOException {
//        File f1 = new File("D:\\C-Java\\S-study\\biliHeiMa\\myFile\\src\\fileTest\\java.txt");
        // 需求一:在当前模块目录下创建java.txt文件
        File f1 = new File("java.txt");
        System.out.println(f1.createNewFile());

        // 需求2:删除当前模块目录下创建的java.txt文件
        System.out.println(f1.delete());
        System.out.println("---------");

        // 需求3:在当前模块下创建itcast目录
        File f2 = new File("itcast");
//        System.out.println(f2.mkdir());

        // 需求4:删除当前模块下创建itcast目录
        System.out.println(f2.delete());
        System.out.println("---------");

        // 需求5:在当前模块下创建itcast目录,在该目录下创建文件java.txt
        File f3 = new File("itcast");
        System.out.println(f3.mkdir());
        File f4 = new File("itcast\\java.txt");
        System.out.println(f4.createNewFile());

        // 需求6:删除当前模块下的目录itcast
        System.out.println(f4.delete());
        System.out.println(f3.delete());
    }
}

3.File类判断和获取功能

package com.study_01;

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

public class FileDemo04 {
    public static void main(String[] args) throws IOException {
        // 创建一个File对象
        File f = new File("src\\fileTest\\java.txt");

        System.out.println(f.isDirectory());
        System.out.println(f.isFile());
        System.out.println(f.exists());

        System.out.println(f.getAbsoluteFile());
        System.out.println(f.getPath());
        System.out.println(f.getName());
        System.out.println("--------");

        // 遍历D盘的文件及目录
        File f2 = new File("D:\\");
        String[] str = f2.list();
        for (String s : str) {
            System.out.println(s);
        }
        System.out.println("-------");

        // 遍历D盘的文件
        File[] fileArray = f2.listFiles();
        for (File file : fileArray) {
//            System.out.println(file);
//            System.out.println(file.getName());
            if(file.isFile()) {
                System.out.println(file.getName());
            }
        }
    }
}
===输出===
false
true
true
D:\C-Java\S-study\biliHeiMa\myFile\src\fileTest\java.txt
src\fileTest\java.txt
java.txt
--------
遍历内容
--------
遍历内容

4.File类删除功能

绝对路径和相对路径的区别

绝对路径：完整的路径名，不需要任何其他信息就可以定位它所表示的文件。例如：E:\Vitcast\java.txt
相对路径：必须使用取自其他路径名的信息进行解释。例如：myFile\java.txt

5.递归

6.递归阶乘

7.遍历目录

package com.study_01;

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

public class DiGUiDemo {
    public static void main(String[] args) {
        // 根据指定目录创建一个File对象
//        File f1 = new File("D:\\C-Java\\S-study\\biliHeiMa\\myFile\\src");
        File f1 = new File("D:\\C-Java\\S-study\\biliHeiMa");
        getAllFile(f1);
    }

    // 定义一个方法
    public static void getAllFile(File srcFile) {
        // 获取给定路径的目录文件对象数组
        File[] fileArray = srcFile.listFiles();
        /
        if (fileArray != null) {
            for (File file : fileArray) {
                // 如果是目录就进行递归
                if (file.isDirectory()) {
                    getAllFile(file);
                } else {
                    System.out.println(file);
                }
            }
        }
    }
}

2.字节流

8.IO流概述和分类

IO流概述：

IO ：输入/输出（Input/Output）
流：是一种抽象概念，是对数据传输的总称。也就是说数据在设备间的传输称为流，流的本质是数据传输

IO流分类：

按照数据的流向
- 输入流：读数据
- 输出流：写数据
按照数据类型来分
- 字节流
  - 字节输入流；字节输出流
- 字符流
  - 字符输入流；字符输出流

一般来说,我们说IO流是按照数据类型来分的

那么这两种流都在什么情况下使用呢？

如果数据通过Window自带的记事本软件打开，我们还可以读懂里面的内容，就使用字符流，否则使用字节流。如果你不知道该使用哪种类型的流，就使用字节流

9.字节流写数据

字节流抽象基类

InputStream：这个抽象类是表示字节输入流的所有类的超类
OutputStream：个抽象类是表示字节输出流的所有类的超类
子类名特点:子类名称都是以其父类名作为子类名的后缀

FileOutputStream：文件输出流用于将数据写入File

FileOutputStream（String name）：创建文件输出流以指定的名称写入文件

使用字节输出流写数据的步骤：

创建字节输出流对象（调用系统功能创建了文件，创建字节输出流对象，让字节输出流对象指向文件）
调用字节输出流对象的写数据方法
释放资源（关闭此文件输出流并释放与此流相关联的任何系统资源

package com.study_01;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamDemo01 {
    public static void main(String[] args) throws IOException {
        // 创建字节输出流对象
        // FileOutputStream(Strin gname):创建文件输出流以指定的名称写入文件
        FileOutputStream fos = new FileOutputStream("fos.txt");
        /*
            做了三件事
                A:调用了系统功能创建了文件
                B:创建了字节输出流对象
                C:让字节输出流对象指向创建好的文件
         */

        fos.write(97);// a
//        fos.write(57);// 9
//        fos.write(55);// 7

        // 最后都要释放资源
        // void close():关闭此文件输出流与释放与此流相关的任何系统资源
        fos.close();
    }
}

package com.study_01;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/*
    public FileOutputStream(String name,boolean append)
    创建文件输出流以指定的名称写入文件。 如果第二个参数为true ，则字节将写入文件的末尾而不是开头
    可以理解为续写
 */
public class FileOutputStreamDemo03 {
    public static void main(String[] args) throws IOException {
        // 床架字节输出对象
        FileOutputStream fos = new FileOutputStream("fos.txt",true);

        // 写数据
        for (int i = 0; i < 10; i++) {
            fos.write("hello".getBytes());
            fos.write("\n".getBytes());
        }

        // 释放资源
        fos.close();
    }
}

10.字节流写入的三种方式

package com.study_01;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class FileOutputStreamDemo02 {
    public static void main(String[] args) throws IOException {
        // FileOutputStream(String name):创建文件输出流以指定的名称写入文件
        FileOutputStream fos = new FileOutputStream("fos.txt");
        // new File(name)
//        FileOutputStream fos = new FileOutputStream(new File("fos.txt"));

        // FileOutputStream(File file):创建文件输出流以写入有指定的File对象表示的文件
//        File file = new File("fox.txt");
//        FileOutputStream fos2 = new FileOutputStream(file);
//        FileOutputStream fos2 = new FileOutputStream(new File("fos.txt"));

        // void write(int b)
//        fos.write(97);
//        fos.write(98);
//        fos.write(99);
//        fos.write(100);
//        fos.write(101);

        // void writ(byte[] b)
//        byte[] bys = {97,98,99,100,101};
        // bytep[] getBytes (): 返回字符串对应的自己数组1
        byte[] bys = "abcde".getBytes();
//        fos.write(bys);

        // void write(byte[] b, int off, int len) 从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。
        fos.write(bys,0,3);
        fos.close();
    }
}

11.字节流写数据两个小问题

字节流写数据如何实现换行呢？

写完数据后，加换行符
windows:\r\n
linux:\n
mac:\r

字节流写数据如何实现追加写入呢？

public FileOutputStream（String name，boolean append）
创建文件输出流以指定的名称写入文件。如果第二个参数为true，则字节将写入文件的末尾而不是开头

12.字节流写数据加异常处理

package com.study_01;

import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamDemo04 {
    public static void main(String[] args) {
//        try {
//            FileOutputStream fos = new FileOutputStream("fos.txt");
//            fos.write("hello".getBytes());
//            fos.close();
//        } catch (IOException e) {
//            e.printStackTrace();
//        }

        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream("fos.txt");
            System.out.println(fos);
            fos.write("hello".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

13.字节流读数据

需求：把文件fos.txt中的内容读取出来在控制台输出

FilelnputStream：从文件系统中的文件获取输入字节

FilelnputStream（String name）：通过打开与实际文件的连接来创建一个FilelnputStream，该文件由文件系统中的路径名name命名

使用字节输入流读数据的步骤：

①创建字节输入流对象

②调用字节输入流对象的读数据方法

③释放资源。

package com.study_02;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class FileIntputStreamDemo01 {
    public static void main(String[] args) throws IOException {
        // 创建字节输入流对象
//        FileInputStream(String name)
        FileInputStream fis = new FileInputStream("fos.txt");

        // 调用字节输入流对象的读数据方法
        // int read() 从该输入流读取一个字节的数据

        /*
        // 第一次读取数据
        int by = fis.read();
        System.out.println(by);
        System.out.println((char) by);

        // 第二次
        by = fis.read();
        System.out.println(by);
        System.out.println((char) by);

        // 再多读取两次
        by = fis.read();
        System.out.println(by);
        by = fis.read();
        System.out.println(by);
*/
//        int by = fis.read();
//        while (by != -1) {
//            System.out.print((char) by);
//            by = fis.read();
//        }

        // 优化上面程序
        int by;
        while ((by=fis.read())!=-1){
            System.out.print((char) by);
        }

        // 释放资源
        fis.close();
    }
}

14.复制文本文件

// 根据数据源创建字节输入流对象
FileInputStream fis = new FileInputStream("散文.txt");
// 根据目的地创建字节输出流对象
FileOutputStream fos = new FileOutputStream("散文2.txt");

int by;
while ((by=fis.read())!=-1) {
    fos.write(by);
}

fos.close();
fis.close();

15.字节流读数据(一次读一个字节数组数据)

package com.study_02;

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

public class FileIntputStreamDemo02 {
    public static void main(String[] args) throws IOException {
        // 创建字节输入流对象
        FileInputStream fis = new FileInputStream("fos.txt");

        // 调用字节输入流对象的读数据方法
        /*
        byte[] bys = new byte[5];

        // 第一次读取数据
        int len = fis.read(bys);
        System.out.println(len);
        System.out.println(new String(bys));

        // 第二次读取数据
        len = fis.read(bys);
        System.out.println(len);
        System.out.println(new String(bys));

        // 第三次读取数据
        len = fis.read(bys);
        System.out.println(len);
//        System.out.println(new String(bys));
        System.out.println(new String(bys,0,len));
        */

        /*
            hello\n
            world\n

            第一次:hello
            第二次:\r\nwor
            第三次:ld\r\nr
        */


        byte[] bys = new byte[1024]; // 1024及整数倍数

        int len;
        while ((len = fis.read(bys))!=-1){
            System.out.print(new String(bys,0,len));
        }

        fis.close();

    }
}

16.字节流复制图片

package com.study_02;

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

public class FileIntputStreamDemo03 {
    public static void main(String[] args) throws IOException {

        FileInputStream fis = new FileInputStream("t.jpg");
        FileOutputStream fos = new FileOutputStream("ttt.jpg");

        byte[] bys = new byte[1024];
        int len;
        while ((len=fis.read(bys))!=-1){
            fos.write(bys,0,len);
        }

        fos.close();
        fis.close();
    }
}

1.字节缓冲流

为了提高效率,举个例子,一开始骑自行车送快递,一次只能送一个,后面配了一辆五菱宏光,一次可以送十几件

BufferOutputStream：该类实现缓冲输出流。通过设置这样的输出流，应用程序可以向底层输出流写入字节，而不必为写入的每个字节导致底层系统的调用
BufferedlnputStream：创建BufferedlnputStream将创建一个内部冲区数组。当从流中读取或跳过字节时，内部缓冲区将根据需要从所包含的输入流中重新填充，一次很多字节

构造方法：

字节缓冲输出流：BufferedOutputStream（OutputStream out）
字节缓冲输入流：BufferedlnputStream（InputStream in）

为什么构造方法需要的是字节流，而不是具体的文件或者路径呢？

字节缓冲流仅仅提供缓冲区，而真正的读写数据还得依靠基本的字节流对象进行操作

package com.study_03;

import java.io.*;

public class BufferStreamDemo {
    public static void main(String[] args) throws IOException {
        /*
        // 字节缓冲输出流:BufferedOutputStream(OutputStream out)
//        FileOutputStream fos = new FileOutputStream("bos.txt");
//        BufferedOutputStream bos = new BufferedOutputStream(fos);
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bos.txt"));
        // 写数据
        bos.write("hello\r\n".getBytes());
        bos.write("hello\r\n".getBytes());
        // 释放资源
        bos.close();
        */

        // 字节缓冲输入流:BufferedInputStream(InputStream in)
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bos.txt"));

        // 一次读取一个字节数据
//        int by;
//        while ((by = bis.read())!=-1) {
//            System.out.print((char) by);
//        }

        // 一次读取一个字节数组的数据
        byte[] bys = new byte[1024];
        int len;
        while ((len = bis.read(bys))!=-1) {
            System.out.print(new String(bys,0,len));
        }
        bis.close();
    }
}

2.字节流复制视频

package com.study_03;

import java.io.*;

/*
    四种方式实现复制视频，并记录每种方式复制视频的时间
    1：基本字节流一次读写一个字节
    2：基本字节流一次读写一个字节数组
    3：字节缓冲流一次读写一个字节
    4：字节缓冲流一次读写一个字节数组
 */
public class CopyAviDemo {
    public static void main(String[] args) throws IOException {
        // 记录开始时间
        long startTime = System.currentTimeMillis();

        // 复制视频
//        method1(); // 共耗时:46207毫秒
//        method2(); // 共耗时:142毫秒
//        method3(); // 共耗时:155毫秒
        method4(); // 共耗时:36毫秒


        // 记录结束时间
        long endTime = System.currentTimeMillis();
        System.out.println("共耗时:" + (endTime - startTime) + "毫秒");
    }

    // 1：基本字节流一次读写一个字节
    private static void method1() throws IOException {
        FileInputStream fis = new FileInputStream("Airport.mp4");
        FileOutputStream fos = new FileOutputStream("视屏复制.mp4");

        int by;
        while ((by = fis.read()) != -1) {
            fos.write(by);
        }

        fos.close();
        fis.close();
    }

    // 2：基本字节流一次读写一个字节数组
    private static void method2() throws IOException {
        FileInputStream fis = new FileInputStream("Airport.mp4");
        FileOutputStream fos = new FileOutputStream("视屏复制.mp4");

        byte[] bys = new byte[1024];
        int len;
        while ((len = fis.read(bys)) != -1) {
            fos.write(bys, 0, len);
        }

        fos.close();
        fis.close();
    }

    // 3：字节缓冲流一次读写一个字节
    private static void method3() throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("Airport.mp4"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("视屏复制.mp4"));

        int by;
        while ((by= bis.read())!=-1){
            bos.write(by);
        }
        bos.close();
        bis.close();
    }

    // 4：字节缓冲流一次读写一个字节数组
    private static void method4() throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("Airport.mp4"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("视屏复制.mp4"));

        byte[] bys = new byte[1024];
        int len;
        while ((len=bis.read(bys))!=-1) {
            bos.write(bys,0,len);
        }
        bos.close();
        bis.close();
    }
}