Java文件操作与IO流-优快云博客

本文链接：https://blog.youkuaiyun.com/Just__2009/article/details/108579637

I:input O: output

File

文件遍历、添加或删除

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

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

        File e = new File("C:\\Users\\Administrator\\Desktop\\Test");
        File[] files = e.listFiles();
        listFiles(files);

    }
    public static void listFiles(File[] files){
        if(files!=null && files.length>0){
            //遍历目录内所有文件
            for(File f:files){
                //判断是否是文件
                if(f.isFile()){
                    //判断是否是avi文件
                    if(f.getName().endsWith(".avi")){
                        //判断文件大小是否大于200MB
                        if(f.length()>100*1024*1024){
                            //删除文件
                            f.delete();
                            //打印删除信息
                            System.out.println(f.getAbsolutePath()+"已删除");

                        }
                    }
                //文件夹
                }else{
                    //进行迭代，打印出所有内层的avi文件
                    File[] f2 = f.listFiles();
                    listFiles(f2);
                }

            }
        }

    }
}

文件过滤器

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

public class Demo1 {
    public static void main(String[] args) throws IOException {
        File e = new File("C:\\Users\\Administrator\\Desktop\\YUZHAO");
        listFiles(e);

    }
    public static void listFiles(File file){
        //1. 创建一个过滤器 并描述规则
        FileFilter filter = new AVIfileFilter();
        //2. 通过文件获取子文件夹
        File[] files = file.listFiles(filter);
        if(files!=null && files.length!=0){
            for (File f: files){
                if(f.isDirectory()){
                    listFiles(f);
                }else{
                    System.out.println("发现了一个avi"+f.getAbsolutePath());
                }
            }
        }
    }
    
    static class AVIfileFilter implements FileFilter {

        @Override
        public boolean accept(File pathname) {
            if(pathname.getName().endsWith(".avi") || pathname.isDirectory()){
                return true;
            }
            //return true 表示保留，return false表示不保留
            return false;
        }
    }
}

使用匿名内部类

public static void listFiles(File file){
        //1. 创建一个过滤器 并描述规则
        //匿名内部类
        FileFilter filter = new FileFilter(){
            @Override
            public boolean accept(File pathname) {
                if(pathname.getName().endsWith(".avi") || pathname.isDirectory()){
                    return true;
                }
                //return true 表示保留，return false表示不保留
                return false;
            }
        };
        //2. 通过文件获取子文件夹
        File[] files = file.listFiles(filter);
        if(files!=null && files.length!=0){
            for (File f: files){
                if(f.isDirectory()){
                    listFiles(f);
                }else{
                    System.out.println("发现了一个avi"+f.getAbsolutePath());
                }
            }
        }
    }

匿名内部类使用方法二：

 public static void listFiles(File file){
        //1. 创建一个过滤器 并描述规则
        
        //2. 通过文件获取子文件夹
        File[] files = file.listFiles(new FileFilter(){
            @Override
            public boolean accept(File pathname) {
                if(pathname.getName().endsWith(".avi") || pathname.isDirectory()){
                    return true;
                }
                //return true 表示保留，return false表示不保留
                return false;
            }
        });
        if(files!=null && files.length!=0){
            for (File f: files){
                if(f.isDirectory()){
                    listFiles(f);
                }else{
                    System.out.println("发现了一个avi"+f.getAbsolutePath());
                }
            }
        }

    }

相对路径和绝对路径
1.绝对路径，是一个以盘符起始的完整路径
2.相对路径，是一个不完整的便捷路径，在java中是相对于项目目录路径

IO流

字节流：

输入流： InputStream
输出流： OutputStream

字符流：

输入流：Reader
输出流：Writer

流使用完毕一定要关闭。

OutputStream

一切皆字节：计算机中任何数据（文本、图片等）都是以二进制的形式存储的
在数据传输时也都是以二进制存储的
不再使用时一定要关闭流。

FileOutputStream

每一个FileOutPutStream对象都可以被看作向某个文件中输出的流。

