Tengo un archivo de texto que quiero editar usando Java. Tiene miles de líneas. Yo, básicamente, quiere iterar a través de las líneas y cambiar/editar/borrar texto. Esto tendrá que suceder muy a menudo.

De las soluciones que he visto en otros sitios, el enfoque general parece ser:

  • Abrir el archivo existente utilizando una clases bufferedreader
  • Leer cada línea, hacer modificaciones a cada línea, y agregarlo a un StringBuilder
  • Una vez que todo el texto ha sido leído y modificado, escribir el contenido de la StringBuilder a un nuevo archivo
  • Reemplazar el archivo antiguo con el nuevo archivo

Esta solución parece un poco «chapucero» para mí, sobre todo si tengo miles de líneas en mi archivo de texto.

Alguien sabe de una solución mejor?

  • Usted puede utilizar RandomAccessFile en Java para modificar el archivo sin tener que escribir de nuevo todo el archivo de nuevo. Ver información detallada a continuación publicado por mí.
InformationsquelleAutor Zakir Hemraj | 2009-05-04

11 Comentarios

  1. 30

    No he hecho esto en Java recientemente, pero la escritura de un archivo completo en la memoria parece una mala idea.

    La mejor idea que se me ocurre es abrir un archivo temporal en modo de escritura, al mismo tiempo, y para cada línea, leer, modificar si es necesario, a continuación, escribir en el archivo temporal. Al final, elimine el original y cambiar el nombre del archivo temporal.

    Si usted modificar los permisos en el sistema de archivo, probablemente también se han de eliminar y cambiar el nombre de permisos.

    • Resulta que mi respuesta fue mal; me olvidé de que RandomAccessFile no permite inserciones o deleciones. Creo que esta es la mejor respuesta.
    • Terminé usando este enfoque con clases bufferedreader y BufferedWriter.
  2. 5

    si el archivo es de sólo unos pocos miles de líneas que usted debería ser capaz de leer el archivo completo en la lectura y a convertir en una Cadena.

    Puede utilizar apache IOUtils que tiene el método como el siguiente.

    public static String readFile(String filename) throws IOException {
        File file = new File(filename);
        int len = (int) file.length();
        byte[] bytes = new byte[len];
        FileInputStream fis = null;
        try {
            fis = new FileInputStream(file);
            assert len == fis.read(bytes);
        } catch (IOException e) {
            close(fis);
            throw e;
        }
        return new String(bytes, "UTF-8");
    }
    
    public static void writeFile(String filename, String text) throws IOException {
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream(filename);
            fos.write(text.getBytes("UTF-8"));
        } catch (IOException e) {
            close(fos);
            throw e;
        }
    }
    
    public static void close(Closeable closeable) {
        try {
            closeable.close();
        } catch(IOException ignored) {
        }
    }
  3. 2

    Si el archivo es grande, es posible que desee utilizar un FileStream para la salida, pero que parece bastante como es el proceso más simple para hacer lo que estás haciendo (y sin más especificidad es decir, en qué tipos de cambios /modificaciones /eliminaciones que estamos tratando de hacer, es imposible determinar lo más complicado podría funcionar).

  4. 2

    Ninguna razón para amortiguar el archivo completo.

    Simplemente escribir cada línea como de leer, insertar líneas cuando sea necesario, eliminar líneas cuando sea necesario, reemplace las líneas cuando sea necesario.

    Fundamentalmente, no obtendrá alrededor de tener que volver a crear el archivo al por mayor, especialmente si se trata de un archivo de texto.

  5. 2

    Qué tipo de datos es? Puedes controlar el formato del archivo?

    Si el archivo contiene los pares de nombre/valor (o similar), usted podría tener algo de suerte con Propiedades, o tal vez improvisar algo mediante un archivo plano controlador JDBC.

    Alternativamente, han considerado que la no escritura de datos, tan a menudo? Operativo en una copia en memoria de su archivo debe ser relativamente trivial. Si no hay recursos externos que necesitan actualizaciones en tiempo real del archivo, entonces no hay necesidad de ir a la disco cada vez que quiera hacer una modificación. Puede ejecutar una tarea programada para escribir actualizaciones periódicas en el disco si usted está preocupado acerca de la copia de seguridad de datos.

  6. 1

    En general, no puede editar el archivo en el lugar; es, simplemente, una muy larga secuencia de caracteres, que pasa a incluir caracteres de salto de línea. Usted puede editar en el lugar si los cambios no cambiar el número de caracteres en cada línea.

  7. 1

    Aunque esta pregunta se la hace un tiempo publicado, creo que es bueno poner mi respuesta aquí.
    Creo que el mejor enfoque es utilizar FileChannel de java.nio.channels paquete en este escenario. Pero esto, sólo en caso de que usted necesita para tener un buen rendimiento! Usted necesita para obtener un FileChannel a través de un RandomAccessFile, como este:

    java.nio.channels.FileChannel channel = new java.io.RandomAccessFile("/my/fyle/path", "rw").getChannel();

    Después de esto, usted necesita una para crear un ByteBuffer donde se leerá de la FileChannel.

    este se ve algo como esto:

    
    java.nio.ByteBuffer inBuffer = java.nio.ByteBuffer.allocate(100);
    int pos = 0;
    int aux = 0;
    StringBuilder sb = new StringBuilder();
    
    while (pos != -1) {
    
        aux = channel.read(inBuffer, pos);
        pos = (aux != -1) ? pos + aux : -1;
    
        b = inBuffer.array();
        sb.delete(0, sb.length());
    
        for (int i = 0; i < b.length; ++i) {
    
             sb.append((char)b[i]);
    
        }
    
        //here you can do your stuff on sb
    
        inBuffer = ByteBuffer.allocate(100);
    
    }

    Espero que mi respuesta te ayude!

  8. 1

    Puede utilizar RandomAccessFile en Java para modificar el archivo con una condición:
    El tamaño de cada línea tiene que ser solucionado de otra manera, cuando la nueva cadena se escribe, se puede reemplazar la cadena en la línea siguiente.

    Por lo tanto, en mi ejemplo, establecer la longitud de la línea 100 y el relleno con el espacio de la cadena a la hora de crear el archivo y escribir en el archivo.

    Para el fin de permitir la actualización, es necesario establecer la longitud de la línea un poco más grande que la longitud más larga de la línea en este archivo.

    public class RandomAccessFileUtil {
    public static final long RECORD_LENGTH = 100;
    public static final String EMPTY_STRING = " ";
    public static final String CRLF = "\n";
    public static final String PATHNAME = "/home/mjiang/JM/mahtew.txt";
    /**
    *  one two three
    Text to be appended with
    five six seven
    eight nine ten
    * 
    * 
    * @param args
    * @throws IOException
    */
    public static void main(String[] args) throws IOException
    {
    String starPrefix = "Text to be appended with";
    String replacedString = "new text has been appended";
    RandomAccessFile file = new RandomAccessFile(new File(PATHNAME), "rw");
    String line = "";
    while((line = file.readLine()) != null)
    {
    if(line.startsWith(starPrefix))
    {
    file.seek(file.getFilePointer() - RECORD_LENGTH - 1);
    file.writeBytes(replacedString);
    }
    }
    }
    public static void createFile() throws IOException
    {
    RandomAccessFile file = new RandomAccessFile(new File(PATHNAME), "rw");
    String line1 = "one two three";
    String line2 = "Text to be appended with";
    String line3 = "five six seven";
    String line4 = "eight nine ten";
    file.writeBytes(paddingRight(line1));
    file.writeBytes(CRLF);
    file.writeBytes(paddingRight(line2));
    file.writeBytes(CRLF);
    file.writeBytes(paddingRight(line3));
    file.writeBytes(CRLF);
    file.writeBytes(paddingRight(line4));
    file.writeBytes(CRLF);
    file.close();
    System.out.println(String.format("File is created in [%s]", PATHNAME));
    }
    public static String paddingRight(String source)
    {
    StringBuilder result = new StringBuilder(100);
    if(source != null)
    {
    result.append(source);
    for (int i = 0; i < RECORD_LENGTH - source.length(); i++)
    {
    result.append(EMPTY_STRING);
    }
    }
    return result.toString();
    }

    }

  9. -2

    Puede cambiar el archivo txt para java ahorro de clic en «Guardar Como» para guardar *.extensión de java.

Dejar respuesta

Please enter your comment!
Please enter your name here