Application: gvSIG desktop

import java.util.NoSuchElementException;

import java.util.Spliterator;

import java.util.Spliterators;

import java.util.function.Predicate;

import java.util.stream.Stream;

import java.util.stream.StreamSupport;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.io.IOUtils;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.library.impl.DefaultLibrariesInitializer;

    protected static final int INDEX_HEADER_FILESIZE = 0;

    protected static final int INDEX_HEADER_INDEXCREATIONCOST = 1;

    protected RandomAccessFile raf;

    protected Reader reader;

            status.message(i18n.getTranslation("_Calculating_number_of_lines"));

            status.setIndeterminate();

        }

        try {

            String line;

            count = 0;

                }

                count++;

            }

            if (status != null) {

                status.message("");

                status.setIndeterminate();

            }

    }

    public RandomAccessFileIndex createOrOpenIndexOfLines(File index, boolean safe, Predicate<String> filter, SimpleTaskStatus status) throws IOException {

        if (this.isRecomemendedTheRecreationOfTheLinesIndex(index)) {

        }

        return new RandomAccessFileIndex(index);

    }

    }

    public RandomAccessFileIndex createIndexOfLines(File index, boolean safe, Predicate<String> filter, SimpleTaskStatus status) throws IOException {

        long countLines = this.countLines(filter, status);

        if (countLines < 1) {

            return null;

                status.setCurValue(0);

            }

            long t1 = System.currentTimeMillis();

            int lineno = 0;

            long position = 0;

//            line_idx.set(lineno++, position);

                status.setCurValue(lineno);

            } else {

                // Use buffered reader, fast and unsafe calculate position.

                while (lineno < countLines) {

                    this.seek(position);

                    if (line == null) {

                        break;

                    }

                }

            }

            long t2 = System.currentTimeMillis();

            line_idx.setHeader(INDEX_HEADER_FILESIZE, this.raf.length());

            line_idx.setHeader(INDEX_HEADER_INDEXCREATIONCOST, t2 - t1);

            if (status != null) {

        for (int linenumber = 0; linenumber < lines_idx.size(); linenumber++) {

            long lineoffset = lines_idx.get(linenumber);

            reader.seek(lineoffset);

            String line = breader.readLine();

            if (linenumber < 100) {

                System.out.println(String.format("%6d/%d: %s", lineoffset, linenumber, line));

        for (int linenumber = lines_idx.size() - 1; linenumber >= 0; linenumber--) {

            long lineoffset = lines_idx.get(linenumber);

            reader.seek(lineoffset);

            String line = breader.readLine();

            if (linenumber < 100) {

                System.out.println(String.format("%6d/%d: %s", lineoffset, linenumber, line));

    }

    public static class MyBufferedReader extends BufferedReader {

        private Reader in;

        public MyBufferedReader(Reader in) {

            this(in, defaultCharBufferSize);

        }

        /**

         * Checks to make sure that the stream has not been closed

         */

         * reached

         * @exception IOException If an I/O error occurs

         */

        public int read() throws IOException {

            synchronized (lock) {

                ensureOpen();

         *

         * @exception IOException If an I/O error occurs

         */

        public int read(char cbuf[], int off, int len) throws IOException {

            synchronized (lock) {

                ensureOpen();

         *

         * @see java.nio.file.Files#readAllLines

         */

        public String readLine() throws IOException {

            return readLine(false);

        }

         * @exception IllegalArgumentException If <code>n</code> is negative.

         * @exception IOException If an I/O error occurs

         */

        public long skip(long n) throws IOException {

            if (n < 0L) {

                throw new IllegalArgumentException("skip value is negative");

         *

         * @exception IOException If an I/O error occurs

         */

        public boolean ready() throws IOException {

            synchronized (lock) {

                ensureOpen();

         * Tells whether this stream supports the mark() operation, which it

         * does.

         */

        public boolean markSupported() {

            return true;

        }

         * @exception IllegalArgumentException If {@code readAheadLimit < 0}

         * @exception IOException If an I/O error occurs

         */

        public void mark(int readAheadLimit) throws IOException {

            if (readAheadLimit < 0) {

                throw new IllegalArgumentException("Read-ahead limit < 0");

         * @exception IOException If the stream has never been marked, or if the

         * mark has been invalidated

         */

        public void reset() throws IOException {

            synchronized (lock) {

                ensureOpen();

            }

        }

        public void close() throws IOException {

            synchronized (lock) {

                if (in == null) {

         *

         * @since 1.8

         */

        public Stream<String> lines() {

            Iterator<String> iter = new Iterator<String>() {

                String nextLine = null;

        public boolean isSkipLf() {

            return this.skipLF;

        }

    }

}