මම දැන් කාලයක් තිස්සේ පහත මෝඩකම භාවිතා කරමි. අවම වශයෙන් මා සංචාරය කළ අඩවි වලවත් එය වඩාත් පුළුල් ලෙස පැතිරී ඇති බව පෙනේ.

ජාවා හි නූලකට ගොනුවක් කියවීමට වඩා හොඳ / වෙනස් ක්‍රමයක් තිබේද?

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

ගොනුවකින් සියලුම පෙළ කියවන්න

ජාවා 11 මඟින් කුඩා ලිපිගොනු කියවීමට readString () ක්‍රමය එකතු කරන ලදි, රේඛීය පර්යන්තString ආරක්ෂා කරයි:

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

ජාවා 7 සහ 11 අතර අනුවාද සඳහා, මෙන්න උපයෝගීතා ක්‍රමයකින් ඔතා ඇති සංයුක්ත ශක්තිමත් මෝඩකමක්:

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

ගොනුවකින් පෙළ පේළි කියවන්න

ජාවා 7 ගොනුවක් පෙළ රේඛා ලෙස කියවීමට පහසු ක්‍රමයක් එකතු කළ අතර එය a List<String>. එක් එක් පේළියේ කෙළවරේ සිට රේඛා බෙදුම්කරුවන් ඉවත් කර ඇති නිසා මෙම ප්‍රවේශය "පාඩු" වේ.

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

ජාවා 8 Files.lines()මඟින් නිෂ්පාදනය කිරීමේ ක්‍රමය එකතු කරන ලදී Stream<String>. නැවතත්, මෙම ක්‍රමය පාඩු වන්නේ රේඛා බෙදුම්කරුවන් ඉවත් කර ඇති බැවිනි. IOExceptionගොනුව කියවන විට එය හමු වුවහොත් , එය ඔතා ඇත UncheckedIOException, මන්ද Streamපරීක්ෂා කළ ව්‍යතිරේකයන් විසි කරන ලැම්බඩා පිළිගන්නේ නැත.

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

මේ Streamසඳහා close()ඇමතුමක් අවශ්‍යයි ; මෙය API හි දුර්වල ලෙස ලේඛනගත කර ඇති අතර, බොහෝ අය ක්‍රමවේදයක් Streamඇති බව close()නොදැනේ යැයි මම සැක කරමි . පෙන්වා ඇති පරිදි ARM- බ්ලොක් එකක් භාවිතා කිරීමට වග බලා ගන්න.

ඔබ ගොනුවක් හැර වෙනත් ප්‍රභවයක් සමඟ වැඩ කරන්නේ නම්, ඒ වෙනුවට ඔබට lines()ක්‍රමය භාවිතා කළ හැකිය BufferedReader.

මතක භාවිතය

රේඛීය බිඳීම් ආරක්ෂා කරන පළමු ක්‍රමය, තාවකාලිකව ගොනුවේ ප්‍රමාණය මෙන් කිහිප ගුණයක් මතකය අවශ්‍ය වේ, මන්ද කෙටි කාලයක් සඳහා අමු ගොනු අන්තර්ගතය (බයිට් අරා) සහ විකේතනය කළ අක්ෂර (ඒ සෑම එකක්ම බිටු 16 ක් කේතනය කර තිබුණත්) ගොනුවේ බිටු 8 ක් ලෙස) එකවර මතකයේ රැඳේ. පවතින මතකයට සාපේක්ෂව කුඩා යැයි ඔබ දන්නා ලිපිගොනු වලට අයදුම් කිරීම ආරක්ෂිත වේ.

දෙවන ක්‍රමය, රේඛා කියවීම සාමාන්‍යයෙන් වඩා මතක කාර්යක්‍ෂම වේ, මන්ද විකේතනය සඳහා ආදාන බයිට් බෆරය මුළු ගොනුවම අඩංගු නොවිය යුතුය. කෙසේ වෙතත්, පවතින මතකයට සාපේක්ෂව ඉතා විශාල ගොනු සඳහා එය තවමත් සුදුසු නොවේ.

විශාල ලිපිගොනු කියවීම සඳහා, ඔබේ වැඩසටහන සඳහා වෙනස් මෝස්තරයක් අවශ්‍ය වේ, එය ධාරාවකින් පෙළ කැබැල්ලක් කියවා, එය ක්‍රියාවට නංවා, ඊළඟට ඉදිරියට ගොස් එකම ස්ථාවර ප්‍රමාණයේ මතක වාරණයක් නැවත භාවිතා කරයි. මෙන්න, "විශාල" පරිගණක පිරිවිතර මත රඳා පවතී. වර්තමානයේ, මෙම සීමාව බොහෝ ගිගාබයිට් RAM විය හැකිය. තෙවන ක්‍රමය, a භාවිතා කිරීම Stream<String>මෙය කළ හැකි එක් ක්‍රමයකි, ඔබේ ආදාන “වාර්තා” තනි රේඛා වේ නම්. ( readLine()ක්‍රමවේදය භාවිතා BufferedReaderකිරීම මෙම ප්‍රවේශයට සමාන ක්‍රියා පටිපාටිය වේ.)

