IO框架概述

最新推荐文章于 2023-07-05 14:20:14 发布

Pfst of cict

最新推荐文章于 2023-07-05 14:20:14 发布

阅读量195

点赞数

文章标签： java jvm 算法

本文链接：https://blog.csdn.net/weixin_48195998/article/details/126059320

版权

流

流的概念

流是内存与存储设备之间传输数据的通道。

流的分类

按方向分

输入流：将<存储设备>中的内容读入到<内存>中。
输出流：将<内存>中的内容写入到<存储设备>中

按单位分

字节流：以字节为单位，可以读写所有数据。
字符流：以字符为单位，只能读写文本数据。

按功能分

节点流：具有实际传输数据的读写功能。
过滤流：在节点流的基础之上增强功能。

字节流

字节流的父类（抽象类）

InputStream：字节输入流
- public int read(){}
- public int read(byte[])
- public int read(byte[])
OutputStream：字节输出流
- public void write(int n){}
- public void write(byte[] b)
- public void write(byte[] n,int off ,int len){}

文件字节流

FileInputStream:

public int read(byte[] b)//从流中读取多个字节，将读到的内容存入b数组，返回实际读到的字节数；如果达到文件的尾部，则返回-1；

OutputStream：

public void write（byte[] b）//一次写多个字节，将b数组中所有字节写入输出流。

FileInputStream

将数据读入数组里面输出时，如果不使用重载的new String(b,0,count)方法很有可能出现读出的数据后面多出一大块。因为没有把上一次读进数组里的数据覆盖掉。

package IO;

import java.io.FileInputStream;

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

        //创建FileInputStream，并指定文件路径
        FileInputStream fis = new FileInputStream("D:\\IO流文件\\a.txt");
        int data=0;
        //读取文件
//        while((data=fis.read())!=-1){  //read()返回的是读取一个字节的数据
//            System.out.print((char)data);
//        }
        System.out.println();
//        byte[] b=new byte[3];
//        int count=fis.read(b);
//        System.out.print(new String(b));
//        System.out.println("读取字节数为"+count);
//        int count2=fis.read(b);
//        System.out.print(new String(b));
//        System.out.println("读取字节数为"+count2);
//        int count3=fis.read(b);
//        System.out.print(new String(b,0,count3));
//        System.out.println("读取字节数为"+count3);
//        int count4=fis.read(b);
//        System.out.println(count4);//-1   read(b[]) 读到结尾会自动停止，如果还要强制让他读就会返回-1
        byte[] b=new byte[1024];
        int count;
        while((count=fis.read(b))!=-1){   //read(b[])返回的是读取数据的字节个数
            System.out.println(new String(b,0,count)); //调用String(b[]有参构造方法需要先实例化 所以要new
        }
        //关闭
        fis.close();
        System.out.println();
        System.out.println("执行完毕");
    }
}

OutputStream

写入文件时如果append不给true值再次运行程序就会覆盖掉原来写入的数据。

package IO;

import java.io.FileOutputStream;

public class FileOutputStreamTest {
    public static void main(String[] args) throws  Exception {
        FileOutputStream fos = new FileOutputStream("d:\\IO流文件\\b.txt",true);//append=true再次运行写入时不会覆盖之前的写入数据
        fos.write(97);//转换为二进制，然后写低八位对应的ASCll码
        fos.write('b');
        fos.write('c');
        int[] a={110,48,65,4,8,7};//字节流写入，以一个字节为单位进行写入的，超过一个字节的数据只写低八位
        for (int i = 0; i < a.length; i++) {
                fos.write(a[i]);
        }
        String b="hello world";
        fos.write(b.getBytes());//使用指定的字符集将字符串编码为 byte 序列，并将结果存储到一个新的 byte 数组中
        fos.close();
    }

}

字节流文件复制

package IO;

import java.io.FileInputStream;
import java.io.FileOutputStream;

public class Copy {
    public static void main(String[] args) throws Exception{
        FileInputStream fis = new FileInputStream("d:\\桌面\\图片\\q.jpg");
        FileOutputStream fos = new FileOutputStream("d:\\IO流文件\\q.jpg");
        int count;
        byte[] b=new byte[1020];
        while((count= fis.read(b))!=-1){ //空格也算一个字节
            fos.write(b);
        }
        fis.close();
        fos.close();
    }
}

