Java IO流

最新推荐文章于 2023-08-15 00:42:53 发布

不会编程的小小怪

最新推荐文章于 2023-08-15 00:42:53 发布

阅读量117

点赞数

分类专栏： Java 文章标签： java 开发语言

本文链接：https://blog.youkuaiyun.com/m0_54357806/article/details/129737610

版权

Java 专栏收录该内容

7 篇文章

订阅专栏

1.File类

文件和目录路径名的抽象表示形式

1.1 构造方法

public File(String pathname)

public File(String parent,String child)

public File(File parent,String child)

绝对路径（完整路径）：在windows中就代表的是带盘符的路径

相对路径：以项目作为根目录存在

import java.io.File;

public class FileTest {
    public static void main(String[] args) {
        File file = new File("D:\\project\\javaproject\\bigdatajava\\src\\com\\bigdata\\learn\\day12\\a.txt"); //绝对路径
        File file1 = new File("src/com/bigdata/learn/day12/b.txt"); //相对路径
        //将系统中一个文件或者一个文件夹用一个File对象进行表示
        System.out.println(file.isFile());
        System.out.println(file1.isFile()); //判断是不是文件

        File file2 = new File("src/com/bigdata/learn/day12","a.txt"); //先传父路径，再传子路径
        System.out.println(file2.isFile());

        File file3 = new File("src/com/bigdata/learn/day12"); //先将父路径作为一个文件
        File file4 = new File(file3, "a.txt");
        System.out.println(file4.isFile());

    }
}

1.2 成员方法

创建功能

public boolean createNewFile()

public boolean mkdir()

public boolean mkdirs()

删除功能

public boolean delete()

重命名功能

public boolean renameTo(File dest)

判断功能

public boolean isDirectory()

public boolean isFile()

public boolean exists()

public boolean canRead()

public boolean canWrite()

public boolean isHidden()

基本获取功能

public String getAbsolutePath()

public String getPath()

public String getName()

public long length()

public long lastModified()

高级获取功能

public String[] list()

public File[] listFiles()

import java.io.File;

public class FileTest2 {
    public static void main(String[] args) throws Exception{
        File file1 = new File("src/com/bigdata/learn/day12/b.txt");
        file1.createNewFile(); //创建新的文件

        File file2 = new File("src/com/bigdata/learn/day12/aaa");
        file2.mkdir(); //创建新的文件夹

        File file3 = new File("src/com/bigdata/learn/day12/bbb/ccc/ddd");
        file3.mkdirs(); //创建多重文件夹


        System.out.println(file2.delete()); //删除文件，使用delete删除文件夹的时候，必须保证文件夹为空

        File file5 = new File("src/com/bigdata/learn/day12/new.txt");
        System.out.println(file1.renameTo(file5)); //重命名文件

        System.out.println(file1.isDirectory()); //判断是不是文件夹
        System.out.println(file1.exists()); //判断是否存在
        System.out.println(file1.canRead()); //判断是否可读
        System.out.println(file1.canWrite()); //判断是否可写
        System.out.println(file1.isHidden()); //判断是否为隐藏文件
        System.out.println(file1.getAbsoluteFile()); //获取绝对路径
        System.out.println(file1.getPath()); //获取相对路径
        System.out.println(file1.getName()); //获取文件名
        System.out.println(file1.length()); //获取文件字节数
        System.out.println(file1.lastModified()); //获取最后一次修改时间戳

        System.out.println("================================================");
        File mkdir1 = new File("E:\\soft");
        String[] file_list=mkdir1.list(); //获取soft下的所有文件，并将其放入列表中
        for (String s : file_list) {
            System.out.println(s); //循环遍历打印文件名
        }
        System.out.println("================================================");

        File[] files=mkdir1.listFiles();
        for (File file : files) {  //循环打印文件
            System.out.println(file);  
        }
        
    }
}

文件名称过滤器

需求：获取E盘下所有以JPG结尾的文件

