¿Cómo eliminar saltos de línea de un archivo en Java?

¿Cómo puedo reemplazar todos los saltos de línea de una cadena en Java de tal manera que funcione en Windows y Linux (es decir, sin problemas específicos del sistema operativo de retorno de carro / avance de línea / nueva línea, etc.)?

Lo he intentado (nota readFileAsString es una función que lee un archivo de texto en una Cadena):

String text = readFileAsString("textfile.txt");
text.replace("\n", "");

Pero esto no parece funcionar.

¿Cómo se puede hacer esto?

Debe establecer textlos resultados de text.replace():

String text = readFileAsString("textfile.txt");
text = text.replace("\n", "").replace("\r", "");

Esto es necesario porque las cadenas son inmutables: las llamadas replaceno cambian la cadena original, devuelve una nueva que se ha cambiado. Si no asigna el resultado text, entonces esa nueva Cadena se pierde y se recolecta basura.

En cuanto a obtener la cadena de nueva línea para cualquier entorno, que está disponible llamando System.getProperty("line.separator").

Como se señaló en otras respuestas, su código no funciona principalmente porque String.replace(...)no cambia el objetivo String. (No puede, ¡las cadenas de Java son inmutables!) Lo que replacerealmente hace es crear y devolver un nuevo Stringobjeto con los caracteres cambiados según sea necesario. Pero tu código arroja eso String...

Aquí hay algunas posibles soluciones. Cuál es el más correcto depende de qué es exactamente lo que está tratando de hacer.

// #1
text = text.replace("\n", "");

Simplemente elimina todos los caracteres de nueva línea. Esto no hace frente a las terminaciones de línea de Windows o Mac.

// #2
text = text.replace(System.getProperty("line.separator"), "");

Elimina todos los terminadores de línea para la plataforma actual. Esto no hace frente al caso en el que intenta procesar (por ejemplo) un archivo UNIX en Windows, o viceversa.

// #3
text = text.replaceAll("\\r|\\n", "");

Elimina todos los terminadores de línea de Windows, UNIX o Mac. Sin embargo, si el archivo de entrada es texto, esto concatenará palabras; p.ej

Goodbye cruel
world.

se convierte

Goodbye cruelworld.

Por lo tanto, es posible que desee hacer esto:

// #4
text = text.replaceAll("\\r\\n|\\r|\\n", " ");

que reemplaza cada terminador de línea con un espacio. Desde Java 8 también puedes hacer esto:

// #5
text = text.replaceAll("\\R", " ");

Y si desea reemplazar varios separadores de línea con un espacio:

// #6
text = text.replaceAll("\\R+", " ");

Si desea eliminar solo los terminadores de línea que son válidos en el sistema operativo actual, puede hacer esto:

text = text.replaceAll(System.getProperty("line.separator"), "");

Si desea asegurarse de eliminar los separadores de línea, puede hacerlo así:

text = text.replaceAll("\\r|\\n", "");

O, un poco más detallado, pero menos regexy:

text = text.replaceAll("\\r", "").replaceAll("\\n", "");

Esta función normaliza todos los espacios en blanco, incluidos los saltos de línea, a espacios individuales. No es exactamente lo que pidió la pregunta original, pero es probable que haga exactamente lo que se necesita en muchos casos:

import org.apache.commons.lang3.StringUtils;

final String cleansedString = StringUtils.normalizeSpace(rawString);

Supongo que esto sería eficiente

String s;
s = "try this\n try me.";
s.replaceAll("[\\r\\n]+", "")

str = str.replaceAll("\\r\\n|\\r|\\n", " ");

Funcionó perfectamente para mí después de buscar mucho, habiendo fallado con cada otra línea.

Los saltos de línea no son iguales en windows / linux / mac. Debe usar System.getProperties con el atributo line.separator.

String text = readFileAsString("textfile.txt").replace("\n","");

.replace devuelve una nueva cadena, las cadenas en Java son inmutables.

Es posible que desee leer su archivo con un BufferedReader. Esta clase puede dividir la entrada en líneas individuales, que puede ensamblar a voluntad. La maneraBufferedReader funciona reconoce las convenciones de final de línea de los mundos de Linux, Windows y MacOS automáticamente, independientemente de la plataforma actual.

Por lo tanto:

BufferedReader br = new BufferedReader(
    new InputStreamReader("textfile.txt"));
StringBuilder sb = new StringBuilder();
for (;;) {
    String line = br.readLine();
    if (line == null)
        break;
    sb.append(line);
    sb.append(' ');   // SEE BELOW
}
String text = sb.toString();

Tenga en cuenta que readLine()no incluye el terminador de línea en la cadena devuelta. El código anterior agrega un espacio para evitar pegar la última palabra de una línea y la primera palabra de la línea siguiente.

String text = readFileAsString("textfile.txt").replaceAll("\n", "");

Aunque la definición de trim () en el sitio web de Oracle es "Devuelve una copia de la cadena, con espacios en blanco iniciales y finales omitidos".

la documentación omite decir que los nuevos caracteres de línea (al principio y al final) también se eliminarán.

En resumen String text = readFileAsString("textfile.txt").trim();, también funcionará para usted. (Comprobado con Java 6)

Me resulta extraño que (Apache) StringUtils no esté cubierto aquí todavía.

puede eliminar todas las líneas nuevas (o cualquier otra ocurrencia de una subcadena para ese asunto) de una cadena usando el .replacemétodo

StringUtils.replace(myString, "\n", "");

Esta línea reemplazará todas las líneas nuevas con la cadena vacía.

como newline es técnicamente un carácter, opcionalmente puede usar el .replaceCharsmétodo que reemplazará a los caracteres

StringUtils.replaceChars(myString, '\n', '');

Para su información, si desea reemplazar los saltos de línea simultáneos simultáneos con un solo salto de línea, puede usar

myString.trim().replaceAll("[\n]{2,}", "\n")

O reemplazar con un solo espacio

myString.trim().replaceAll("[\n]{2,}", " ")

Puede usar apache commons IOUtils para recorrer en iteración la línea y agregar cada línea a StringBuilder. Y no olvides cerrar InputStream

StringBuilder sb = new StringBuilder();
FileInputStream fin=new FileInputStream("textfile.txt");
LineIterator lt=IOUtils.lineIterator(fin, "utf-8");
while(lt.hasNext())
{
  sb.append(lt.nextLine());
}
String text = sb.toString();
IOUtils.closeQuitely(fin);

Puede usar métodos genéricos para reemplazar cualquier carácter con cualquier carácter.

public static void removeWithAnyChar(String str, char replceChar,
        char replaceWith) {
    char chrs[] = str.toCharArray();
    int i = 0;
    while (i < chrs.length) {

        if (chrs[i] == replceChar) {
            chrs[i] = replaceWith;
        }
        i++;
    }

}

org.apache.commons.lang.StringUtils # chopNewline

Intenta hacer esto:

 textValue= textValue.replaceAll("\n", "");
 textValue= textValue.replaceAll("\t", "");
 textValue= textValue.replaceAll("\\n", "");
 textValue= textValue.replaceAll("\\t", "");
 textValue= textValue.replaceAll("\r", "");
 textValue= textValue.replaceAll("\\r", "");
 textValue= textValue.replaceAll("\r\n", "");
 textValue= textValue.replaceAll("\\r\\n", "");