java - online - Encuentra una línea en un archivo y quítalo

leer.class java

Question

Estoy buscando un pequeño fragmento de código que encuentre una línea en el archivo y elimine esa línea (no el contenido sino la línea) pero no pudo encontrar. Entonces, por ejemplo, tengo en un archivo siguiente:

myFile.txt :

aaa
bbb
ccc
ddd

Necesito tener una función como esta: public void removeLine(String lineContent) , y si paso removeLine("bbb") , obtengo un archivo como este:

myFile.txt:

aaa
ccc
ddd

Answer 1

Aquí está la clase completa. En el siguiente archivo "somelocation" se refiere a la ruta real del archivo.

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class FileProcess
{
public static void main(String[] args) throws IOException
{
File inputFile = new File("C://somelocation//Demographics.txt");
File tempFile = new File("C://somelocation//Demographics_report.txt");
BufferedReader reader = new BufferedReader(new FileReader(inputFile));
BufferedWriter writer = new BufferedWriter(new FileWriter(tempFile));
String currentLine;
while((currentLine = reader.readLine()) != null) {
if(null!=currentLine && !currentLine.equalsIgnoreCase("BBB")){
writer.write(currentLine + System.getProperty("line.separator"));
}
}
writer.close();
reader.close();
boolean successful = tempFile.renameTo(inputFile);
System.out.println(successful);
}
}

Answer 2

Aqui tienes. Esta solución utiliza un DataInputStream para buscar la posición de la cadena que desea reemplazar y utiliza un FileChannel para reemplazar el texto en esa posición exacta. Solo reemplaza la primera aparición de la cadena que encuentra. Esta solución no almacena una copia del archivo completo en algún lugar , (ya sea la RAM o un archivo temporal), simplemente edita la parte del archivo que encuentra.

public static long scanForString(String text, File file) throws IOException {
if (text.isEmpty())
return file.exists() ? 0 : -1;
// First of all, get a byte array off of this string:
byte[] bytes = text.getBytes(/* StandardCharsets.your_charset */);
// Next, search the file for the byte array.
try (DataInputStream dis = new DataInputStream(new FileInputStream(file))) {
List<Integer> matches = new LinkedList<>();
for (long pos = 0; pos < file.length(); pos++) {
byte bite = dis.readByte();
for (int i = 0; i < matches.size(); i++) {
Integer m = matches.get(i);
if (bytes[m] != bite)
matches.remove(i--);
else if (++m == bytes.length)
return pos - m + 1;
else
matches.set(i, m);
}
if (bytes[0] == bite)
matches.add(1);
}
}
return -1;
}
public static void replaceText(String text, String replacement, File file) throws IOException {
// Open a FileChannel with writing ability. You don''t really need the read
// ability for this specific case, but there it is in case you need it for
// something else.
try (FileChannel channel = FileChannel.open(file.toPath(), StandardOpenOption.WRITE, StandardOpenOption.READ)) {
long scanForString = scanForString(text, file);
if (scanForString == -1) {
System.out.println("String not found.");
return;
}
channel.position(scanForString);
channel.write(ByteBuffer.wrap(replacement.getBytes(/* StandardCharsets.your_charset */)));
}
}

Ejemplo

Entrada: ABCDEFGHIJKLMNOPQRSTUVWXYZ

Método de llamada:

replaceText("QRS", "000", new File("path/to/file");

Archivo resultante: ABCDEFGHIJKLMNOP000TUVWXYZ

Answer 3

Desea hacer algo como lo siguiente:

• Abra el archivo anterior para leer
• Abra un nuevo archivo (temporal) para escribir
• Itera sobre las líneas en el archivo anterior (probablemente usando un BufferedReader )
  • Para cada línea, verifique si coincide con lo que se supone que debe eliminar
  • Si coincide, no hagas nada
  • Si no coincide, escríbalo en el archivo temporal
• Cuando termine, cierre ambos archivos
• Eliminar el archivo anterior
• Cambie el nombre del archivo temporal por el nombre del archivo original

(No escribiré el código actual, ya que esto parece una tarea, pero no dude en publicar otras preguntas en bits específicos con los que tenga problemas)

Answer 4

Entonces, cada vez que escucho que alguien menciona que quieren filtrar el texto, inmediatamente pienso en ir a Streams (principalmente porque hay un método llamado filter que filtra exactamente como lo necesita). Otra respuesta menciona el uso de Stream s con la biblioteca Apache commons-io, pero pensé que valdría la pena mostrar cómo esto se puede hacer en Java 8. Aquí está la forma más simple:

public void removeLine(String lineContent) throws IOException
{
File file = new File("myFile.txt");
List<String> out = Files.lines(file.toPath())
.filter(line -> !line.contains(lineContent))
.collect(Collectors.toList());
Files.write(file.toPath(), out, StandardOpenOption.WRITE, StandardOpenOption.TRUNCATE_EXISTING);
}

Creo que no hay mucho que explicar allí, básicamente Files.lines obtiene un Stream<String> de las líneas del archivo, filter elimina las líneas que no queremos, luego collect pone todas las líneas del nuevo archivo en una List . Luego escribimos la lista sobre la parte superior del archivo existente con Files.write , usando la opción adicional TRUNCATE para que se reemplacen los contenidos anteriores del archivo.

Por supuesto, este enfoque tiene la desventaja de cargar cada línea en la memoria, ya que todas se almacenan en una List antes de volver a escribirse. Si quisiéramos simplemente modificar sin almacenar, necesitaríamos usar alguna forma de OutputStream para escribir cada nueva línea en un archivo a medida que pasa a través de la secuencia, así:

public void removeLine(String lineContent) throws IOException
{
File file = new File("myFile.txt");
File temp = new File("_temp_");
PrintWriter out = new PrintWriter(new FileWriter(temp));
Files.lines(file.toPath())
.filter(line -> !line.contains(lineContent))
.forEach(out::println);
out.flush();
out.close();
temp.renameTo(file);
}

No se ha cambiado mucho en este ejemplo. Básicamente, en lugar de usar collect para reunir los contenidos del archivo en la memoria, usamos forEach para que cada línea que lo hace a través del filter se envíe al PrintWriter y se escriba en el archivo inmediatamente y no se almacene. Tenemos que guardarlo en un archivo temporal, porque no podemos sobreescribir el archivo existente al mismo tiempo que lo estamos leyendo, así que al final, cambiamos el nombre del archivo temporal para reemplazar el archivo existente.

Answer 5

Esta solución puede no ser óptima o bonita, pero funciona. Lee en un archivo de entrada línea por línea, escribiendo cada línea en un archivo de salida temporal. Cada vez que encuentra una línea que coincide con lo que está buscando, omite escribirlo. Luego cambia el nombre del archivo de salida. He omitido el manejo de errores, el cierre de lectores / escritores, etc. del ejemplo. También asumo que no hay espacios en blanco iniciales o finales en la línea que está buscando. Cambie el código alrededor de recortar () según sea necesario para que pueda encontrar una coincidencia.

File inputFile = new File("myFile.txt");
File tempFile = new File("myTempFile.txt");
BufferedReader reader = new BufferedReader(new FileReader(inputFile));
BufferedWriter writer = new BufferedWriter(new FileWriter(tempFile));
String lineToRemove = "bbb";
String currentLine;
while((currentLine = reader.readLine()) != null) {
// trim newline when comparing with lineToRemove
String trimmedLine = currentLine.trim();
if(trimmedLine.equals(lineToRemove)) continue;
writer.write(currentLine + System.getProperty("line.separator"));
}
writer.close();
reader.close();
boolean successful = tempFile.renameTo(inputFile);

Answer 6

Esta solución requiere que la biblioteca Apache Commons IO se agregue a la ruta de compilación. Funciona leyendo el archivo completo y escribiendo cada línea hacia atrás, pero solo si el término de búsqueda no está contenido.

public static void removeLineFromFile(File targetFile, String searchTerm)
throws IOException
{
StringBuffer fileContents = new StringBuffer(
FileUtils.readFileToString(targetFile));
String[] fileContentLines = fileContents.toString().split(
System.lineSeparator());
emptyFile(targetFile);
fileContents = new StringBuffer();
for (int fileContentLinesIndex = 0; fileContentLinesIndex < fileContentLines.length; fileContentLinesIndex++)
{
if (fileContentLines[fileContentLinesIndex].contains(searchTerm))
{
continue;
}
fileContents.append(fileContentLines[fileContentLinesIndex] + System.lineSeparator());
}
FileUtils.writeStringToFile(targetFile, fileContents.toString().trim());
}
private static void emptyFile(File targetFile) throws FileNotFoundException,
IOException
{
RandomAccessFile randomAccessFile = new RandomAccessFile(targetFile, "rw");
randomAccessFile.setLength(0);
randomAccessFile.close();
}

Answer 7

Prueba esto:

public static void main(String[] args) throws IOException {
File file = new File("file.csv");
CSVReader csvFileReader = new CSVReader(new FileReader(file));
List<String[]> list = csvFileReader.readAll();
for (int i = 0; i < list.size(); i++) {
String[] filter = list.get(i);
if (filter[0].equalsIgnoreCase("bbb")) {
list.remove(i);
}
}
csvFileReader.close();
CSVWriter csvOutput = new CSVWriter(new FileWriter(file));
csvOutput.writeAll(list);
csvOutput.flush();
csvOutput.close();
}

Answer 8

Refactoré la solución que tenía Narek para crear (según yo) un código un poco más eficiente y fácil de entender. Utilicé la Gestión automática de recursos incorporada, una característica reciente en Java y utilicé una clase de escáner que, según yo, es más fácil de comprender y usar.

Aquí está el código con comentarios editados:

public class RemoveLineInFile {
private static File file;
public static void main(String[] args) {
//create a new File
file = new File("hello.txt");
//takes in String that you want to get rid off
removeLineFromFile("Hello");
}
public static void removeLineFromFile(String lineToRemove) {
//if file does not exist, a file is created
if (!file.exists()) {
try {
file.createNewFile();
} catch (IOException e) {
System.out.println("File "+file.getName()+" not created successfully");
}
}
// Construct the new temporary file that will later be renamed to the original
// filename.
File tempFile = new File(file.getAbsolutePath() + ".tmp");
//Two Embedded Automatic Resource Managers used
// to effectivey handle IO Responses
try(Scanner scanner = new Scanner(file)) {
try (PrintWriter pw = new PrintWriter(new FileWriter(tempFile))) {
//a declaration of a String Line Which Will Be assigned Later
String line;
// Read from the original file and write to the new
// unless content matches data to be removed.
while (scanner.hasNextLine()) {
line = scanner.nextLine();
if (!line.trim().equals(lineToRemove)) {
pw.println(line);
pw.flush();
}
}
// Delete the original file
if (!file.delete()) {
System.out.println("Could not delete file");
return;
}
// Rename the new file to the filename the original file had.
if (!tempFile.renameTo(file))
System.out.println("Could not rename file");
}
}
catch (IOException e)
{
System.out.println("IO Exception Occurred");
}
}
}

Answer 9

Una vieja pregunta, pero una manera fácil es:

• Iterar a través de un archivo, agregando cada línea a una nueva lista de matriz
• itere a través de la matriz, encuentre la Cadena correspondiente, luego llame al método remove.
• iterar nuevamente a través de la matriz, imprimiendo cada línea en el archivo, boolean para append debe ser falso, lo que básicamente reemplaza el archivo

Answer 10

Usando apache commons-io y Java 8 puede usar

 List<String> lines = FileUtils.readLines(file);
List<String> updatedLines = lines.stream().filter(s -> !s.contains(searchString)).collect(Collectors.toList());
FileUtils.writeLines(file, updatedLines, false);

Answer 11

 public static void deleteLine() throws IOException {
RandomAccessFile file = new RandomAccessFile("me.txt", "rw");
String delete;
String task="";
byte []tasking;
while ((delete = file.readLine()) != null) {
if (delete.startsWith("BAD")) {
continue;
}
task+=delete+"/n";
}
System.out.println(task);
BufferedWriter writer = new BufferedWriter(new FileWriter("me.txt"));
writer.write(task);
file.close();
writer.close();
}

Answer 12

 public void removeLineFromFile(String file, String lineToRemove) {
try {
File inFile = new File(file);
if (!inFile.isFile()) {
System.out.println("Parameter is not an existing file");
return;
}
//Construct the new file that will later be renamed to the original filename.
File tempFile = new File(inFile.getAbsolutePath() + ".tmp");
BufferedReader br = new BufferedReader(new FileReader(file));
PrintWriter pw = new PrintWriter(new FileWriter(tempFile));
String line = null;
//Read from the original file and write to the new
//unless content matches data to be removed.
while ((line = br.readLine()) != null) {
if (!line.trim().equals(lineToRemove)) {
pw.println(line);
pw.flush();
}
}
pw.close();
br.close();
//Delete the original file
if (!inFile.delete()) {
System.out.println("Could not delete file");
return;
}
//Rename the new file to the filename the original file had.
if (!tempFile.renameTo(inFile))
System.out.println("Could not rename file");
}
catch (FileNotFoundException ex) {
ex.printStackTrace();
}
catch (IOException ex) {
ex.printStackTrace();
}
}

Esto lo he encontrado en internet.

Answer 13

package com.ncs.cache;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.File;
import java.io.FileWriter;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.PrintWriter;
public class FileUtil {
public void removeLineFromFile(String file, String lineToRemove) {
try {
File inFile = new File(file);
if (!inFile.isFile()) {
System.out.println("Parameter is not an existing file");
return;
}
// Construct the new file that will later be renamed to the original
// filename.
File tempFile = new File(inFile.getAbsolutePath() + ".tmp");
BufferedReader br = new BufferedReader(new FileReader(file));
PrintWriter pw = new PrintWriter(new FileWriter(tempFile));
String line = null;
// Read from the original file and write to the new
// unless content matches data to be removed.
while ((line = br.readLine()) != null) {
if (!line.trim().equals(lineToRemove)) {
pw.println(line);
pw.flush();
}
}
pw.close();
br.close();
// Delete the original file
if (!inFile.delete()) {
System.out.println("Could not delete file");
return;
}
// Rename the new file to the filename the original file had.
if (!tempFile.renameTo(inFile))
System.out.println("Could not rename file");
} catch (FileNotFoundException ex) {
ex.printStackTrace();
} catch (IOException ex) {
ex.printStackTrace();
}
}
public static void main(String[] args) {
FileUtil util = new FileUtil();
util.removeLineFromFile("test.txt", "bbbbb");
}
}

src: http://www.javadb.com/remove-a-line-from-a-text-file/

Answer 14

public static void deleteLine(String line, String filePath) {
File file = new File(filePath);
File file2 = new File(file.getParent() + "//temp" + file.getName());
PrintWriter pw = null;
Scanner read = null;
FileInputStream fis = null;
FileOutputStream fos = null;
FileChannel src = null;
FileChannel dest = null;
try {
pw = new PrintWriter(file2);
read = new Scanner(file);
while (read.hasNextLine()) {
String currline = read.nextLine();
if (line.equalsIgnoreCase(currline)) {
continue;
} else {
pw.println(currline);
}
}
pw.flush();
fis = new FileInputStream(file2);
src = fis.getChannel();
fos = new FileOutputStream(file);
dest = fos.getChannel();
dest.transferFrom(src, 0, src.size());
} catch (IOException e) {
e.printStackTrace();
} finally {
pw.close();
read.close();
try {
fis.close();
fos.close();
src.close();
dest.close();
} catch (IOException e) {
e.printStackTrace();
}
if (file2.delete()) {
System.out.println("File is deleted");
} else {
System.out.println("Error occured! File: " + file2.getName() + " is not deleted!");
}
}
}