字节缓冲流

BufferedInputStream

package IO;

import java.io.BufferedInputStream;
import java.io.FileInputStream;

public class BufferedInputStreamTest {
    public static void main(String[] args) throws Exception {
        FileInputStream fis = new FileInputStream("d:\\IO流文件\\b.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);
        int data;
        while((data=bis.read())!=-1){ //bis.read() 先将数据读入自己8k的缓冲数组中，再单独输出
            System.out.print((char)data);
        }
        int count;
        byte[] b=new byte[1024];
        while((count=bis.read(b))!=-1){//bis,read(b)先将数据读入自己的8k缓冲数组，再按自定义的数组大小读取
            System.out.println(new String(b,0,count));
        }
        bis.close();
    }
}

BufferedOutputStream

package IO;

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;

public class BufferedOutputStreamTest {
    public static void main(String[] args)throws Exception {
        FileOutputStream fos = new FileOutputStream("d:\\IO流文件\\d.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        for (int i = 0; i < 10; i++) {
            bos.write("taylor swift\n".getBytes());//写到8k的缓冲数组中
            bos.flush();//刷新到硬盘
        }
        bos.close();
    }
}

序列化与反序列化

序列化

package IO;

import java.io.Serializable;

public class Student implements Serializable {
    String name;
    int age;

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

package IO;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

/**
 * 使用ObjectOutputStreamTest实现对象的序列化时，序列化类必须实现Serilizable接口
 */
public class ObjectOutputStreamTest {
    public static void main(String[] args) throws Exception{
        FileOutputStream fos = new FileOutputStream("d:\\IO流文件\\e.txt");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        Student s1 = new Student("张三", 25);
        //写文件（序列化）
        oos.writeObject(s1);
        oos.close();
    }
}

反序列化

public class Student implements Serializable {
    String name;
    int age;

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

package IO;

import java.io.FileInputStream;
import java.io.ObjectInputStream;

/**
 * 使用ObjectOutputStreamTest实现对象的反序列化时，序列化类必须实现Serilizable接口
 */
public class ObjectInputStreamTest {
    public static void main(String[] args) throws Exception{
        FileInputStream fis = new FileInputStream("d:\\IO流文件\\e.txt");
        ObjectInputStream ois = new ObjectInputStream(fis);
        Student s= (Student) ois.readObject();
        System.out.println(s.toString());
        ois.close();
    }
}

注意事项：

序列化类必须要实现Serializable接口
序列化类中对象属性也要求实现Serializable接口
序列化版本号ID，保证序列化的类和反序列化的类是同一个类。
使用transient（瞬间的）修饰属性，这个属性不能序列化
静态属性不能序列化

序列化多个对象可以借助集合实现

package IO;

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.Arrays;

/**
 * 使用ObjectOutputStreamTest实现对象的序列化时，序列化类必须实现Serilizable接口
 */
public class ObjectOutputStreamTest {
    public static void main(String[] args) throws Exception{
        FileOutputStream fos = new FileOutputStream("d:\\IO流文件\\e.txt");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        Student s1 = new Student("张三", 25);
        Student s2 = new Student("李四", 26);
        ArrayList<Student> als=new ArrayList<Student>();
        als.add(s1);
        als.add(s2);
        oos.writeObject(als);
        oos.close();
    }
}

package IO;

import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.util.ArrayList;

/**
 * 使用ObjectOutputStreamTest实现对象的反序列化时，序列化类必须实现Serilizable接口
 */
public class ObjectInputStreamTest {
    public static void main(String[] args) throws Exception{
        FileInputStream fis = new FileInputStream("d:\\IO流文件\\e.txt");
        ObjectInputStream ois = new ObjectInputStream(fis);
        ArrayList<Student> als=(ArrayList)ois.readObject();
        System.out.println(als.toString());
        ois.close();
    }
}

文件字符流

FileReader

package IO;

import java.io.FileReader;

public class FileReadTest {
    public static void main(String[] args)throws Exception {
        FileReader fr = new FileReader("d:\\IO流文件\\f.txt");
        int data;
//        while ((data=fr.read())!=-1){//int取值范围为包含char 可以自动转换，而char取值范围里面不包含-1
//            System.out.print((char)data);
//        }
        char[] b=new char[3];
        int count;
        while((count=fr.read(b))!=-1){
            System.out.println(new String(b,0,count));
        }
        fr.close();
    }
}

FileWriter

package IO;

import java.io.FileWriter;

public class FileWriterTest {
    public static void main(String[] args)throws Exception{
        FileWriter fw = new FileWriter("d:\\IO流文件\\g.txt");
        char[] a={'a','s','d','w'};
        int[] b={1,5,4,7,8,9};
        for (int i = 0; i <b.length ; i++) {
//          fw.write((char)b[i]);//int强转为char 会根据int的数值到Unicode表中去找对应的char 没有就会乱码
            fw.write(Integer.toString(b[i]));//写入整型
        }
        for (int i = 0; i < 10; i++) {
           fw.write("好好学习赚大钱！！\n");
        }
        fw.write(a);
        fw.close();
    }

}

文本复制

package IO;

import java.io.FileReader;
import java.io.FileWriter;

/**
 * 只能复制文本文件，不能复制图片文件和二进制文件
 */
public class CharCopy {
    public static void main(String[] args)throws Exception {
        FileReader fr = new FileReader("d:\\IO流文件\\g.txt");
        FileWriter fw = new FileWriter("d:\\IO流文件\\h.txt");
//        char[] b=new char[1024];
//        fr.read(b);
//        fw.write(b);
        int count;
        while((count=fr.read())!=-1){
            fw.write(count);//写入整型，然后到字符编码表中去找到对应的字符。
        }
        /*
        write() 有五种重载方式：
        write(int args)：写入数字，利用 ASCII 码表 或者 Unicode 表转化
        write(String str)：写入字符串
        write(String str,int offset,int count)：写入字符串的一部分
        write(char[] array)：写入字符数组
        write(char[] array,int offset,int count)：写入字符数组的一部分
         */
        fr.close();
        fw.close();
    }
}

是否能复制图片？

package IO;

import java.io.FileReader;
import java.io.FileWriter;

public class CharCopy2 {
    public static void main(String[] args)throws Exception {
        FileReader fr = new FileReader("d:\\IO流文件\\q.jpg");
        FileWriter fw = new FileWriter("d:\\IO流文件\\bb.jpg");
        int data;
        while((data=fr.read())!=-1){
            fw.write(data); /**
             不能读取图片文件和二进制文件，因为图片和二进制只是单纯的由二进制文件组成，
             文件没有对应的字符编码。
             */
        }
        fr.close();
        fw.close();
    }
}

字符缓冲流

BufferedReader

package IO;

import java.io.BufferedReader;
import java.io.FileReader;

public class BufferedReaderTest {
    public static void main(String[] args)throws Exception {
        FileReader fr = new FileReader("d:\\IO流文件\\g.txt");
        BufferedReader br = new BufferedReader(fr);
       //   1.  int data;
//        while((data=br.read())!=-1){
//            System.out.print((char)data);
//        }
       //2.
//       char[] b=new char[10];
//        int count;
//        while((count=br.read(b))!=-1){
//            System.out.print(new String(b,0,count)); //读到啥就会输出啥包括换行符
//        }
        //3.
        String line;
        while((line=br.readLine())!=null){//读到空格或者null停止
            System.out.println(line);
        }
        br.close();
    }
}

BufferedWriter

package IO;

import java.io.BufferedWriter;
import java.io.FileWriter;

public class BufferedWriterTest {
    public static void main(String[] args) throws Exception{
        FileWriter fw = new FileWriter("d:\\IO流文件\\aa.txt");
        BufferedWriter bw = new BufferedWriter(fw);
        for (int i = 0; i < 10; i++) {
            bw.write("希望自己能够有一个美好的未来！！");
            bw.newLine();
            bw.flush();//自己刷新一下防止文件太大，系统提供的缓冲不够再次写入就会覆盖之前写入的数据，这样就不会写到硬盘上。
        }
        bw.close();//自动调用flush
    }
}

PrintWriter

package IO;

import java.io.PrintWriter;

public class PrintWriterTest {
    public static void main(String[] args) throws  Exception{
        PrintWriter pw = new PrintWriter("d:\\IO流文件\\bb.txt");
        char[] a={'a','b','c','d'};
        pw.println(true);
        pw.println(8);
        pw.println(a);
        pw.close();
    }
}

转换流

InputStreamReader（硬盘到内存，字节到字符）

package IO;

import java.io.FileInputStream;
import java.io.InputStreamReader;

/**
 * 指定使用的编码读取文件
 */
public class InputStreamReaderTest {
    public static void main(String[] args) throws Exception{
        FileInputStream fis = new FileInputStream("d:\\IO流文件\\aa.txt");
        InputStreamReader isr = new InputStreamReader(fis,"utf8");
        int data;
        while((data=isr.read())!=-1){
            System.out.print((char)data);
        }
        isr.close();
    }

}

OutputStreamWriter

package IO;

import java.io.FileOutputStream;
import java.io.OutputStreamWriter;

public class OutputStreamWriterTest {
    public static void main(String[] args) throws Exception {
        FileOutputStream fos = new FileOutputStream("d:\\IO流文件\\bb.txt");
        OutputStreamWriter osr = new OutputStreamWriter(fos, "utf8");
        for (int i = 0; i < 10; i++) {
            osr.write("java带我走向未来！！\n");
        }
        osr.close();
    }
}

File类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PYLyBN0I-1659084112518)(D:\桌面\javaPicture\1645688798517.png)]

File 类与 FileInputStream 类的区别：

流类关注的是文件内容，而 File 类关注的是文件在磁盘上的存储。
File 不属于文件流 , 只能代表一个文件或是目录的路径名而已。

文件操作

package IO;

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

public class FileTest {
    public static void main(String[] args)throws Exception {
        separator();
        fileoperate();
    }
    //分隔符
    public static void separator(){
        System.out.println("路径分隔符："+File.pathSeparator);
        System.out.println("名称分隔符："+File.separator);
    }
    //文件操作
    public static void fileoperate() throws  Exception{
        //创建文件
        File file = new File("d:\\IO流文件\\cc.txt");
        if (!file.exists()){
            boolean b=file.createNewFile();
            System.out.println("创建结果"+b);
        }
        //删除文件2.1直接删除
//        System.out.println("删除结果："+file.delete());
//        2.2 使用JVM退出时删除
//        file.deleteOnExit();
//        Thread.sleep(5000);
        //获取文件信息
        System.out.println("绝对路径"+file.getAbsolutePath());//绝对路径
        System.out.println("相对路径"+file.getPath());//获取路径，即文件创建时填写的路径
        System.out.println("文件名称"+file.getName());
        System.out.println("父目录"+file.getParent());
        System.out.println("文件长度"+file.length());
        //lastModified返回long型。new Date返回日期格式 toLocaleString() 方法使用区域设置将 Date 对象转换为字符串。
        //默认语言取决于您计算机上的区域设置。
        System.out.println("文件创建时间"+new Date(file.lastModified()).toLocaleString());
        //判断
        System.out.println("是否可写"+file.canWrite());
        System.out.println("是否是文件"+file.isFile());//有可能是文件夹等等
        System.out.println("是否是隐藏文件"+file.isHidden());

    }
}

文件夹操作

package IO;
import java.io.File;
import java.util.Date;

public class DirTest {
    public static void main(String[] args)throws Exception {
        diroperate();
    }
    //文件夹操作
    public static void diroperate() throws  Exception{
        //创建文件夹
        File dir = new File("d:\\IO流文件\\aaa");
        if (!dir.exists()){
//          boolean b=dir.mkdir();//创建单级目录
            boolean b=dir.mkdirs();//创建多级目录
            System.out.println("创建结果"+b); //创建成功返回true 失败返回false
        }
        //删除文件2.1直接删除
        System.out.println("删除结果："+dir.delete()); //删除成功返回true 失败返回flase
//        2.2 使用JVM退出时删除
//        dir.deleteOnExit();
//        Thread.sleep(5000);
        //获取文件信息
        System.out.println("绝对路径"+dir.getAbsolutePath());//绝对路径
        System.out.println("相对路径"+dir.getPath());//获取路径，即文件创建时填写的路径
        System.out.println("文件名称"+dir.getName());
        System.out.println("父目录"+dir.getParent());
        System.out.println("文件长度"+dir.length());
        //lastModified返回long型。new Date返回日期格式 toLocaleString() 方法使用区域设置将 Date 对象转换为字符串。
        //默认语言取决于您计算机上的区域设置。
        System.out.println("文件创建时间"+new Date(dir.lastModified()).toLocaleString());
        //判断
        System.out.println("是否可写"+dir.canWrite());
        System.out.println("是否是文件"+dir.isDirectory());//有可能是文件夹等等
        System.out.println("是否是隐藏文件"+dir.isHidden());
        //遍历.1
        File dir1 = new File("d:\\桌面\\图片");
        String[] string = dir1.list();
        File[] files = dir1.listFiles();
        for (File file : files) {
            System.out.println(file.getPath());
        }
        for (String s : string) {
            System.out.println(s.toString());
        }
         //过滤 实现FileFilter接口
        System.out.println("=================过滤=========================");
        File[] file=dir1.listFiles(new FileFilter() {//dir.listFiles()返回文件类型数据 将数据传给accept方法
            @Override
            public boolean accept(File pathname) {
                if(pathname.getName().endsWith(".jpg")){
                    return true;
                }
                return false;
            }
        });
        for (File file1 : file) {
            System.out.println(file1);
        }
    }
}

案例1.1（递归查找指定文件夹下的所有文件绝对路径）

package IO;

import java.io.File;

/**
 * 递归调用输出指定文件夹下的所有文件的绝对路径
 */
public class FileTest1 {
    public static void main(String[] args) {
        File files=new File("d:\\IO流文件");
        diGui(files);
    }
    public static void diGui(File file){
        File[] a=file.listFiles();
        if (a!=null&&a.length>0){
        for (File file1 : a) {
            if(file1.isDirectory()){
                diGui(file1);
            }
            else{
                System.out.println(file1.getAbsolutePath());
            }
        }
        }
    }
}

案例1.2（递归查找指定文件夹下的所有文件绝对路径）

package IO;

import java.io.File;

/**
 * 递归删除指定文件夹下的所有文件
 */
public class FileTest2 {
    public static void main(String[] args) {
        File file = new File("d:\\IO流文件\\111");
        diGui(file);
    }
    public static void diGui(File file){
        File[] files = file.listFiles();
        if(files!=null&&files.length>0){
            for (File file1 : files) {
                if (file1.isDirectory()){
                    diGui(file1);
                }
                else
                    System.out.println(file1.getAbsolutePath()+"文件删除"+file1.delete());
            }
        }
        System.out.println(file.getAbsolutePath()+"文件夹删除："+file.delete());
    }
}

集合Properties

package IO;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.PrintWriter;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

public class property {
    public static void main(String[] args)throws Exception {
        Properties properties = new Properties();
        //增加
        properties.setProperty("age","18");
        properties.setProperty("userName","张三");
        System.out.println(properties);
        //删除
//        properties.remove("userName");
//        System.out.println(properties);
        //遍历keySet
        Set<Object> objects = properties.keySet();
        for (Object object : objects) {
            System.out.println(object.toString()+"======="+properties.get(object));
        }
        //entrySet
        Set<Map.Entry<Object, Object>> entries = properties.entrySet();
        for (Map.Entry<Object, Object> entry : entries) {
            System.out.println(entry.getKey()+"======"+entry.getValue());
        }
        //stringPropertyNames
        Set<String> strings = properties.stringPropertyNames();
        for (String string : strings) {
            System.out.println(string+"========="+properties.getProperty(string));
        }
        //和流有关的方法
        System.out.println("===============list方法 将此属性列表打印到指定的输出流。=====================");
        PrintWriter printWriter = new PrintWriter("d:\\IO流文件\\dd.txt");
        properties.list(printWriter);
        printWriter.close();
        //store保存方法 将集合中的内容保存到文件夹
        System.out.println("===============保存方法=====================");
        FileWriter fileWriter = new FileWriter("d:\\IO流文件\\ee.txt");
        properties.store(fileWriter,"注释");
        fileWriter.close();
        //加载方法
        System.out.println("===============加载方法=====================");
        FileReader fileReader = new FileReader("d:\\IO流文件\\ee.txt");
        properties.load(fileReader);
        fileReader.close();
        System.out.println(properties.toString());
    }
}