import java.io.File;
import java.io.FileFilter;
import java.io.FilenameFilter;

public class FileFilter1 {
    public static void main(String[] args) {
        File file = new File("E:\\");

        File[] files=file.listFiles(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                File f = new File(dir, name);
                return f.isFile() && f.getName().endsWith(".jpg");
            }
        });

        for (File file1 : files) {
            System.out.println(file1);
        }
        
    }
}

递归获取F盘中以md结尾的文件

import java.io.File;

public class Digui {
    public static void main(String[] args) {
        File file = new File("F:\\");
        getMD(file);

    }

    public static void getMD(File file){
        if(file!=null){
            if(file.isFile()){
                if(file.getName().endsWith(".md")){
                    System.out.println(file.getName());
                }
            }else{
                File[] files=file.listFiles();
                if(files!=null){
                    for (File file1 : files) {
                        getMD(file1);
                    }
                }
            }
        }
    }
}

2.IO流

IO流用来处理设备之间的数据传输

上传文件和下载文件

Java对数据的操作是通过流的方式

Java用于操作流的对象都在IO包中

以java程序为参照物
    按照流向分为输入流(外部文件时数据---->java)和输出流(java---->外部文件中去)
    按照数据的类型:
        辨别字节流和字符流: 如果一个文件使用记事本打开能够看懂就属于字符流,否则就是字节流(万能流)
        字节流:
            字节输入流
            字节输出流
        字符流:
            字符输入流
            字符输出流

字节流的抽象基类： InputStream ，OutputStream。

字符流的抽象基类： Reader ， Writer。

注：由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。

如：InputStream的子类FileInputStream。

如：Reader的子类FileReader。

2.1 字节流

2.1.1 字节流写数据FileOutputStream

FileOutputStream的构造方法

FileOutputStream(File file)

FileOutputStream(String name)

字节流写方法

public void write(int b)

public void write(byte[] b)

public void write(byte[] b,int off,int len)

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

public class OutputStreamTest1 {
    public static void main(String[] args) throws IOException {
        //将写目标的文件封装成一个File对象，以参数的形式传入构造方法中
        //目标的文件可以不存在，如果不存在会自动创建
        File file = new File("src/com/bigdata/learn/File/a.txt");
        FileOutputStream fos = new FileOutputStream(file);
        System.out.println(fos);

        //以字符串传入构造方法
        FileOutputStream fos2 = new FileOutputStream("src/com/bigdata/learn/File/a.txt");
        System.out.println(fos2);

        byte[] bytes ={100,101,102,103,104};
        fos.write(97); //ASCII码
        fos.write("\r\n".getBytes()); //换行
        fos.write(bytes); //写入数组
        fos.write(bytes,2,3); //写入部分数组，2是索引，3是长度

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

注：写入发现是覆盖，若想改为追加，在后面加个true

FileOutputStream fos = new FileOutputStream(file，true);

2.2.2 字节流读数据FileInputStream

InputStream

FileInputStream

把刚才写的数据读取出来显示在控制台

FileInputStream的构造方法

FileInputStream(File file)

FileInputStream(String name)

FileInputStream的成员方法

public int read()

public int read(byte[] b)

import java.io.*;

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

        //将写目标的文件封装成一个File对象，以参数的形式传入构造方法中
        //目标的文件必须存在
        File file = new File("src/com/bigdata/learn/File/a.txt");
        FileInputStream fis = new FileInputStream(file);
        System.out.println(fis);

        //以字符串传入构造方法
        FileInputStream fis2 = new FileInputStream("src/com/bigdata/learn/File/a.txt");
        System.out.println(fis2);

        int i=0;
        while((i=fis.read())!=-1){
            System.out.println(i);
        } //一次读取一个字符,根据源码知道结束时得到的是-1

        //一次读取一个字节数组
        byte[] arr=new byte[1024]; //设置一个数组，默认大小为1024的整数倍
        int length=0;
        while((length=fis2.read(arr))!=-1){
            String s = new String(arr, 0, length); //将一部分转为字符串就行
            System.out.println(s);
        }

    }
}

