Ich benutze die Redewendung unten schon seit einiger Zeit. Und es scheint am weitesten verbreitet zu sein, zumindest auf den Websites, die ich besucht habe.

Gibt es eine bessere / andere Möglichkeit, eine Datei in Java in eine Zeichenfolge einzulesen?

private String readFile(String file) throws IOException {
    BufferedReader reader = new BufferedReader(new FileReader (file));
    String         line = null;
    StringBuilder  stringBuilder = new StringBuilder();
    String         ls = System.getProperty("line.separator");

    try {
        while((line = reader.readLine()) != null) {
            stringBuilder.append(line);
            stringBuilder.append(ls);
        }

        return stringBuilder.toString();
    } finally {
        reader.close();
    }
}

Lesen Sie den gesamten Text aus einer Datei

Java 11 hat die Methode readString () hinzugefügt , um kleine Dateien als Zeilenabschlusszeichen zu lesen String:

String content = Files.readString(path, StandardCharsets.US_ASCII);

Für Versionen zwischen Java 7 und 11 ist hier eine kompakte, robuste Sprache, die in einer Dienstprogrammmethode zusammengefasst ist:

static String readFile(String path, Charset encoding) 
  throws IOException 
{
  byte[] encoded = Files.readAllBytes(Paths.get(path));
  return new String(encoded, encoding);
}

Lesen Sie Textzeilen aus einer Datei

Java 7 hat eine bequeme Methode zum Lesen einer Datei als Textzeilen hinzugefügt , die als dargestellt wird List<String>. Dieser Ansatz ist "verlustbehaftet", da die Zeilentrennzeichen vom Ende jeder Zeile entfernt werden.

List<String> lines = Files.readAllLines(Paths.get(path), encoding);

Java 8 fügte die Files.lines()Methode hinzu , um a zu erzeugen Stream<String>. Auch diese Methode ist verlustbehaftet, da Zeilentrennzeichen entfernt werden. Wenn IOExceptionbeim Lesen der Datei ein auftritt , wird es in ein eingeschlossen UncheckedIOException, da Streamkeine Lambdas akzeptiert werden, die geprüfte Ausnahmen auslösen.

try (Stream<String> lines = Files.lines(path, encoding)) {
  lines.forEach(System.out::println);
}

Dies Streamerfordert einen close()Anruf; Dies ist in der API schlecht dokumentiert, und ich vermute, dass viele Leute nicht einmal bemerken, dass Streames eine gibtclose() Methode gibt. Stellen Sie sicher, dass Sie wie gezeigt einen ARM-Block verwenden.

Wenn Sie mit einer anderen Quelle als einer Datei arbeiten, können Sie die lines()Methode in verwendenBufferedReader stattdessen verwenden.

Speicherauslastung

Die erste Methode, bei der Zeilenumbrüche beibehalten werden, kann vorübergehend Speicherplatz benötigen, der um ein Vielfaches größer ist als die Datei, da für kurze Zeit der Inhalt der Rohdatei (ein Byte-Array) und die decodierten Zeichen (von denen jedes 16 Bit beträgt, selbst wenn es codiert ist) als 8 Bits in der Datei) befinden sich gleichzeitig im Speicher. Es ist am sichersten, auf Dateien anzuwenden, von denen Sie wissen, dass sie im Verhältnis zum verfügbaren Speicher klein sind.

Die zweite Methode, das Lesen von Zeilen, ist normalerweise speichereffizienter, da der Eingabebytepuffer zum Decodieren nicht die gesamte Datei enthalten muss. Es ist jedoch immer noch nicht für Dateien geeignet, die im Verhältnis zum verfügbaren Speicher sehr groß sind.

Zum Lesen großer Dateien benötigen Sie ein anderes Design für Ihr Programm, das einen Textblock aus einem Stream liest, verarbeitet und dann zum nächsten übergeht, wobei derselbe Speicherblock mit fester Größe wiederverwendet wird. Hier hängt "groß" von den Computerspezifikationen ab. Heutzutage kann dieser Schwellenwert viele Gigabyte RAM betragen. Die dritte Methode, a zu verwenden, Stream<String>ist eine Möglichkeit, dies zu tun, wenn Ihre eingegebenen "Datensätze" zufällig einzelne Zeilen sind. (Mit der readLine()Methode vonBufferedReader ist das prozedurale Äquivalent zu diesem Ansatz.)

