it-swarm.com.de

Wie erstelle ich eine Java Zeichenfolge aus dem Inhalt einer Datei?

Ich verwende die folgende Redewendung seit einiger Zeit. Und es scheint am weitesten verbreitet zu sein, zumindest auf den Seiten, die ich besucht habe.

Gibt es eine bessere/andere Möglichkeit, eine Datei in Java in einen String 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();
    }
}
1401
OscarRyz

Liest den gesamten Text aus einer Datei

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

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

Für Versionen zwischen Java 7 und 11 ist hier eine kompakte, robuste Redewendung, 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);
}

Liest Textzeilen aus einer Datei

Java 7 fügte eine bequeme Methode zum Lesen einer Datei als Textzeile hinzu, die als List<String> dargestellt wird. Dieser Ansatz ist "verlustbehaftet", da die Zeilentrenner am Ende jeder Zeile entfernt werden.

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

Java 8 hat die Methode Files.lines() hinzugefügt, um einen Stream<String> zu erzeugen. Auch diese Methode ist verlustbehaftet, da Zeilentrenner entfernt werden. Wenn beim Lesen der Datei ein IOException angetroffen wird, wird er in ein UncheckedIOException eingeschlossen, da Stream keine Lambdas akzeptiert, die überprüfte Ausnahmen auslösen.

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

Dieser Stream benötigt einen close() Aufruf; Dies ist in der API schlecht dokumentiert, und ich vermute, dass viele Leute nicht einmal bemerken, dass Stream eine close()-Methode hat. Stellen Sie sicher, dass Sie einen ARM-Block wie abgebildet verwenden.

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

Speicherauslastung

Die erste Methode, bei der Zeilenumbrüche beibehalten werden, kann vorübergehend mehrmals so viel Speicherplatz beanspruchen wie die Datei, da für kurze Zeit der Inhalt der Rohdatei (ein Byte-Array) und die dekodierten Zeichen (von denen jedes 16 Bit enthält, auch wenn es kodiert ist) als 8 Bits in der Datei) befinden sich sofort im Speicher. Es ist am sichersten, Dateien zuzuweisen, 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 Eingabe-Byte-Puffer 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 Textabschnitt aus einem Stream liest, verarbeitet und dann mit dem nächsten fortfährt, wobei der gleiche 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, die einen Stream<String> verwendet, ist eine Möglichkeit, dies zu tun, wenn Ihre Eingabe "Datensätze" einzelne Zeilen sind. (Die Verwendung der Methode readLine() von BufferedReader 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 Standardeinstellung der Plattform Ihren Wünschen entspricht, diese sind jedoch selten und Sie sollten in der Lage sein, Ihre Wahl zu rechtfertigen.

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

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

Die Plattform-Standardeinstellung ist in der Klasse Charset selbst verfügbar:

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

Hinweis: Diese Antwort ersetzt weitgehend meine Java 6-Version. Das Hilfsprogramm von Java 7 vereinfacht den Code auf sichere Weise, und die alte Antwort, die einen zugeordneten Bytepuffer verwendete, verhinderte, dass die gelesene Datei gelöscht wurde, bis der zugeordnete Puffer durch Garbage Collected gelöscht wurde. Sie können die alte Version über den "bearbeiteten" Link zu dieser Antwort anzeigen.

1424
erickson

Wenn Sie eine externe Bibliothek verwenden möchten, lesen Sie Apache Commons IO (200 KB JAR). Es enthält eine org.Apache.commons.io.FileUtils.readFileToString() -Methode, mit der Sie ein gesamtes File in ein String mit einer Codezeile einlesen können.

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);
}
326
Willi aus Rohr

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() für Sie aufruft:

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

Denken Sie daran, dass der Konstruktor Scanner einen IOException auslösen kann. Und vergessen Sie nicht, Java.io und Java.util zu importieren.

Quelle: Pat Niemeyers Blog

174
Pablo Grisafi
import Java.nio.file.Files;
import Java.nio.file.Paths;

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

seit Java 7 können Sie dies auf diese Weise tun.

96
Jobin Joseph

Wenn Sie nach einer Alternative suchen, an der keine Bibliothek eines Drittanbieters beteiligt ist (z. B. Commons I/O ), können Sie die Klasse Scanner 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();
    }
}
76
Dónal

Guave hat eine ähnliche Methode wie die von 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 von Oscar Reyes