把当前文件下的a.txt文件里的内容添加到b.txt中

package com.bigdata.learn.day12;

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

public class OutInTest1 {
    public static void main(String[] args) {

        FileInputStream fis = null;
        FileOutputStream fos=null;
        try {
            fis = new FileInputStream("src/com/bigdata/learn/day12/a.txt");
            fos =new FileOutputStream("src/com/bigdata/learn/day12/b.txt");
            //一个字符一个字符操作
//          int i=0;
//          while((i=fis.read())!=-1){
//              fos.write(i);
//          }
            //字节数组方式写入
            int length=0;
            byte[] arr =new byte[1024];
            while((length=fis.read(arr))!=-1){
                fos.write(arr,0,length);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        

        try {
            fos.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        try {
            fis.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

    }
}

复制图片

package com.bigdata.learn.day12;

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

public class OutInTest2 {
    public static void main(String[] args) {

        FileInputStream fis = null;
        FileOutputStream fos=null;
        try {
            fis = new FileInputStream("E:\\cat.jpg");
            fos =new FileOutputStream("src/com/bigdata/learn/day12/cat.jpg");
            //一个字符一个字符操作
          int i=0;
          while((i=fis.read())!=-1){
              fos.write(i);
          }
            //字节数组方式写入
//            int length=0;
//            byte[] arr =new byte[1024];
//            while((length=fis.read(arr))!=-1){
//                fos.write(arr,0,length);
//            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }


        try {
            fos.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        try {
            fis.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

    }
}

2.2.3 BuffedOutputStream字节缓冲输出流

构造方法

BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("src/com/bigdata/learn/day12/b.txt"));

bos.flush();

2.2.4 BuffedInputStream 字节缓冲输入流

构造方法

BufferedInputStream bis = new BufferedInputStream(new FileInputStream("java/src/com/shujia/wyh/day12/c.txt"));

bos.flush();

缓冲流必须刷新才能写入写出,close里包含刷新功能。

3.字符流

字符流（转换流） = 字节流 + 编码表在不同的编码下，一个字符所占的字节数是不同的。读和写要是同一个编码，才能看懂

3.1 字符输入流 Writer

子类OutputStreamWriter

import java.io.*;

public class WriterTest {
    public static void main(String[] args) throws IOException {
        Writer writer = new OutputStreamWriter(new FileOutputStream("src/com/bigdata/learn/day12/b.txt"),"utf8"); //第二个参数为编码

        //一次写一个字节
        writer.write(97);
        writer.flush(); //要刷新

        //一次写一个字符数组
        String s1="今天天气很好";
        char[] chars = s1.toCharArray();
        writer.write(s1);
        writer.flush();

        //写字符数组一部分
        writer.write(s1,1,3);
        writer.flush();

        //写一个字符串
        writer.write("字符串");
        writer.flush();

        //写字符串的一 部分
        writer.write("你好，你好",3,2);
        writer.flush();
        
    }
}

3.2 字符输出流 Reader

import java.io.*;

public class ReaderTest {
    public static void main(String[] args) throws IOException {
        Reader reader = new InputStreamReader(new FileInputStream("src/com/bigdata/learn/day12/b.txt"),"utf8");

        //一次读取一个字符
//        int i=0;
//        while((i= reader.read())!=-1){
//            System.out.println((char) i);
//        }

        //一次读取一个字符数组
        int length=0;
        char[] chars = new char[1024];
        while ((length=reader.read(chars))!=-1){
            String s=new String(chars,0,length);
            System.out.println(s);
        }
        
    }
}

实例:使用字符流复制文件

import java.io.*;

//使用字符流复制文件
public class WriterReader {
    public static void main(String[] args) throws IOException {
        Reader reader = new InputStreamReader(new FileInputStream("src/com/bigdata/learn/day12/new.txt")); //创建输入流
        Writer writer = new OutputStreamWriter(new FileOutputStream("src/com/bigdata/learn/day12/copyed.txt")); //创建输出流

        //一个字符一个字符复制
//        int i=0;
//        while((i= reader.read())!=-1){
//            writer.write(i);
//            writer.flush();
//        }

        //一个字符串一个字符串的复制
        int length=0;
        char[] chars = new char[1024];
        while((length=reader.read(chars))!=-1){
            String s = new String(chars, 0, length);
            writer.write(s);
            writer.flush();
        }
        
        writer.close();
        reader.close();
    }
}

3.3 FileReader和FileWriter

转换流的名字比较长，而我们常见的操作都是按照本地默认编码实现的，所以，为了简化我们的书写，转换流提供了对应的子类。

 FileReader fr = new FileReader("java/src/com/shujia/wyh/day12/e.txt");
 FileWriter fw = new FileWriter("java/src/com/shujia/wyh/day12/g2.txt");

是上面reader和writer的简化写法，基本操作一致

3.4 字符缓冲输出输入流

BufferedReader br = new BufferedReader(new FileReader("java/src/com/shujia/wyh/day12/g.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\g6.txt"));

字符缓冲输入流中有一个特殊方法：可以一次读取一行
System.out.println(br.readLine());

public class BufferedWriter1 {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new FileReader("src/com/bigdata/learn/day12/new.txt"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("src/com/bigdata/learn/day12/copyed.txt"));
        String line=null;
        //一行一行的读
        while ((line = br.readLine()) != null) {
            bw.write(line);
//            bw.write("\r\n");
            bw.newLine(); //根据系统的不一样，生成换行符,默认不换行
            bw.flush();
        }
    }
}

4.序列化流

将对象像数据流一样在网络中传输的过程，叫做序列化流序列化：对象 ---> 数据流 ObjectOutputStream 反序列化：数据流 --- > 对象 ObjectInputStream

我们正常按照思路创建序列化对象，将对象写到文件中后发现，出错了：NotSerializableException
 观察api发现，因为Teacher类没有实现Serializable接口，而又观察api得知Serializable接口中没有任何的常量和抽象方法
 而这种接口，我们一般称之为标记接口。

 我们正常写和读是没有问题，但是当我们修改了对象的类之后，再进行读取的时候发现，报错了
 com.shujia.wyh.day12.Teacher;
 local class incompatible:
     stream classdesc serialVersionUID = 5110993845480645297,
     local class serialVersionUID = 7384147610509976649

解决方案：无论我们怎么修改对象类中内容，这个serialVersionUID一直不变就好了。
如果不想让某个成员做序列化，使用transient关键字进行修饰

教师类中写法
private static final long serialVersionUID = 7384147610509976649L;
private String name;
transient private int age;

在Editor- code style-Inspections中

设置上图，可以在类中通过alt+enter自动生成serialVersionUID不变

public class ObjectOutputStreamDemo1 {
    public static void main(String[] args) {
        //创建一个对象
        Teacher t1 = new Teacher("小虎", 18);
//        write(t1);
        Object o = read();
        System.out.println(o);
    }

    public static Object read(){
        ObjectInputStream ois = null;
        Object o = null;
        try {
            //创建反序列化对象
            ois = new ObjectInputStream(new FileInputStream("java/src/com/shujia/wyh/day12/obj.txt"));
            o = ois.readObject(); //new Teacher("小虎", 18);
            return o;

        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if(ois!=null){
                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return o;

    }

    public static void write(Object obj){
        ObjectOutputStream oos = null;
        try {
            //创建序列化流对象
            oos = new ObjectOutputStream(new FileOutputStream("java/src/com/shujia/wyh/day12/obj.txt"));
            oos.writeObject(obj);
            oos.flush();
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            if(oos!=null){
                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}