Zeichenkodierung

Eine Sache, die im Beispiel im ursprünglichen Beitrag fehlt, ist die Zeichenkodierung. Es gibt einige Sonderfälle, in denen die Plattform standardmäßig Ihren Wünschen entspricht, diese sind jedoch selten und Sie sollten in der Lage sein, Ihre Wahl zu rechtfertigen.

Die StandardCharsetsKlasse definiert einige Konstanten für die Codierungen, die für alle Java-Laufzeiten erforderlich sind:

String content = readFile("test.txt", StandardCharsets.UTF_8);

Die Plattformvorgabe ist in der CharsetKlasse selbst verfügbar :

String content = readFile("test.txt", Charset.defaultCharset());

Hinweis: Diese Antwort ersetzt weitgehend meine Java 6-Version. Das Dienstprogramm von Java 7 vereinfacht den Code sicher, und die alte Antwort, die einen zugeordneten Bytepuffer verwendete, verhinderte, dass die gelesene Datei gelöscht wurde, bis der zugeordnete Puffer mit Müll gesammelt wurde. Sie können die alte Version über den Link "Bearbeitet" zu dieser Antwort anzeigen.

Wenn Sie bereit sind, eine externe Bibliothek zu verwenden, lesen Sie Apache Commons IO (200 KB JAR). Es enthält eine org.apache.commons.io.FileUtils.readFileToString()Methode, mit der Sie ein Ganzes mit einer Codezeile Filein eine lesen können String.

Beispiel:

import java.io.*;
import java.nio.charset.*;
import org.apache.commons.io.*;

public String readFile() throws IOException {
    File file = new File("data.txt");
    return FileUtils.readFileToString(file, StandardCharsets.UTF_8);
}

Eine sehr schlanke Lösung basierend auf Scanner:

Scanner scanner = new Scanner( new File("poem.txt") );
String text = scanner.useDelimiter("\\A").next();
scanner.close(); // Put this call in a finally block

Oder wenn Sie den Zeichensatz festlegen möchten:

Scanner scanner = new Scanner( new File("poem.txt"), "UTF-8" );
String text = scanner.useDelimiter("\\A").next();
scanner.close(); // Put this call in a finally block

Oder mit einem Try-with-Resources- Block, der scanner.close()Sie auffordert:

try (Scanner scanner = new Scanner( new File("poem.txt"), "UTF-8" )) {
    String text = scanner.useDelimiter("\\A").next();
}

Denken Sie daran, dass der ScannerKonstruktor ein werfen kann IOException. Und vergessen Sie nicht , zu importieren java.ioundjava.util .

Quelle: Pat Niemeyers Blog

import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;

String content = new String(Files.readAllBytes(Paths.get("readMe.txt")), StandardCharsets.UTF_8);

seit java 7 kannst du es so machen.

Wenn Sie nach einer Alternative suchen, an der keine Bibliothek eines Drittanbieters beteiligt ist (z. B. Commons I / O ), können Sie die Scannerklasse verwenden :

private String readFile(String pathname) throws IOException {

    File file = new File(pathname);
    StringBuilder fileContents = new StringBuilder((int)file.length());        

    try (Scanner scanner = new Scanner(file)) {
        while(scanner.hasNextLine()) {
            fileContents.append(scanner.nextLine() + System.lineSeparator());
        }
        return fileContents.toString();
    }
}

Guave hat eine ähnliche Methode wie Commons IOUtils, die Willi aus Rohr erwähnt hat:

import com.google.common.base.Charsets;
import com.google.common.io.Files;

// ...

String text = Files.toString(new File(path), Charsets.UTF_8);

EDIT by PiggyPiglet
Files#toString ist veraltet und muss im Oktober 2019 entfernt werden. Verwenden Sie stattdessen Files.asCharSource(new File(path), StandardCharsets.UTF_8).read();

EDIT von Oscar Reyes

Dies ist der (vereinfachte) zugrunde liegende Code in der zitierten Bibliothek:

InputStream in = new FileInputStream(file);
byte[] b  = new byte[file.length()];
int len = b.length;
int total = 0;

while (total < len) {
  int result = in.read(b, total, len - total);
  if (result == -1) {
    break;
  }
  total += result;
}