FileOutputStream(File file)
创建文件输出流以写入由指定的 File对象表示的文件。默认为清空重写
FileOutputStream(File file, boolean append)
创建文件输出流以写入由指定的 File对象表示的文件。

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

public class Demo2 {
    public static void main(String[] args) throws IOException {
        System.out.println("============Demo1==========");
         FileOutputStream fos = new FileOutputStream("C:\\Users\\Administrator\\Desktop\\test\\a.txt");
         fos.write(65);//A
         byte[] bytes = {66,67,68,69,70};//A
         fos.write(bytes);//AABCDEF
         fos.close();
        System.out.println("============Demo2==========");
        FileOutputStream fos2 = new FileOutputStream("C:\\Users\\Administrator\\Desktop\\test\\a2.txt");
        byte[] bytes2 = "ABCDEF".getBytes();
        fos2.write(bytes2);//ABCDEF
        fos2.write(bytes2,1,2);//BC



    }
}

FileInputStream

读取一个字节的内容

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

public class Demo3 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("C:\\Users\\Administrator\\Desktop\\test\\a.txt");
        byte b = (byte)fis.read();
        System.out.println(b);//65
        System.out.println((char)b);//A

        fis.close();
    }
}

读取一组字节的内容**（常用）**
目的：减少IO使用频率
读取到旧数据

public class Demo4 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("C:\\Users\\Administrator\\Desktop\\test\\a.txt");
        byte[] bytes = new byte[10];
        fis.read(bytes);
        System.out.println(new String(bytes));//AABCDEFSFE
        fis.read(bytes);
        System.out.println(new String(bytes));//WWFXCVDSad
        fis.read(bytes);
        System.out.println(new String(bytes));//qdqwwrDSad
        fis.read(bytes);
        System.out.println(new String(bytes));//qdqwwrDSad

    }
}

为了避免这个问题。使用String类的三参构造器设定范围
String(byte[] bytes, int offset, int length)
通过使用平台的默认字符集解码指定的字节子阵列来构造新的 String 。

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

public class Demo4 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("C:\\Users\\Administrator\\Desktop\\test\\a.txt");
        byte[] bytes = new byte[10];
        while(true){
            int len = fis.read(bytes);
            if(len==-1){
                break;
            }
            System.out.println(new String(bytes,0,len));

        }
        fis.close();
    }
}

文件加密和解密工具

import java.io.*;
import java.util.Scanner;

public class Demo5 {
    public static void main(String[] args) throws IOException {
        System.out.println("请输入文件存储路径");
        Scanner scanner = new Scanner(System.in);
        String fileName = scanner.nextLine();
        //源文件
        File oldFile = new File(fileName);
        //加密存储的新文件 文件名"en-文件名"
        File newFile = new File(oldFile.getParent(),"en-"+oldFile.getName());

        FileInputStream fis = new FileInputStream(oldFile);
        FileOutputStream fos = new FileOutputStream(newFile);
        while(true){
            int content = fis.read();
            if(content==-1){
                break;
            }
            fos.write(content^10);
        }
        System.out.println("加密完毕");
        
    }
}

文字编码

字符流

字符流可以解决在读取文件时程序读取一半的问题
在操作字符输出流时，当缓存不被刷新时，字符是不会被写入到文件中的。close()关闭同样可以刷新缓存。

import java.io.FileWriter;
import java.io.IOException;

public class Demo6 {
    public static void main(String[] args) throws IOException {
        FileWriter wr = new FileWriter("C:\\Users\\Administrator\\Desktop\\test\\字符流.txt");
        wr.write("测试");
        wr.append("字符流").append("结果").append("如此");//测试字符流结果如此
        wr.close();
    }
}

字节流装饰为字符流

import java.io.*;

public class Demo7 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("C:\\Users\\Administrator\\Desktop\\test\\a.txt");
        InputStreamReader isr = new InputStreamReader(fis,"gbk");//指定编码名称
        while(true){
            int i = isr.read();
            if(i == -1){
                break;
            }
            System.out.println((char)i);
        }

    }
}

