Java8使用Function读取文件

import java.util.arraylist;
import java.util.function.consumer;
import java.util.list;

public class filecloseable<t> implements autocloseable {
    private consumer<list<t>> writer;
    private int pagesize;
    private list<t> buffer;

    public filecloseable(consumer<list<t>> writer, int pagesize) {
        this.writer = writer;
        this.pagesize = pagesize;
        this.buffer = new arraylist<>(math.max(1, pagesize));
    }

    public void add(t element) {
        buffer.add(element);
        if (buffer.size() >= pagesize) {
            flush();
        }
    }

    private void flush() {
        if (!buffer.isempty()) {
            writer.accept(new arraylist<>(buffer));
            buffer.clear();
        }
    }

    @override
    public void close() {
        flush();
    }
}

public class filecontext {
    private file file;
    private charset charset;
    private int skipheader;
    private string batchdate;
    private int pagesize;
    private boolean deleteflag;
    private string filterlineheader;

    // 构造函数、getter 和 setter 省略

    public file getfile() {
        return file;
    }

    public void setfile(file file) {
        this.file = file;
    }

    public charset getcharset() {
        return charset;
    }

    public void setcharset(charset charset) {
        this.charset = charset;
    }

    public int getskipheader() {
        return skipheader;
    }

    public void setskipheader(int skipheader) {
        this.skipheader = skipheader;
    }

    public string getbatchdate() {
        return batchdate;
    }

    public void setbatchdate(string batchdate) {
        this.batchdate = batchdate;
    }

    public int getpagesize() {
        return pagesize;
    }

    public void setpagesize(int pagesize) {
        this.pagesize = pagesize;
    }

    public boolean isdeleteflag() {
        return deleteflag;
    }

    public void setdeleteflag(boolean deleteflag) {
        this.deleteflag = deleteflag;
    }

    public string getfilterlineheader() {
        return filterlineheader;
    }

    public void setfilterlineheader(string filterlineheader) {
        this.filterlineheader = filterlineheader;
    }
}

import lombok.allargsconstructor;
import lombok.builder;
import lombok.noargsconstructor;
import lombok.extern.slf4j.slf4j;

import java.io.file;
import java.nio.file.files;
import java.nio.file.paths;
import java.util.list;
import java.util.function.bifunction;
import java.util.function.consumer;
import java.util.stream.stream;

@builder
@allargsconstructor
@noargsconstructor
@slf4j
public class filehandler<t, r> {

    private filecontext context;
    private bifunction<string, string, t> reader; // 读逻辑
    private consumer<list<t>> writer;// 写逻辑
    private linefilter linefilter; // 新增过滤逻辑

    public void execute() throws exception {
        file file = context.getfile();
        try (
                stream<string> streams = files.lines(paths.get(file.getpath()), context.getcharset());
                filecloseable<t> files = new filecloseable<>(writer, context.getpagesize())
        ) {
            streams.skip(context.getskipheader())
                    .filter(linefilter.getlinepredicate())
                    .map(e -> reader.apply(e, context.getbatchdate()))
                    .foreach(files::add);
        } catch (exception e) {
            log.error("解析文件失败: file: {}, error: {}", file, e);
            throw new exception("文件处理异常", e);
        } finally {
            deletefileifnecessary(file);
        }
    }

    private void deletefileifnecessary(file file) {
        if (context.isdeleteflag() && file.exists()) {
            try {
                boolean deleted = files.deleteifexists(file.topath());
                if (deleted) {
                    log.info("文件已删除: {}", file);
                } else {
                    log.info("文件不存在，无法删除: {}", file);
                }
            } catch (exception e) {
                log.error("删除文件失败: file: {}, error: {}", file, e);
            }
        }
    }
}

import java.util.function.predicate;

public interface linefilter {
    predicate<string> getlinepredicate();
}

import java.util.function.predicate;

public class customlinefilter implements linefilter {
    private string filterlineheader;

    public customlinefilter(string filterlineheader) {
        this.filterlineheader = filterlineheader;
    }

    @override
    public predicate<string> getlinepredicate() {
        return line -> !line.startswith(filterlineheader);
    }
}

import java.io.file;
import java.nio.charset.standardcharsets;
import java.util.list;
import java.util.function.bifunction;
import java.util.function.consumer;

public class filehandlerexample {
    public static void main(string[] args) {
        // 创建文件上下文
        filecontext context = new filecontext();
        file file = new file("d:\\temp\\testwrite.txt");
        context.setfile(file);
        context.setcharset(standardcharsets.utf_8);
        context.setskipheader(0);
        context.setbatchdate("20220101");
        context.setpagesize(100);
        context.setdeleteflag(false);

        // 定义解析方法
        bifunction<string, string, string> reader = (line, batchdate) -> line.trim();

        // 定义写入方法
        consumer<list<string>> writer = list -> {
            for (string s : list) {
                system.out.println(s);
            }
        };

        // 创建自定义过滤逻辑
        linefilter linefilter = new customlinefilter("#");

        // 创建 filehandler 实例
        filehandler<string, void> filehandler = filehandler.<string, void>builder()
                .context(context)
                .reader(reader)
                .writer(writer)
                .linefilter(linefilter) // 设置过滤逻辑
                .build();

        // 执行文件处理
        try {
            filehandler.execute();
        } catch (exception e) {
            e.printstacktrace();
        }
    }
}