අක්ෂර කේතන

මුල් පෝස්ට් එකේ නියැදියෙන් අස්ථානගත වී ඇති එක් දෙයක් නම් අක්ෂර කේතනයයි. වේදිකා පෙරනිමිය ඔබට අවශ්‍ය විශේෂ අවස්ථා කිහිපයක් ඇත, නමුත් ඒවා දුර්ලභ වන අතර ඔබේ තේරීම සාධාරණීකරණය කිරීමට ඔබට හැකි විය යුතුය.

මෙම StandardCharsetsපන්තියේ සියලුම ජාවා runtimes අවශ්ය වන ගැනීමේදී කේතන ක්රමවල සඳහා යම් යම් නියත නිර්වචනය:

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

වේදිකාව පෙරනිමි සිට ලබා ගත හැකි වේ ද Charsetපන්ති ය:

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

සටහන: මෙම පිළිතුර බොහෝ දුරට මගේ ජාවා 6 අනුවාදය ප්‍රතිස්ථාපනය කරයි. ජාවා 7 හි උපයෝගීතාව කේතය ආරක්ෂිතව සරල කරන අතර, සිතියම්ගත කළ බයිට් බෆරයක් භාවිතා කළ පැරණි පිළිතුර, සිතියම්ගත කළ බෆරය කසළ එකතු කරන තෙක් කියවූ ගොනුව මකා දැමීම වලක්වනු ලැබීය. මෙම පිළිතුරෙහි "සංස්කරණය කරන ලද" සබැඳිය හරහා ඔබට පැරණි අනුවාදය නැරඹිය හැකිය.

ඔබ බාහිර පුස්තකාලයක් භාවිතා කිරීමට කැමති නම්, පරීක්ෂා කරන්න Apache Commons IO (200KB JAR) බලන්න. එය අඩංගු org.apache.commons.io.FileUtils.readFileToString()ඔබ මුළු කියවීමට ඉඩ ක්රමය Fileබවට Stringකේතය එක් රේඛාව සමඟ.

උදාහරණයක්:

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

පදනම් කරගත් ඉතා කෙට්ටු විසඳුමක් Scanner:

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

නැතහොත්, ඔබට අක්ෂර මාලාව සැකසීමට අවශ්‍ය නම්:

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

නැතහොත්, ඔබ සමඟ කැඳවිය හැකි සම්පත් සමඟ උත්සාහ කරන්නscanner.close() :

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

Scannerඉදිකිරීම්කරුට විසි කළ හැකි බව මතක තබා ගන්න IOException. හා ආනයනය කිරීමට අමතක කරන්න එපා java.ioසහjava.util .

මූලාශ්‍රය: පැට් නියෙමියර්ගේ බ්ලොගය

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

ජාවා 7 සිට ඔබට එය මේ ආකාරයෙන් කළ හැකිය.

ඔබ තෙවන පාර්ශවීය පුස්තකාලයකට සම්බන්ධ නොවන විකල්පයක් සොයන්නේ නම් (උදා: පොදු I / O ), ඔබට ස්කෑනර් පන්තිය භාවිතා කළ හැකිය :

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

පේර විලි Aus Rohr සඳහන් බව Commons IOUtils සිට එක් සමාන ක්රමයක් ඇත:

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

// ...

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

PiggyPiglet විසින් සංස්කරණය කරන්න,
Files#toString එය ඉවත් කිරීමට නියමිත අතර 2019 ඔක්තෝබර් ඉවත් කිරීමට නියමිතය. ඒ වෙනුවට භාවිතා කරන්න Files.asCharSource(new File(path), StandardCharsets.UTF_8).read();

සංස්කරණය කරන්න ඔස්කාර් රීස්

උපුටා ගත් පුස්තකාලයේ (සරල) යටින් පවතින කේතය මෙයයි:

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

සංස්කරණය කරන්න (ජොනික් විසින්): ඉහත සඳහන් මෑත ගුවා අනුවාදවල ප්‍රභව කේතයට නොගැලපේ. වත්මන් මූලාශ්රය සඳහා, පන්ති බලන්න ගොනු , CharStreams , ByteSource හා CharSource දී 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 "";
    }

ඔබට නූල් සැකසුම් (සමාන්තර සැකසුම්) අවශ්‍ය නම් ජාවා 8 හි විශිෂ්ට ධාරා 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

තවත් උදාහරණ JDK සාම්පල ලබා ගත හැක sample/lambda/BulkDataOperationsබාගත කර ගත හැකි බව ඔරකල් ජාවා SE 8 අවපතන පිටුවට

