Como remover quebras de linha de um arquivo em Java?

Como posso substituir todas as quebras de linha de uma string em Java de forma que funcione no Windows e Linux (ou seja, sem problemas específicos do SO de retorno de carro / avanço de linha / nova linha etc.)?

Eu tentei (note readFileAsString é uma função que lê um arquivo de texto em uma String):

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

mas isso não parece funcionar.

Como isso pode ser feito?

Você precisa definir textos resultados de text.replace():

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

Isso é necessário porque Strings são imutáveis ​​- a chamada replacenão altera a String original, retorna uma nova que foi alterada. Se você não atribuir o resultado text, essa nova String será perdida e o lixo coletado.

Quanto à obtenção da nova linha String para qualquer ambiente - disponível por chamada System.getProperty("line.separator").

Conforme observado em outras respostas, seu código não está funcionando principalmente porque String.replace(...)não altera o destino String. (Não pode - as seqüências Java são imutáveis!) O que replacerealmente faz é criar e retornar um novo Stringobjeto com os caracteres alterados conforme necessário. Mas seu código joga fora isso String...

Aqui estão algumas soluções possíveis. Qual é o mais correto depende do que exatamente você está tentando fazer.

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

Simplesmente remove todos os caracteres da nova linha. Isso não lida com as terminações de linha do Windows ou Mac.

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

Remove todos os terminadores de linha da plataforma atual. Isso não lida com o caso em que você está tentando processar (por exemplo) um arquivo UNIX no Windows ou vice-versa.

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

Remove todos os terminadores de linha do Windows, UNIX ou Mac. No entanto, se o arquivo de entrada for texto, isso concatenará as palavras; por exemplo

Goodbye cruel
world.

torna-se

Goodbye cruelworld.

Então você pode realmente querer fazer isso:

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

que substitui cada terminador de linha por um espaço. Desde o Java 8, você também pode fazer isso:

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

E se você deseja substituir vários separadores de linhas por um espaço:

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

Se você deseja remover apenas os terminadores de linha válidos no sistema operacional atual, faça o seguinte:

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

Se você deseja remover os separadores de linha, faça o seguinte:

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

Ou, um pouco mais detalhado, mas menos regular:

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

Essa função normaliza todo o espaço em branco, incluindo quebras de linha, em espaços únicos. Não é exatamente o que a pergunta original solicitou, mas provavelmente faz exatamente o que é necessário em muitos casos:

import org.apache.commons.lang3.StringUtils;

final String cleansedString = StringUtils.normalizeSpace(rawString);

Isso seria eficiente, eu acho

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

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

Funcionou perfeitamente para mim depois de pesquisar muito, tendo falhado em todas as outras linhas.

Quebras de linha não são as mesmas em windows / linux / mac. Você deve usar System.getProperties com o atributo line.separator.

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

.replace retorna uma nova string, as strings em Java são imutáveis.

Você pode querer ler seu arquivo com um BufferedReader. Esta classe pode dividir a entrada em linhas individuais, que você pode montar à vontade. A maneira como BufferedReaderopera reconhece automaticamente as convenções de final de linha dos mundos Linux, Windows e MacOS, independentemente da plataforma atual.

Conseqüentemente:

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();

Observe que readLine()não inclui o terminador de linha na string retornada. O código acima acrescenta um espaço para evitar colar a última palavra de uma linha e a primeira palavra da próxima linha.

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

Mesmo que a definição de trim () no site da Oracle seja "Retorna uma cópia da string, com espaços em branco à esquerda e à direita omitidos".

a documentação omite que novos caracteres de linha (à esquerda e à direita) também serão removidos.

Em suma String text = readFileAsString("textfile.txt").trim();, também funcionará para você. (Verificado com Java 6)

Acho estranho que o (Apache) StringUtils ainda não tenha sido abordado aqui.

você pode remover todas as novas linhas (ou quaisquer outras ocorrências de uma substring) de uma sequência usando o .replacemétodo

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

Esta linha substituirá todas as novas linhas pela sequência vazia.

como a nova linha é tecnicamente um caractere, você pode, opcionalmente, usar o .replaceCharsmétodo que substituirá os caracteres

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

Para sua informação, se você quiser substituir quebras de linha muti simultâneas por quebra de linha única, poderá usar

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

Ou substitua por um único espaço

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

Você pode usar IOUtils do apache commons para percorrer a linha e anexar cada linha ao StringBuilder. E não se esqueça de fechar o 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);

Você pode usar métodos genéricos para substituir qualquer caractere por qualquer caractere.

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

Tente fazer isso:

 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", "");