Java IO流

STATICHIT静砸

已于 2022-04-14 21:50:08 修改

阅读量720

点赞数

分类专栏： Java学习文章标签： Java

于 2022-04-11 21:28:35 首次发布

本文链接：https://blog.csdn.net/m0_62742402/article/details/124045214

版权

Java学习专栏收录该内容

16 篇文章 0 订阅

订阅专栏

File

文件类概述和构造方法

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

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

File类创建功能

public boolean createNewFile（）：

如果文件不存在，就创建文件，并返回true

如果文件存在，就不创建文件，并返回false

public boolean mkdir（）：

如果目录不存在，就创建目录，并返回true

如果目录存在，就不创建目录，并返回false

（creatNewFile和mkdir的区别是一个是创建文件，一个是创建目录）

public boolean mkdirs（）：

如果目录不存在，就创建目录，并返回true

如果目录存在，就不创建目录，并返回false

（mkdir和mkdirs的区别是一个是创建单个目录，一个可以创建多级目录）

创建的是文件还是目录，不是通过文件路径名字来看的。

比如如果我们这样子

得到的不是txt文件而是名为“javase.txt”的目录

所以我们要看方法来判断创建的是文件还是目录

再次总结：creatNewFile（）是创建文件，mkdir（）和mkdirs（）是创建目录。

File类删除功能

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

●绝对路径:完整的路径名，不需要任何其他信息就可以定位它所表示的文件。例如: E:\itcast\Vjava.txt

●相对路径:必须使用取自其他路径名的信息进行解释。例如: myFile\Vjava.txt
的

删除目录时的注意事项:
●如果一个目录中有内容(目录, 文件)，不能直接删除。应该先删除目录中的内容,最后才能删除目录

File类判断和获取功能

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

public class FileDemo4 {
    public static void main(String[] args) throws IOException {
        //创建一个File对象
        File f = new File("File\\java.txt");
        //f.createNewFile();
//        public boolean isDirectory(): 测试此抽象路径名表示的File是否为目录
//        public boolean isFile(): 测试此抽象路径名表示的File是否为文件
//        public boolean exists(): 测试此抽象路径名表示的File是否存在
        System.out.println(f.isDirectory());
        System.out.println(f.isFile());
        System.out.println(f.exists());
        System.out.println("--------");

//        public String getAbSplutePath(): 返回此抽象路径名的绝对路径名字符串
//        public String getPath(): 将此抽象路径名转换为路径名字符串
//        public String getName():返回由此抽象路径名表示的文件或目录的名称
        System.out.println(f.getAbsolutePath());
        System.out.println(f.getPath());
        System.out.println(f.getName());
        System.out.println("--------");

//        public String[] list(): 返回此抽象路径名表示的目录中的文件和目录的名称字符串数组
//        public File[] listFiles(): 返回此抽象路径名表示的目录中的文件和目录的File对象数组
        File f2 = new File("E:\\itcast");
        String[] strArray = f2.list();
        for(String str : strArray)
        {
            System.out.println(str);
        }
        System.out.println("--------");

        File[] fileArray = f2.listFiles();
        for(File file : fileArray)
        {
            System.out.println(file);
        }
        System.out.println("--------");

        //得到绝对路径的意义是可以调用File方法进行操作
        for(File file : fileArray)
        {
            if(file.isFile())
            System.out.println(file);
        }

    }
}

得到结果

false
true
true
--------
E:\untitled2\File\java.txt
File\java.txt
java.txt
--------
java.txt
JavaSE
javase.txt
JavaWEB
--------
E:\itcast\java.txt
E:\itcast\JavaSE
E:\itcast\javase.txt
E:\itcast\JavaWEB
--------
E:\itcast\java.txt

字节流

IO流概述和分类

I0流分类:

按照数据的流向
        输入流:读数据
        输出流:写数据

按照数据类型来分
        字节流
                字节输入流，字节输出流
        字符流
                字符输入流，字符输出流
一般来说，我们说IO流的分类是按照数据类型来分的

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

字节流写数据

字节流写数据的三种方式

一个利用getBytes实现的输入字符串的简便方法：

文件输出流对象.write("我是要输入的字符串".getBytes());

1:字节流写数据如何实现换行呢?

写完数据后加换行符号（不同系统换行符不同）

                window: \r\n

                Linux: \n

                mac: \r

2:字节流写数据如何实现追加写入呢?

        public FileOutputStream (String. name, boolean append)