තවත් එක් ලයිනර් උදාහරණයක්

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

එම කේතය ඔබට සැබවින්ම කිරීමට අවශ්‍ය දේ හෝ නොවිය හැකි රේඛා බිඳීම් සාමාන්‍යකරණය කරයි.

මෙන්න එය නොකරන විකල්පයක් වන අතර (IMO) NIO කේතයට වඩා තේරුම් ගැනීමට පහසුය (එය තවමත් භාවිතා වුවද 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();
    }        
}

ගොනුව තැටියෙන් හෝ ජාලයෙන් String ලෙස කියවීමට හැකි සියලු ක්‍රම එක්රැස් කරන ලදි.

• ගුවා: පන්ති භාවිතා කරන ගූගල්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 - IOUtils , FileUtils පන්ති භාවිතා කරන පොදු IO

  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") );*/
  }

• ජාවා 8 Bufferreader භාවිතා විෂය ධාරාව 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()));
  }

• රීජෙක්ස් සමඟ ස්කෑනර් පන්තිය \A. එය ආදානයේ ආරම්භයට ගැලපේ.

  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() : "";
  }

• ජාවා 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භාවිතා කිරීම 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();
  }

ඉහත ක්‍රමවලට ප්‍රවේශ වීම සඳහා ප්‍රධාන ක්‍රමය සමඟ උදාහරණය.

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

@ බලන්න

• ආදාන ප්‍රවාහයක් නූලකට පරිවර්තනය කිරීමේ ක්‍රම

එය පෙළ ගොනුවක් නම් අපාචේ කොමන්ස්- io භාවිතා නොකරන්නේ ඇයි ?

එයට පහත ක්‍රමවේදය ඇත

public static String readFileToString(File file) throws IOException

ඔබට ලැයිස්තුවක් ලෙස පේළි අවශ්‍ය නම්

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

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

ගොනුවක් ද්විමය ලෙස කියවා අවසානයේ පරිවර්තනය කිරීම

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

ජාවා උත්සාහ කරන්නේ අතිශයින්ම සාමාන්‍ය හා නම්‍යශීලී වීමටයි. එහි ප්‍රති As ලයක් ලෙස, ස්ක්‍රිප්ටින් භාෂාවක සාපේක්ෂව සරල දෙයක් (ඔබේ කේතය පයිතන්හි " open(file).read()" සමඟ ප්‍රතිස්ථාපනය වේ) වඩා සංකීර්ණ වේ. බාහිර පුස්තකාලයක් භාවිතා කිරීම හැර ( විලී ඕස් රෝර් සඳහන් කළ පරිදි) එය කිරීමට කෙටි ක්‍රමයක් ඇති බවක් නොපෙනේ . ඔබේ විකල්ප:

• බාහිර පුස්තකාලයක් භාවිතා කරන්න.
• ඔබගේ සියලු ව්‍යාපෘති වලට මෙම කේතය පිටපත් කරන්න.
• ඔබ නිතර භාවිතා කරන කාර්යයන් අඩංගු ඔබේම කුඩා පුස්තකාලයක් සාදන්න.

ඔබගේ හොඳම ඔට්ටුව 2 වන එක විය හැකිය, එයට අවම පරායත්තතා ඇත.

ජාවා 7 සමඟ, යූටීඑෆ් -8 ගොනුවක් කියවීමට මෙය මගේ ප්‍රියතම විකල්පයයි:

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

ජාවා 7 සිට, JDK සතුව නව java.nio.fileAPI ඇත, එය බොහෝ කෙටිමං සපයයි, එබැවින් සරල ගොනු මෙහෙයුම් සඳහා තෙවන පාර්ශවීය පුස්තකාල සැමවිටම අවශ්‍ය නොවේ.

JDK 8 හෝ ඊට වැඩි භාවිතා කිරීම:

බාහිර පුස්තකාල භාවිතා නොකෙරේ

ගොනු අන්තර්ගතයෙන් ඔබට නව සංගීත වස්තුවක් නිර්මාණය කළ හැකිය ( java.nio.fileපැකේජයෙන් පන්ති භාවිතා කිරීම ):

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

රේඛීය විචල්‍යයේ විෂය පථය සීමා කිරීම සඳහා, ටික වේලාවක් වෙනුවට, ලූපයක් සඳහා භාවිතා කරන එකම තේමාවේ වෙනසක් ඇත. එය "වඩා හොඳ" ද යන්න පෞද්ගලික රුචිකත්වයට කරුණකි.

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

ඔබට Filesපන්තියට ප්‍රවේශය නොමැති නම් , ඔබට ස්වදේශීය විසඳුමක් භාවිතා කළ හැකිය.

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

