Leer un archivo línea por línea, en orden inverso

Esta es una vieja pregunta. También quería hacer lo mismo y después de algunas búsquedas se encontró que hay una clase en apache commons-io para lograr esto:

org.apache.commons.io.input.ReversedLinesFileReader

Creo que una buena opción para esto sería usar la clase RandomFileAccess. Hay un código de ejemplo para la retro-lectura usando esta clase en esta página. Leer bytes de esta manera es fácil, sin embargo leer cadenas podría ser un poco más difícil.

Una alternativa más simple, porque dices que estás creando un servlet para hacer esto, es usar un LinkedList para contener las últimas líneas N (donde N podría ser un parámetro servlet). Cuando el tamaño de la lista excede N, se llama removeFirst().

Desde la perspectiva de la experiencia del usuario, esta es probablemente la mejor solución. Como usted nota, las líneas más recientes son las más importantes. No estar abrumado con información también es muy importante.

Si tiene prisa y desea la solución más simple sin preocuparse demasiado por el rendimiento, le daría una oportunidad de usar un proceso externo para hacer el trabajo sucio (dado que está ejecutando su aplicación en un servidor Un*x, como cualquier persona decente haría XD)

new BufferedReader(new InputStreamReader(Runtime.getRuntime().exec("tail yourlogfile.txt -n 50 | rev").getProcess().getInputStream()))

Buena pregunta. No tengo conocimiento de ninguna implementación común de esto. Tampoco es trivial hacerlo correctamente, así que ten cuidado con lo que elijas. Debe tratar con la codificación de conjuntos de caracteres y la detección de diferentes métodos de salto de línea. Aquí está la implementación que tengo hasta ahora que funciona con archivos codificados ASCII y UTF-8, incluido un caso de prueba para UTF-8. No funciona con archivos codificados UTF-16LE o UTF-16BE.

import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.RandomAccessFile;
import java.io.Reader;
import java.io.UnsupportedEncodingException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import junit.framework.TestCase;

public class ReverseLineReader {
    private static final int BUFFER_SIZE = 8192;

    private final FileChannel channel;
    private final String encoding;
    private long filePos;
    private ByteBuffer buf;
    private int bufPos;
    private byte lastLineBreak = '\n';
    private ByteArrayOutputStream baos = new ByteArrayOutputStream();

    public ReverseLineReader(File file, String encoding) throws IOException {
        RandomAccessFile raf = new RandomAccessFile(file, "r");
        channel = raf.getChannel();
        filePos = raf.length();
        this.encoding = encoding;
    }

    public String readLine() throws IOException {
        while (true) {
            if (bufPos < 0) {
                if (filePos == 0) {
                    if (baos == null) {
                        return null;
                    }
                    String line = bufToString();
                    baos = null;
                    return line;
                }

                long start = Math.max(filePos - BUFFER_SIZE, 0);
                long end = filePos;
                long len = end - start;

                buf = channel.map(FileChannel.MapMode.READ_ONLY, start, len);
                bufPos = (int) len;
                filePos = start;
            }

            while (bufPos-- > 0) {
                byte c = buf.get(bufPos);
                if (c == '\r' || c == '\n') {
                    if (c != lastLineBreak) {
                        lastLineBreak = c;
                        continue;
                    }
                    lastLineBreak = c;
                    return bufToString();
                }
                baos.write(c);
            }
        }
    }

    private String bufToString() throws UnsupportedEncodingException {
        if (baos.size() == 0) {
            return "";
        }

        byte[] bytes = baos.toByteArray();
        for (int i = 0; i < bytes.length / 2; i++) {
            byte t = bytes[i];
            bytes[i] = bytes[bytes.length - i - 1];
            bytes[bytes.length - i - 1] = t;
        }

        baos.reset();

        return new String(bytes, encoding);
    }

    public static void main(String[] args) throws IOException {
        File file = new File("my.log");
        ReverseLineReader reader = new ReverseLineReader(file, "UTF-8");
        String line;
        while ((line = reader.readLine()) != null) {
            System.out.println(line);
        }
    }

    public static class ReverseLineReaderTest extends TestCase {
        public void test() throws IOException {
            File file = new File("utf8test.log");
            String encoding = "UTF-8";

            FileInputStream fileIn = new FileInputStream(file);
            Reader fileReader = new InputStreamReader(fileIn, encoding);
            BufferedReader bufReader = new BufferedReader(fileReader);
            List<String> lines = new ArrayList<String>();
            String line;
            while ((line = bufReader.readLine()) != null) {
                lines.add(line);
            }
            Collections.reverse(lines);

            ReverseLineReader reader = new ReverseLineReader(file, encoding);
            int pos = 0;
            while ((line = reader.readLine()) != null) {
                assertEquals(lines.get(pos++), line);
            }

            assertEquals(lines.size(), pos);
        }
    }
}

Puede usar RandomAccessFile implementa esta función, como:

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