return new String( b , Charsets.UTF_8 );

Bearbeiten (von Jonik): Das Obige stimmt nicht mit dem Quellcode der neuesten Guava-Versionen überein. Die aktuelle Quelle finden Sie in den Klassen Dateien , CharStreams , ByteSource und CharSource im Paket com.google.common.io .

import java.nio.file.Files;

....... .......

 String readFile(String filename) {
            File f = new File(filename);
            try {
                byte[] bytes = Files.readAllBytes(f.toPath());
                return new String(bytes,"UTF-8");
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return "";
    }

Wenn Sie eine Zeichenfolgenverarbeitung (Parallelverarbeitung) benötigen, verfügt Java 8 über die großartige Stream-API.

String result = Files.lines(Paths.get("file.txt"))
                    .parallel() // for parallel processing 
                    .map(String::trim) // to change line   
                    .filter(line -> line.length() > 2) // to filter some lines by a predicate                        
                    .collect(Collectors.joining()); // to join lines

Weitere Beispiele finden Sie in JDK-Beispielen sample/lambda/BulkDataOperations, die von der Oracle Java SE 8-Downloadseite heruntergeladen werden können

Ein weiteres Beispiel für einen Einzeiler

String out = String.join("\n", Files.readAllLines(Paths.get("file.txt")));

Dieser Code normalisiert Zeilenumbrüche, die möglicherweise das sind, was Sie wirklich tun möchten oder nicht.

Hier ist eine Alternative, die das nicht tut und die (IMO) einfacher zu verstehen ist als der NIO-Code (obwohl er immer noch verwendet wird java.nio.charset.Charset):

public static String readFile(String file, String csName)
            throws IOException {
    Charset cs = Charset.forName(csName);
    return readFile(file, cs);
}

public static String readFile(String file, Charset cs)
            throws IOException {
    // No real need to close the BufferedReader/InputStreamReader
    // as they're only wrapping the stream
    FileInputStream stream = new FileInputStream(file);
    try {
        Reader reader = new BufferedReader(new InputStreamReader(stream, cs));
        StringBuilder builder = new StringBuilder();
        char[] buffer = new char[8192];
        int read;
        while ((read = reader.read(buffer, 0, buffer.length)) > 0) {
            builder.append(buffer, 0, read);
        }
        return builder.toString();
    } finally {
        // Potential issue here: if this throws an IOException,
        // it will mask any others. Normally I'd use a utility
        // method which would log exceptions and swallow them
        stream.close();
    }        
}

Sammelte alle möglichen Möglichkeiten, um die Datei als Zeichenfolge von der Festplatte oder vom Netzwerk zu lesen.

• Guave: Google benutzt Klassen Resources,Files

  static Charset charset = com.google.common.base.Charsets.UTF_8;
  public static String guava_ServerFile( URL url ) throws IOException {
      return Resources.toString( url, charset );
  }
  public static String guava_DiskFile( File file ) throws IOException {
      return Files.toString( file, charset );
  }

• APACHE - GEMEINSAME E / A mit den Klassen IOUtils, FileUtils

  static Charset encoding = org.apache.commons.io.Charsets.UTF_8;
  public static String commons_IOUtils( URL url ) throws IOException {
      java.io.InputStream in = url.openStream();
      try {
          return IOUtils.toString( in, encoding );
      } finally {
          IOUtils.closeQuietly(in);
      }
  }
  public static String commons_FileUtils( File file ) throws IOException {
      return FileUtils.readFileToString( file, encoding );
      /*List<String> lines = FileUtils.readLines( fileName, encoding );
      return lines.stream().collect( Collectors.joining("\n") );*/
  }

• Java 8 BufferReader mit Stream API

  public static String streamURL_Buffer( URL url ) throws IOException {
      java.io.InputStream source = url.openStream();
      BufferedReader reader = new BufferedReader( new InputStreamReader( source ) );
      //List<String> lines = reader.lines().collect( Collectors.toList() );
      return reader.lines().collect( Collectors.joining( System.lineSeparator() ) );
  }
  public static String streamFile_Buffer( File file ) throws IOException {
      BufferedReader reader = new BufferedReader( new FileReader( file ) );
      return reader.lines().collect(Collectors.joining(System.lineSeparator()));
  }

• Scannerklasse mit Regex \A. Dies entspricht dem Beginn der Eingabe.

  static String charsetName = java.nio.charset.StandardCharsets.UTF_8.toString();
  public static String streamURL_Scanner( URL url ) throws IOException {
      java.io.InputStream source = url.openStream();
      Scanner scanner = new Scanner(source, charsetName).useDelimiter("\\A");
      return scanner.hasNext() ? scanner.next() : "";
  }
  public static String streamFile_Scanner( File file ) throws IOException {
      Scanner scanner = new Scanner(file, charsetName).useDelimiter("\\A");
      return scanner.hasNext() ? scanner.next() : "";
  }

• Java 7 ( java.nio.file.Files.readAllBytes)

  public static String getDiskFile_Java7( File file ) throws IOException {
      byte[] readAllBytes = java.nio.file.Files.readAllBytes(Paths.get( file.getAbsolutePath() ));
      return new String( readAllBytes );
  }

• BufferedReadermit InputStreamReader.

  public static String getDiskFile_Lines( File file ) throws IOException {
      StringBuffer text = new StringBuffer();
      FileInputStream fileStream = new FileInputStream( file );
      BufferedReader br = new BufferedReader( new InputStreamReader( fileStream ) );
      for ( String line; (line = br.readLine()) != null; )
          text.append( line + System.lineSeparator() );
      return text.toString();
  }

Beispiel mit Hauptmethode für den Zugriff auf die oben genannten Methoden.

public static void main(String[] args) throws IOException {
    String fileName = "E:/parametarisation.csv";
    File file = new File( fileName );

    String fileStream = commons_FileUtils( file );
            // guava_DiskFile( file );
            // streamFile_Buffer( file );
            // getDiskFile_Java7( file );
            // getDiskFile_Lines( file );
    System.out.println( " File Over Disk : \n"+ fileStream );


    try {
        String src = "https://code.jquery.com/jquery-3.2.1.js";
        URL url = new URL( src );

        String urlStream = commons_IOUtils( url );
                // guava_ServerFile( url );
                // streamURL_Scanner( url );
                // streamURL_Buffer( url );
        System.out.println( " File Over Network : \n"+ urlStream );
    } catch (MalformedURLException e) {
        e.printStackTrace();
    }
}

@sehen

• Möglichkeiten, einen InputStream in einen String zu konvertieren

Wenn es sich um eine Textdatei handelt, warum nicht Apache Commons-Io verwenden ?

Es hat die folgende Methode

public static String readFileToString(File file) throws IOException

Wenn Sie die Zeilen als Liste verwenden möchten, verwenden Sie

public static List<String> readLines(File file) throws IOException

Seit JDK 11:

String file = ...
Path path = Paths.get(file);
String content = Files.readString(path);
// Or readString(path, someCharset), if you need a Charset different from UTF-8

Eine Datei als Binärdatei lesen und am Ende konvertieren

public static String readFileAsString(String filePath) throws IOException {
    DataInputStream dis = new DataInputStream(new FileInputStream(filePath));
    try {
        long len = new File(filePath).length();
        if (len > Integer.MAX_VALUE) throw new IOException("File "+filePath+" too large, was "+len+" bytes.");
        byte[] bytes = new byte[(int) len];
        dis.readFully(bytes);
        return new String(bytes, "UTF-8");
    } finally {
        dis.close();
    }
}

Mit Java 7 ist dies meine bevorzugte Option zum Lesen einer UTF-8-Datei:

String content = new String(Files.readAllBytes(Paths.get(filename)), "UTF-8");

Seit Java 7 verfügt das JDK über die neue java.nio.fileAPI, die viele Verknüpfungen bietet, sodass Bibliotheken von Drittanbietern für einfache Dateivorgänge nicht immer erforderlich sind.

Java versucht, in allem, was es tut, extrem allgemein und flexibel zu sein. Infolgedessen ist etwas, das in einer Skriptsprache relativ einfach ist (Ihr Code würde open(file).read()in Python durch " " ersetzt), viel komplizierter. Es scheint keinen kürzeren Weg zu geben, als eine externe Bibliothek zu verwenden (wie Willi aus Rohr erwähnt hat). Deine Optionen:

• Verwenden Sie eine externe Bibliothek.
• Kopieren Sie diesen Code in alle Ihre Projekte.
• Erstellen Sie Ihre eigene Mini-Bibliothek, die Funktionen enthält, die Sie häufig verwenden.

Ihre beste Wette ist wahrscheinlich die 2., da sie die geringsten Abhängigkeiten aufweist.

Verwenden von JDK 8 oder höher:

Keine externen Bibliotheken verwendet

Sie können ein neues String-Objekt aus dem Dateiinhalt erstellen (Verwenden von Klassen aus dem java.nio.filePaket):

public String readStringFromFile(String filePath) throws IOException {
    String fileContent = new String(Files.readAllBytes(Paths.get(filePath)));
    return fileContent;
}

Es gibt eine Variation desselben Themas, bei der anstelle einer while-Schleife eine for-Schleife verwendet wird, um den Umfang der Zeilenvariablen einzuschränken. Ob es "besser" ist, ist eine Frage des persönlichen Geschmacks.

for(String line = reader.readLine(); line != null; line = reader.readLine()) {
    stringBuilder.append(line);
    stringBuilder.append(ls);
}

Wenn Sie keinen Zugriff auf die FilesKlasse haben, können Sie eine native Lösung verwenden.

static String readFile(File file, String charset)
        throws IOException
{
    FileInputStream fileInputStream = new FileInputStream(file);
    byte[] buffer = new byte[fileInputStream.available()];
    int length = fileInputStream.read(buffer);
    fileInputStream.close();
    return new String(buffer, 0, length, charset);
}

Eine flexible Lösung mit IOUtils von Apache commons-io in Kombination mit StringWriter :

Reader input = new FileReader();
StringWriter output = new StringWriter();
try {
  IOUtils.copy(input, output);
} finally {
  input.close();
}
String fileContents = output.toString();

Es funktioniert mit jedem Reader oder Eingabestream (nicht nur mit Dateien), beispielsweise beim Lesen von einer URL.

Beachten Sie, dass bei Verwendung fileInputStream.available()der zurückgegebenen Ganzzahl nicht die tatsächliche Dateigröße angegeben werden muss, sondern die geschätzte Anzahl von Bytes, die das System aus dem Stream lesen kann, ohne die E / A zu blockieren. Ein sicherer und einfacher Weg könnte so aussehen

public String readStringFromInputStream(FileInputStream fileInputStream) {
    StringBuffer stringBuffer = new StringBuffer();
    try {
        byte[] buffer;
        while (fileInputStream.available() > 0) {
            buffer = new byte[fileInputStream.available()];
            fileInputStream.read(buffer);
            stringBuffer.append(new String(buffer, "ISO-8859-1"));
        }
    } catch (FileNotFoundException e) {
    } catch (IOException e) { }
    return stringBuffer.toString();
}

Es sollte berücksichtigt werden, dass dieser Ansatz nicht für Mehrbyte-Zeichencodierungen wie UTF-8 geeignet ist.

Dieser verwendet die Methode RandomAccessFile.readFully, sie scheint ab JDK 1.0 verfügbar zu sein!

public static String readFileContent(String filename, Charset charset) throws IOException {
    RandomAccessFile raf = null;
    try {
        raf = new RandomAccessFile(filename, "r");
        byte[] buffer = new byte[(int)raf.length()];
        raf.readFully(buffer);
        return new String(buffer, charset);
    } finally {
        closeStream(raf);
    }
} 


private static void closeStream(Closeable c) {
    if (c != null) {
        try {
            c.close();
        } catch (IOException ex) {
            // do nothing
        }
    }
}

Sie können Scanner- und Dateiklasse ausprobieren, eine Lösung mit wenigen Zeilen

 try
{
  String content = new Scanner(new File("file.txt")).useDelimiter("\\Z").next();
  System.out.println(content);
}
catch(FileNotFoundException e)
{
  System.out.println("not found!");
}

Benutzer java.nio.Files, um alle Zeilen der Datei zu lesen.

public String readFile() throws IOException {
        File fileToRead = new File("file path");
        List<String> fileLines = Files.readAllLines(fileToRead.toPath());
        return StringUtils.join(fileLines, StringUtils.EMPTY);
}

public static String slurp (final File file)
throws IOException {
    StringBuilder result = new StringBuilder();

    BufferedReader reader = new BufferedReader(new FileReader(file));

    try {
        char[] buf = new char[1024];

        int r = 0;

        while ((r = reader.read(buf)) != -1) {
            result.append(buf, 0, r);
        }
    }
    finally {
        reader.close();
    }

    return result.toString();
}

Ich kann noch keine anderen Einträge kommentieren, also lasse ich es einfach hier.

Eine der besten Antworten hier ( https://stackoverflow.com/a/326448/1521167 ):

private String readFile(String pathname) throws IOException {

File file = new File(pathname);
StringBuilder fileContents = new StringBuilder((int)file.length());
Scanner scanner = new Scanner(file);
String lineSeparator = System.getProperty("line.separator");

try {
    while(scanner.hasNextLine()) {        
        fileContents.append(scanner.nextLine() + lineSeparator);
    }
    return fileContents.toString();
} finally {
    scanner.close();
}
}

hat noch einen Fehler. Es wird immer ein neues Zeilenzeichen am Ende des Strings eingefügt, was einige seltsame Fehler verursachen kann. Mein Vorschlag ist, es zu ändern in:

    private String readFile(String pathname) throws IOException {
    File file = new File(pathname);
    StringBuilder fileContents = new StringBuilder((int) file.length());
    Scanner scanner = new Scanner(new BufferedReader(new FileReader(file)));
    String lineSeparator = System.getProperty("line.separator");

    try {
        if (scanner.hasNextLine()) {
            fileContents.append(scanner.nextLine());
        }
        while (scanner.hasNextLine()) {
            fileContents.append(lineSeparator + scanner.nextLine());
        }
        return fileContents.toString();
    } finally {
        scanner.close();
    }
}

Nach Strg + F'ing nach Scanner denke ich, dass die Scannerlösung auch aufgelistet werden sollte. Auf die am einfachsten zu lesende Weise geht es so:

public String fileToString(File file, Charset charset) {
  Scanner fileReader = new Scanner(file, charset);
  fileReader.useDelimiter("\\Z"); // \Z means EOF.
  String out = fileReader.next();
  fileReader.close();
  return out;
}

Wenn Sie Java 7 oder höher verwenden (und dies sollten Sie wirklich tun), sollten Sie Try-with-Resources verwenden, um das Lesen des Codes zu vereinfachen. Kein punktnahes Zeug mehr, das alles verschmutzt. Aber das ist meistens eine stilistische Entscheidung.

Ich poste dies hauptsächlich aus Gründen der Vervollständigung, denn wenn Sie dies häufig tun müssen, sollte es Dinge in java.nio.file.Files geben , die die Arbeit besser machen sollten.

Mein Vorschlag wäre, Files # readAllBytes (Path) zu verwenden, um alle Bytes zu erfassen und sie einem neuen String (byte [] Charset) zuzuführen. , um einen String daraus zu erhalten, dem Sie vertrauen können. Charsets werden für Sie während Ihres Lebens gemein sein, also hüten Sie sich jetzt vor diesem Zeug.

Andere haben Code und so gegeben, und ich möchte ihren Ruhm nicht stehlen. ;)

Bei Verwendung dieser Bibliothek handelt es sich um eine Zeile:

String data = IO.from(new File("data.txt")).toString();

Auch wenn sich Ihre Datei in einem Glas befindet, können Sie Folgendes verwenden:

public String fromFileInJar(String path) {
    try ( Scanner scanner 
            = new Scanner(getClass().getResourceAsStream(path))) {
        return scanner.useDelimiter("\\A").next();
    }
}

Der Pfad sollte / zum Beispiel mit beginnen, wenn Ihr Glas ist

my.jar/com/some/thing/a.txt

Dann möchten Sie es so aufrufen:

String myTxt = fromFileInJar("/com/com/thing/a.txt");

In einer Zeile (Java 8), vorausgesetzt, Sie haben einen Reader:

String sMessage = String.join("\n", reader.lines().collect(Collectors.toList()));

Basierend auf der Antwort von @ erickson können Sie Folgendes verwenden:

public String readAll(String fileName) throws IOException {
    List<String> lines = Files.readAllLines(new File(fileName).toPath());
    return String.join("\n", lines.toArray(new String[lines.size()]));
}