See InputSteram.read(byte[]) for reading bytes at a time.

Example code:

try {
    File file = new File("myFile");
    FileInputStream is = new FileInputStream(file);
    byte[] chunk = new byte[1024];
    int chunkLen = 0;
    while ((chunkLen = is.read(chunk)) != -1) {
        // your code..
    }
} catch (FileNotFoundException fnfE) {
    // file not found, handle case
} catch (IOException ioE) {
    // problem reading, handle case
}

You can use the appropriate read() method from the input stream, for example FileInputStream supports a read(byte[]) to read a chunk of bytes.

something like: You may want to wrap the input stream in a BufferedInputStream if you wanted to guarantee 512 byte blocks (the constructor takes a block size argument).

byte[] buffer = new byte[512];
FileInputStream in = new FileInputStream("some_file");
int rc = in.read(buffer);
while(rc != -1)
{
  // rc should contain the number of bytes read in this operation.
  // do stuff...

  // next read
  rc = in.read(buffer); 
}

A simple way to do this is to wrap another Reader with a simple class like this:

/**
 * Read fixed-sized chunks from an underlying {@link Reader}
 */
public class ChunkReader {
    private final int chunkSize;
    private Reader reader;

    public ChunkReader(Reader reader, int chunkSize) {
        if (chunkSize <= 0) {
            throw new IllegalArgumentException("Chunk size must be > 0");
        }
        this.reader = reader;
        this.chunkSize = chunkSize;
    }

    public String readChunk() throws IOException {
        if (reader == null) {
            return null;
        }
        char[] cbuf = new char[chunkSize];
        int off = 0;
        int read = 0;
        while (read < chunkSize) {
            int ret = reader.read(cbuf, off, chunkSize-off);
            if (ret == -1) {
                reader = null;
                if (read == 0) {
                    return null;
                }
                break;
            }
            read += ret;
        }
        return new String(cbuf, 0, read);
    }
}

You could turn it into an Iterator fairly easily if you want, but there's one small caveat: we don't quite know if the next readChunk call will return null if the last one succeeded fully (i.e. read a full chunk), because the underlying Reader could immediately return -1 on the first call. So we'll need to do some sneaky look-aheads for this:

public class ChunkIterator implements Iterator<String> {
    private final int chunkSize;
    private Reader reader;
    private String next;

    public ChunkIterator(Reader reader, int chunkSize) {
        if (chunkSize <= 0) {
            throw new IllegalArgumentException("Chunk size must be > 0");
        }
        this.reader = reader;
        this.chunkSize = chunkSize;
    }

    private String readChunk() throws IOException {
        // same as above
    }

    @Override
    public boolean hasNext() {
        if (next != null) {
            return true;
        }
        if (reader == null) {
            return false;
        }
        try {
            next = readChunk();
        } catch (IOException e) {
            // could also return false, depending on your requirements
            throw new RuntimeException(e);
        }
        return next != null;
    }

    @Override
    public String next() {
        if (!hasNext()) {
            throw new NoSuchElementException();
        }
        return next;
    }
}

To chunk your input use a FileInputStream:

    Path pp = FileSystems.getDefault().getPath("logs", "access.log");
    final int BUFFER_SIZE = 1024*1024; //this is actually bytes

    FileInputStream fis = new FileInputStream(pp.toFile());
    byte[] buffer = new byte[BUFFER_SIZE]; 
    int read = 0;
    while( ( read = fis.read( buffer ) ) > 0 ){
        // call your other methodes here...
    }

    fis.close();

According to your description, Spring-Batch fit very well.

Basically, it use chunk concept to read/process/write the content. By the way, it can be concurrent for performance.

    @Bean
    protected Step loadFeedDataToDbStep() {
        return stepBuilder.get("load new fincon feed").<com.xxx.Group, FinconFeed>chunk(250)
                .reader(itemReader(OVERRIDDEN_BY_EXPRESSION))
                .processor(itemProcessor(OVERRIDDEN_BY_EXPRESSION, OVERRIDDEN_BY_EXPRESSION_DATE, OVERRIDDEN_BY_EXPRESSION))
                .writer(itemWriter())
                .listener(archiveListener())
                .build();
    }

You can refer to here for more

The best thing you can do is to read your file line by line until you reach your patterns by doing something like that:

try (BufferedReader br = new BufferedReader(
     new InputStreamReader(new File(file), charset))
 ) {
    String line;
    boolean start = false;
    // Read the file line by line
    while ((line = br.readLine()) != null) {
        if (start) {
            // Here the start pattern has been found already
            if (line.equals("{/AAAA}")) {
                // The end pattern has been reached so we stop reading the file
                break;
            }
            // The line is not the end pattern so we treat it
            doSomething(line);
        } else {
            // Here we did not find the start pattern yet
            // so we check if the line is the start pattern
            start = line.equals("{AAAA}");
        }
    }
}

This way you only read your file until you reach the end pattern which will be more efficient than reading the entire file.