在创建文件输出流时用该方法指定追加写入
        如果第二个参数为true，则字节将写入文件的末尾而不是开头

字节流写数据加异常处理

finally :在异常处理时提供finally块来执行所有清除操作。比如说IO流中的释放资源

特点:被finally控制的语句一定会执行,除非JVM退出

格式：

如果文件路径不存在为null，则无需close。

字节流读数据（一次读一个字节数据）

用循环输出文件数据直至末尾读完文件

首次用read函数读数据返回的是字符所对应的ascall码，所以是int类型，我们如果想原样输出，就在输出时加一个char强转。

另外，注意输出System.out.print()不要加ln哦，要换行的地方循环会识别到，无需手动换行。

当文件都到末尾时，读到空返回的是null。

所以代码是这样子的

int by;
while(by=file.read()！=-1){
    System.out.print((char)by);
}

字节流复制图片

思路:
①根据数据源创建字节输入流对象
②根据目的地创建字节输出流对象
③读写数据,复制图片(一次读取一个字节数组，一次写入一个字节数组)
④释放资源

字节缓冲流

●BufferOutputStream: 该类实现缓冲输出流。通过设置这样的输出流，应用程序可以向底层输出流写入字节，而不必为写入的每个字节导致底层系统的调用

●BufferedInputStream: 创建BufferedInputStream将创建一个内部缓冲区数组。当从流中读取或跳过字节时，内部缓冲区将根据需要从所包含的输入流中重新填充，一次很多字节

构造方法:（注意：参数类型为字节流哦）

●字节缓冲输出流: BufferedOutputStream(OutputStream out)
●字节缓冲输入流: BufferedInputStream(InputStreamin)

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

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

ps：不要因为字节缓冲流中有个缓字就以为它比普通字节流慢！！因为字节缓冲流可以一次内部缓冲很多内容，所以它是更快的！！faster！！在后面的传输视频处就可以体现字节缓存流的优越性

通过实操体现字节缓存流的优越性

测试得到的结果

四种方式实现复制视频，并记录每种方式复制视频的时间
1:基本字节流一次读写-一个字节共耗时：285557毫秒
2:基本字节流一次读写一个字节数组共耗时：413毫秒
3:字节缓冲流一次读写一个字节共耗时：2693毫秒
4:字节缓冲流一次读写一个字节数组共耗时：124毫秒

import java.io.*;

/*
    //待复制视频地址：C:\Users\静砸今天开心了嘛\Desktop\CodeShortFilm.mp4
    思路：
        1.根据数据源创建字节输入流对象
        2.根据目的地创建字节输出流对象
        3.读写数据，复制视频
        4.释放资源

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

        //复制视频
//        method1();
//        method2();
//        method3();
        method4();

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

    //基本字节流一次读写-一个字节
    public static void method1() throws IOException {
        //C:\Users\静砸今天开心了嘛\Desktop\CodeShortFilm.mp4
        FileInputStream fis = new FileInputStream("C:\\Users\\静砸今天开心了嘛\\Desktop\\CodeShortFilm.mp4");
        FileOutputStream fos = new FileOutputStream("E:\\untitled2\\视频.mp4");

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

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

    //基本字节流一次读写一个字节数组
    public static void method2() throws IOException {
        //C:\Users\静砸今天开心了嘛\Desktop\CodeShortFilm.mp4
        FileInputStream fis = new FileInputStream("C:\\Users\\静砸今天开心了嘛\\Desktop\\CodeShortFilm.mp4");
        FileOutputStream fos = new FileOutputStream("E:\\untitled2\\视频.mp4");

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

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

    //字节缓冲流一次读写一个字节
    public static void method3() throws IOException {
        //C:\Users\静砸今天开心了嘛\Desktop\CodeShortFilm.mp4
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("C:\\Users\\静砸今天开心了嘛\\Desktop\\CodeShortFilm.mp4"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("E:\\untitled2\\视频.mp4"));

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

        bos.close();
        bis.close();
    }

    //字节缓冲流一次读写一 个字节数组
    public static void method4() throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("C:\\Users\\静砸今天开心了嘛\\Desktop\\CodeShortFilm.mp4"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("E:\\untitled2\\视频.mp4"));

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

        bis.close();
        bos.close();
    }
}

字符流(字符流的底层还是字节流)

编码表

按照某种规则，将字符存储到计算机中,称为编码。

反之,将存储在计算机中的二进制数按照某种规则解析显示出来，称为解码。

ps：按照A编码存储，必须按照A编码解析，才能显示正确的文本符号，否则就会导致乱码现象

常见字符集：ASCll字符集，GBXXX字符集，Unicode字符集

常见编码表：GBK（最常用中文码表），GB18030（最新中文码表），UTF-8编码

【这里与字节流的区别就是字节流是读写字节（byte或byte[ ]）数据，而字符流是读写字符（char或char[ ]）数据】

字符流中的编码解码

注意：InputStreamReader和OutputStreamWrite所传的参数是FileInputStream和FileOutputStream哦！

import java.io.*;

public class FileDemo7 {
    public static void main(String[] args) throws IOException {
        //默认字符集写入，”中国“
//        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("E:\\untitled2\\ows.txt"));
        //指定GBK字符集写入 ,”�й�“
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("E:\\untitled2\\ows.txt"),"GBK");
        osw.write("中国");
        osw.close();
        //默认字符集读出
//        InputStreamReader isr = new InputStreamReader(new FileInputStream("E:\\untitled2\\ows.txt"));
        //指定GBK字符集读出
        InputStreamReader isr = new InputStreamReader(new FileInputStream("E:\\untitled2\\ows.txt"),"GBK");

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

        isr.close();//不要忘了关闭噢
    }
}

字符流写数据的5种方式

void flush():刷新流，让数据从缓冲区出来

void close():关闭流，先刷新

字符流读数据的2种方式

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

public class FileDemo8 {
    public static void main(String[] args) throws IOException {
        InputStreamReader isr = new InputStreamReader(new FileInputStream("E:\\untitled2\\File\\src\\aba.txt"));

        /*
        //一次读一个字符数据
        int ch;
        while((ch=isr.read())!=-1){
            System.out.print((char)ch);
        }
         */

        //一次读一个字符数组数据
        char[] chs = new char[1024];
        int len;
        while((len=isr.read(chs))!=-1){
            System.out.print(new String(chs,0,len));
        }
        isr.close();
    }
}