import com.google.common.io.LineProcessor;
public class FileUtils {
/**
 * 反向读取文本文件（UTF8）,文本文件分行是通过\r\n
 * 
 * @param <T>
 * @param file
 * @param step 反向寻找的步长
 * @param lineprocessor
 * @throws IOException
 */
public static <T> T backWardsRead(File file, int step,
        LineProcessor<T> lineprocessor) throws IOException {
    RandomAccessFile rf = new RandomAccessFile(file, "r");
    long fileLen = rf.length();
    long pos = fileLen - step;
    // 寻找倒序的第一行:\r
    while (true) {
        if (pos < 0) {
            // 处理第一行
            rf.seek(0);
            lineprocessor.processLine(rf.readLine());
            return lineprocessor.getResult();
        }
        rf.seek(pos);
        char c = (char) rf.readByte();
        while (c != '\r') {
            c = (char) rf.readByte();
        }
        rf.readByte();//read '\n'
        pos = rf.getFilePointer();
        if (!lineprocessor.processLine(rf.readLine())) {
            return lineprocessor.getResult();
        }
        pos -= step;
    }

  }

Uso:

       FileUtils.backWardsRead(new File("H:/usersfavs.csv"), 40,
            new LineProcessor<Void>() {
                                   //TODO  implements method
                                   .......
            });

La solución más simple es leer el archivo en orden hacia adelante, usando un ArrayList<Long> para mantener el desplazamiento de bytes de cada registro de registro. Tendrá que usar algo como Jakarta Commons CountingInputStream para recuperar la posición de cada registro, y tendrá que organizar cuidadosamente sus búferes para asegurarse de que devuelve los valores adecuados:

FileInputStream fis = // .. logfile
BufferedInputStream bis = new BufferedInputStream(fis);
CountingInputStream cis = new CountingInputSteam(bis);
InputStreamReader isr = new InputStreamReader(cis, "UTF-8");

Y probablemente no podrá usar un BufferedReader, porque intentará leer por adelantado y perder la cuenta (pero leyendo un carácter a la vez no será un problema de rendimiento, porque se está almacenando en búfer más bajo en la pila).

Para escribir el archivo, itera la lista hacia atrás y usa un RandomAccessFile. Hay un pequeño truco: para decodificar correctamente los bytes (suponiendo una codificación multi-byte), tendrá que leer los bytes correspondientes a una entrada, y luego aplicar una decodificación a la misma. La lista, sin embargo, le dará la posición inicial y final de los bytes.

Un gran beneficio de este enfoque, versus simplemente al imprimir las líneas en orden inverso, no dañará los mensajes de registro multilínea (como las excepciones).

import java.io.File;
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
/**
 * Inside of C:\\temp\\vaquar.txt we have following content
 * vaquar khan is working into Citi He is good good programmer programmer trust me
 * @author [email protected]
 *
 */

public class ReadFileAndDisplayResultsinReverse {
    public static void main(String[] args) {
        try {
            // read data from file
            Object[] wordList = ReadFile();
            System.out.println("File data=" + wordList);
            //
            Set<String> uniquWordList = null;
            for (Object text : wordList) {
                System.out.println((String) text);
                List<String> tokens = Arrays.asList(text.toString().split("\\s+"));
                System.out.println("tokens" + tokens);
                uniquWordList = new HashSet<String>(tokens);
                // If multiple line then code into same loop
            }
            System.out.println("uniquWordList" + uniquWordList);

            Comparator<String> wordComp= new Comparator<String>() {

                @Override
                public int compare(String o1, String o2) {
                    if(o1==null && o2 ==null) return 0;
                    if(o1==null ) return o2.length()-0;
                    if(o2 ==null) return o1.length()-0;
                    //
                    return o2.length()-o1.length();
                }
            };
            List<String> fs=new ArrayList<String>(uniquWordList);
            Collections.sort(fs,wordComp);

            System.out.println("uniquWordList" + fs);

        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    static Object[] ReadFile() throws IOException {
        List<String> list = Files.readAllLines(new File("C:\\temp\\vaquar.txt").toPath(), Charset.defaultCharset());
        return list.toArray();
    }


}

Salida:

[Vaquar khan está trabajando en Citi Él es bueno buen programador programador confía en mí tokens [vaquar, khan, is, working, into, Citi, He, is, good, good, programmer, programmer, trust, me]

UniquWordList [trust, vaquar,programmer, is, good, into, khan, me, working, Citi, He]

UniquWordList [programmer, working,vaquar, trust, good, into, khan, Citi, is, me, He]

Si desea ordenar de A a Z, escriba un comparador más

Solución concisa usando Java 7 Autoclosables y Java 8 Streams:

try (Stream<String> logStream = Files.lines(Paths.get("C:\\logfile.log"))) {
   logStream
      .sorted(Comparator.reverseOrder())
      .limit(10) // last 10 lines
      .forEach(System.out::println);
}

Big drawback: solo funciona cuando las líneas están estrictamente en orden natural, como los archivos de registro con marcas de tiempo pero sin excepciones