Dies ist der (vereinfachte) zugrunde liegende Code in der angegebenen 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): Die obigen Angaben stimmen nicht mit dem Quellcode der letzten Guava-Versionen überein. Die aktuelle Quelle finden Sie in den Klassen Files , CharStreams , ByteSource und CharSource in com. google.common.io Paket.

67
finnw
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 "";
    }
53
user590444

Mit diesem Code werden Zeilenumbrüche normalisiert, die möglicherweise nicht das sind, was Sie wirklich tun möchten.

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

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();
    }        
}
49
Jon Skeet

Wenn Sie eine Zeichenfolgenverarbeitung (Parallelverarbeitung) benötigen, verfügt Java 8 über die hervorragende 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 den JDK-Beispielen sample/lambda/BulkDataOperations, die von Oracle Java SE 8-Download-Seite heruntergeladen werden können

Ein weiteres Beispiel für einen Liner

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

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

public static List<String> readLines(File file) throws IOException
25
Home in Time

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

  • Guava: Google mit 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 - COMMONS IO unter Verwendung der 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. das 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 );
    }
    

  • BufferedReader mit 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, um auf die obigen Methoden zuzugreifen.

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

25
Yash

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
25
leventov

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();
    }
}
16
Peter Lawrey

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.file -API, die viele Verknüpfungen bietet, sodass Bibliotheken von Drittanbietern für einfache Dateioperationen nicht immer erforderlich sind.

16
Moritz Petersen

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

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

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

15
Claudiu

Verwendung von JDK 8 oder höher:

keine externen Bibliotheken verwendet

Sie können ein neues String-Objekt aus dem Dateiinhalt erstellen (Klassen aus dem Java.nio.file -Paket verwenden):

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

Es gibt eine Variation desselben Themas, bei der anstelle einer while-Schleife eine for-Schleife verwendet wird, um den Umfang der Zeilenvariablen zu begrenzen. 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);
}
8
Dan Dyer

Wenn Sie keinen Zugriff auf die Klasse Files 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);
}
7
Ilya Gazman

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), zum Beispiel beim Lesen von einer URL.

4
wau
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();
}
3
Scott S. McCoy

Beachten Sie, dass bei Verwendung von fileInputStream.available() die zurückgegebene Ganzzahl nicht die tatsächliche Dateigröße darstellen muss, sondern die erratene Anzahl von Bytes, die das System aus dem Stream lesen kann, ohne 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.

3
Henry

Sie können versuchen, Scanner und Dateiklasse, ein paar Zeilen Lösung

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

Benutzer Java.nio.Files zum Lesen aller Dateizeilen.

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

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
        }
    }
}
3
barjak

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

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

Mit diese Bibliothek ist es eine Zeile:

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

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()]));
}
2
Muskovets

Nach Strg + F'ing nach Scanner denke ich, dass die Scanner-Lösung auch aufgeführt werden sollte. Auf die am einfachsten zu lesende Art und 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 eine neuere Version verwenden (und Sie sollten dies wirklich tun), sollten Sie die Verwendung von try-with-resources in Betracht ziehen, um die Lesbarkeit des Codes zu verbessern. Nie mehr Dinge aus nächster Nähe, die alles verunreinigen. Aber das ist meistens eine Stilwahl.

Ich poste dies hauptsächlich aus Gründen der Vollständigkeit, da es in Java.nio.file.Files Dinge geben sollte, die den Job besser machen, wenn Sie dies häufig tun müssen.

Mein Vorschlag wäre, Files # readAllBytes (Path) zu verwenden, um alle Bytes zu erfassen, und es neu einzugeben String (byte [] Charset , um einen String herauszuholen darauf können Sie vertrauen. Zeichensätze werden dir zu Lebzeiten gemein sein, also pass jetzt auf.

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

2
Haakon Løtveit

Wenn sich Ihre Datei zufällig in einem Glas befindet, können Sie auch 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 wollen Sie es so aufrufen:

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

Ich kann andere Einträge noch nicht 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 fügt immer neue Zeilenzeichen in das Ende der Zeichenkette ein, was zu seltsamen Fehlern führen kann. Mein Vorschlag ist, es zu ändern:

    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();
    }
}
1
Ajk

Code verwenden:

File file = new File("input.txt");
BufferedInputStream bin = new BufferedInputStream(new FileInputStream(
                file));
byte[] buffer = new byte[(int) file.length()];
bin.read(buffer);
String fileStr = new String(buffer);

fileStr enthält die Ausgabe in String.

0
Devram Kandhare