StringWriter සමඟ ඒකාබද්ධව Apache commons-io වෙතින් IOUtils භාවිතා කරන නම්‍යශීලී විසඳුමක් :

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

එය ඕනෑම පා er කයෙකු හෝ ආදාන ප්‍රවාහයක් සමඟ ක්‍රියා කරයි (ලිපිගොනු සමඟ පමණක් නොවේ), උදාහරණයක් ලෙස URL එකකින් කියවීමේදී.

fileInputStream.available()ආපසු ලබා දුන් නිඛිලය භාවිතා කරන විට සත්‍ය ගොනු ප්‍රමාණය නිරූපණය කළ යුතු නැත, නමුත් අනුමාන කළ බයිට් ප්‍රමාණය පද්ධතියට IO අවහිර නොකර ප්‍රවාහයෙන් කියවිය හැකිය. ආරක්ෂිත හා සරල ක්‍රමයක් මේ වගේ විය හැකිය

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

UTF-8 වැනි බහු-බයිට් අක්ෂර කේතන සඳහා මෙම ප්‍රවේශය සුදුසු නොවන බව සැලකිල්ලට ගත යුතුය .

මෙය ක්‍රමය භාවිතා කරයි RandomAccessFile.readFully, එය JDK 1.0 වෙතින් ලබා ගත හැකි බව පෙනේ!

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

ඔබට ස්කෑනර් සහ ගොනු පන්තිය උත්සාහ කළ හැකිය, පේළි කිහිපයක් විසඳුම

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

java.nio.Filesසියලුම ලිපිගොනු කියවීමට පරිශීලකයා .

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

මට තවම වෙනත් සටහන් දැක්විය නොහැක, එබැවින් මම එය මෙහි තබමි.

මෙහි හොඳම පිළිතුරු වලින් එකක් ( 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();
}
}

තවමත් එක් අඩුපාඩුවක් ඇත. එය සෑම විටම නව රේඛා වර්‍ගයක් නූල් අවසානයේ තබයි, එමඟින් සමහර විකාර දෝෂ ඇති විය හැක. මගේ යෝජනාව එය වෙනස් කිරීම:

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

ස්කෑනරයෙන් පසු Ctrl + F'ing පසු, ස්කෑනර් විසඳුම ද ලැයිස්තු ගත කළ යුතු යැයි මම සිතමි. විලාසිතා කියවීමට පහසුම ආකාරයෙන් එය මෙසේ ය:

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;
}

ඔබ ජාවා 7 හෝ නව භාවිතා කරන්නේ නම් (සහ ඔබ සැබවින්ම කළ යුත්තේ) කේතය කියවීම පහසු කිරීම සඳහා සම්පත් සමඟ උත්සාහ කිරීම සලකා බලන්න. සෑම දෙයක්ම පැටව් ගසන තිත්-සමීප දේවල් නැත. නමුත් එය බොහෝ දුරට ශෛලීය තේරීම් මෙතික්ස් ය.

මම මෙය වැඩිපුරම පළ කරන්නේ සම්පූර්ණ කිරීම සඳහා ය, මන්ද ඔබට මෙය බොහෝ දේ කිරීමට අවශ්‍ය නම්, java.nio.file.Files හි දේවල් තිබිය යුතු අතර එම කාර්යය වඩා හොඳින් කළ යුතුය.

මගේ යෝජනාව වනුයේ සියලුම බයිට් අල්ලා ගැනීමට ලිපිගොනු # readAllBytes (Path) භාවිතා කිරීම සහ ඔබට විශ්වාස කළ හැකි නූලක් ලබා ගැනීම සඳහා එය නව සංගීත (බයිට් [] චාර්සෙට්) වෙත පෝෂණය කිරීමයි . ඔබගේ ජීවිත කාලය තුළ අක්ෂර කට්ටල ඔබට පහත් වනු ඇත, එබැවින් දැන් මේ දේවල් වලින් පරිස්සම් වන්න.

තවත් සමහරු කේත සහ දේවල් ලබා දී ඇති අතර ඔවුන්ගේ මහිමය සොරකම් කිරීමට මට අවශ්‍ය නැත. ;)

මෙම පුස්තකාලය භාවිතා කිරීම , එය එක් පේළියකි:

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

ඔබේ ගොනුව භාජනයක් තුළ තිබේ නම්, ඔබට මෙයද භාවිතා කළ හැකිය:

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

/ ඔබේ බඳුන නම් මාර්ගය ආරම්භ විය යුතුය

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

එවිට ඔබට එය මේ ආකාරයට කැඳවීමට අවශ්‍යයි:

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

එක් පේළියක (ජාවා 8), ඔබට පා er කයෙකු ඇතැයි උපකල්පනය කරන්න:

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

@ එරික්සන්ගේ පිළිතුර මත පදනම්ව, ඔබට මෙය භාවිතා කළ හැකිය:

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