How to read a file more efficiently?

Yep, using .collectList() will load the entire file content in memory before processing, defeating your purpose of saving memory. On the other hand, using buffer() is good.

I feel like using .collectList contradicts what I am doing.

It does. That consumes all elements from the initial flux until that completes, storing them all into a List that is then post-processed to produce the final flux of lists of maps. That defeats your purpose of not needing to read the whole file at once. What's more, the whole file is read before processCsvFile() even returns -- not, as one might expect, when someone subscribes to the returned Flux.

You can group incoming lines by buffer()ing the original flux, yielding a flux of Lists of lines. You seem to already be aware of this, so it's unclear why you are use it in the convoluted way you do. Just buffer the flux directly.

You can also transform the elements of a flux by map()ing it. In your case, it makes more sense to do that before grouping than after.

The main issue to overcome here is that you are treating the first line of your CSV specially, such that its contents inform the processing of all the other lines. One way to deal with that is as you have done: collect all of the lines and process them together. If you want to avoid that then you need a way to separate that initial line and capture its contents in a way that is visible when processing each other line, and here is where filter() comes in, and the fact that lambdas close over their context.

Overall, then, maybe something more like this:

public Flux<List<Map<String, String>>> processCsvFile(File csvFile, String delimiter) {

    notBlank(csvFile.getPath(), "the file must not be empty");
    notBlank(delimiter, "the delimiter must not be empty");

    List<String> headers = new ArrayList<>();
    Pattern delimPattern = Pattern.compile("\s*" + Pattern.quote(delimiter) + "\s*");

    return Flux.using(
            () -> Files.lines(csvFile.toPath()),
            Flux::fromStream,
            stream -> stream.close()
        ).filter(line -> {
            if (headers.isEmpty()) {
                headers.addAll(Arrays.asList(delimPattern.split(line)));
                return false;
            }
            return true;
        })
        .map(line -> {
            String[] columns = delimPattern.split(line);
            return IntStream.range(0, headers.size())
                .collect(
                    HashMap::new,
                    (map, i) -> { map.put(headers.get(i), (i < columns.length) ? columns[i] : null); },
                    HashMap::putAll
                );
        })
        .buffer(10)
        .onErrorResume(e -> {
            log.atError()
                    .addKeyValue("csvFile", csvFile.getName())
                    .setCause(e)
                    .log("Error processing CSV file");
            return Flux.error(new RuntimeException("Error processing CSV file", e));
        });
}

Because lambdas close over their context, those used by the various fluxes involved in the above will capture references to the headers and delimPattern objects, so that they can continue to use -- and share! -- them after even after the function returns.

Do note also that although I have mimicked your approach to CSV parsing, that should not be taken as an endorsement. Most CSV dialects are more complicated than that naive approach supports. Unless you have very close control over the input, such that you can be sure that an approach like that is sufficient, you should instead choose and use a well-designed CSV parser that accounts for issues such as quotation and escaping. There are several available. In addition to being more robust, that would surely simplify the above, probably by a lot, or perhaps even moot it altogether.