字节\字符输出打印流

import java.io.*;

public class Demo8 {
    public static void main(String[] args) throws IOException {
        PrintStream ps = new PrintStream("C:\\Users\\Administrator\\Desktop\\test\\字节输出打印流.txt");
        ps.println("测试1");
        ps.println("测试2");
        ps.println("测试3");
        ps.close();
        PrintWriter pw = new PrintWriter("C:\\Users\\Administrator\\Desktop\\test\\字符输出打印流.txt");
        pw.println("测试1");
        pw.println("测试2");
        pw.println("测试3");
        ps.flush();
        ps.close();
        FileOutputStream fos = new FileOutputStream("C:\\Users\\Administrator\\Desktop\\test\\字符输出打印流2.txt");
        PrintWriter pw2 = new PrintWriter(fos);
        pw2.println("测试1");
        pw2.println("测试2");
        pw2.println("测试3");
        pw2.flush();
        FileReader fw = new FileReader("C:\\Users\\Administrator\\Desktop\\test\\缓存读取流.txt");
        BufferedReader br = new BufferedReader(fw);
        String text = br.readLine();
        System.out.println(text);


    }

}

生成异常文件

import java.io.IOException;
import java.io.PrintWriter;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Demo9 {
    public static void main(String[] args) throws IOException {
        try{
            String s = null;
            s.toString();
        }catch(NullPointerException e){
            PrintWriter pw = new PrintWriter("C:\\Users\\Administrator\\Desktop\\test\\异常日志.txt");
            SimpleDateFormat simpledate = new SimpleDateFormat("yyyy-MM-dd HH:mm");
            pw.println(simpledate.format(new Date()));
            e.printStackTrace(pw);
            pw.close();
        }

    }
}

Properties

将程序中的map集合存储到文件里。
写入

import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;

public class Demo10 {
    public static void main(String[] args) throws IOException {
        Properties p = new Properties();
        FileWriter fw = new FileWriter("C:\\Users\\Administrator\\Desktop\\test\\Properties存储.txt");
        p.put("name","小红");
        p.put("age","19");
        p.store(fw,"Person");
        fw.close();
    }
}

读取

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

            Properties p = new Properties();
            Reader r = new FileReader("C:\\Users\\Administrator\\Desktop\\test\\Properties存储.txt");
            p.load(r);
            System.out.println(p.getProperty("name"));//小红
            System.out.println(p.getProperty("age"));//19
    }
}

序列化

避免对象在程序关闭时消失，将对象存入文件的过程
对象的以及其下的属性必须要实现接口Serializable才可以被序列化

import java.io.*;

public class Demo11 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
    //序列化
        Book b = new Book("指环王","中土世界");
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("C:\\Users\\Administrator\\Desktop\\YUZHAO\\test\\序列化.txt"));
        oos.writeObject(b);
        oos.close();
	//反序列化
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(("C:\\Users\\Administrator\\Desktop\\YUZHAO\\test\\序列化.txt")));
        Book o = (Book) ois.readObject();
        System.out.println(o.getInfo());

    }
    //Serializable接口是一种标记 此接口中没有声明的方法
    static class Book implements Serializable {
        private String name;
        private String info;

        public Book(String name, String info) {
            this.name = name;
            this.info = info;
        }
	
        public String getName() {
            return name;
        }

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

        public String getInfo() {
            return info;
        }

        public void setInfo(String info) {
            this.info = info;
        }
    }

防止文件不存在或读取空文档

 public void loadExpress() throws IOException {
        String location ="src/com/ExpressManagement/EXPRESS.txt";
        File file = new File(location);
        if(file.exists() && file.length()!=0) {
            FileInputStream fis = new FileInputStream(location);
            ObjectInputStream objIn = new ObjectInputStream(fis);
            try (fis; objIn) {
                while (true) {
                    Express e = (Express) objIn.readObject();
                    if (e == null) {
                        break;
                    }
                    eList.add(e);
                }

            } catch (EOFException | ClassNotFoundException e) {


            }
        }
    }