注意，一次输入一个字符数组数据的方法是

char[] chs = new char[1024];
int len;
while((len=isr.read(chs))!=-1){
     System.out.print(new String(chs,0,len));
}

先设置一个字符数组，令其容量为1024，再设置一个整型变量len，

输出的地方，要将读出的数据用String函数转为字符型输出。

在上面实操中会发现，转换流的名字很长很不方便，所以转化流提供了对应便捷子类，它们继承了转换流，也就是继承了他们的读写方法。

字符流对应的也有字符缓冲流

它的使用方法和字节缓冲流差不多，但是也有它的特有功能哦！

特殊操作流

标准输入输出流

打印流

对象序列化流

被序列化的对象必须实现Serializeble接口！！，但无需重写任何方法。

import java.io.*;

public class FileDemo9 {
    public static void main(String[] args) throws IOException {
        //ObjectOutputStream(OutputStream):创建一个写入指定的OutputStream的ObjectOutputStream
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("E:\\untitled2\\oos.txt"));
        //创建对象
        Student s = new Student("AK刘璋","20");
        //void writeObject（Object obj）：将指定的对象写入ObjectOutputStream
        oos.writeObject(s);
        //释放资源
        oos.close();
    }
}

序列的反序列化流

import java.io.*;

public class FileDemo10 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //ObjectInputStream(InputStream in):创建从指定的InputStream读取的ObjectInputStream
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("E:\\untitled2\\oos.txt"));

        //object readObject（）：从ObjectInputStream读取一个对象
        Object obj = ois.readObject();

        Student s= (Student) obj;
        System.out.println(s.getName()+","+s.getAge());

        ois.close();

    }
}

对象序列化流的三个问题！

用对象序列化流序列化了-一个对象后，假如我们修改了对象所属的类文件,读取数据会不会出问题呢?

会！抛出InvalidClassExpection异常

如果出问题了,如何解决呢?

给对象所属的类加一个serialVersionUID

private static final long serialVersionUID = 42L;

如果一个对象中的某个成员变量的值不想被序列化，又该如何实现呢?

给该成员变量加transient关键字修饰，该关键字标记的成员变量不参与序列化过程

Properties

STATICHIT静砸

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java IO流

File文件类概述和构造方法File：它是文件和目录路径名的抽象示文件和目录是可以通过File封装成对象的对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已.它可以是存在的，也可以是不存在的. 将来是要通过具体的操作把这个路径的内容转换为具体存在的字节流字符流特殊操作流...
复制链接

扫一扫