दिलचस्प पोस्ट
ढूँढना पथ / रूट आईफोन में मैपकेट पर दो बिंदुओं के बीच $ _REQUEST, $ _GET और $ _POST में जो सबसे तेज़ है? जब उपयोगकर्ता उपयोगकर्ता के संपर्क पहुंच अनुमतियाँ बदलता है तो ऐप iOS 6 में क्रैश हो जाता है सी # में मार्शल "चार *" डिबग मोड के लिए इस निष्पादन योग्य के लिए एक वैध प्रावधान प्रोफ़ाइल नहीं मिली एडी के खुलासे के मॉड्यूल पैटर्न के विवरण में "पैच की आवश्यकता है, तो" सार्वजनिक फ़ंक्शन द्वारा क्या मतलब है ओवरराइड नहीं किया जा सकता है? उत्तरदायी रूप से पक्ष आकार रखते हुए पहलू अनुपात एंड्रॉइड – बटन दोहराएँ कार्रवाई को पकड़ो सैंडी-पुल और हैवैल एसएसई 2 / एवीएक्स / एवीएक्स 2 के लिए प्रति चक्र फ्लॉप प्राथमिक कुंजी के बिना SQL तालिका से डुप्लिकेट रिकॉर्ड हटाएं जावास्क्रिप्ट – मैं स्क्रिप्ट का यूआरएल कैसे प्राप्त करूं? VBA मैक्रो टाइमर शैली पर कोड को चलाने के लिए सेकंड के प्रत्येक सेट नंबर, अर्थात 120 सेकंड जावास्क्रिप्ट 'होस्टिंग' इंटरनेट पर सबसे सुरक्षित यूडीपी पैकेट साइज़ क्या है सी + + मॉड्यूल – उन्हें सी ++ 0x से क्यों हटा दिया गया? क्या वे बाद में वापस आ जाएंगे?

मैं एक फ़ाइल की सामग्री से एक जावा स्ट्रिंग कैसे बनाऊं?

मैं कुछ समय के लिए नीचे मुहावरे का इस्तेमाल कर रहा हूं। और ऐसा लगता है कि मैं जिन साइटों पर गए हैं उन पर कम से कम सबसे ज्यादा फैला हुआ है।

क्या जावा में एक स्ट्रिंग में एक फ़ाइल को पढ़ने के लिए एक बेहतर / अलग तरीका है?

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

वेब के समाधान से एकत्रित समाधान "मैं एक फ़ाइल की सामग्री से एक जावा स्ट्रिंग कैसे बनाऊं?"

किसी फ़ाइल से सभी पाठ पढ़ें

यहां जावा 7 के लिए कॉम्पैक्ट, मजबूत मुहावरे हैं, जो उपयोगिता विधि में लिपटे हैं:

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

किसी फ़ाइल से टेक्स्ट की पंक्तियां पढ़ें

जावा 7 ने एक फ़ाइल को पाठ की पंक्तियों के रूप में पढ़ने के लिए सुविधा विधि को जोड़ा , एक List<String> रूप में दर्शाया गया है यह दृष्टिकोण "हानिपूर्ण" है क्योंकि लाइन विभाजक प्रत्येक पंक्ति के अंत से छीन लिए गए हैं।

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

जावा 8 में, BufferedReader ने एक नई विधि, lines() एक Stream<String> का उत्पादन करने के लिए जोड़ा है यदि फाइल को पढ़ने के दौरान एक IOException का सामना करना IOException है, तो यह एक IOException में लपेटा जाता है, क्योंकि Stream ने लैम्ब्डा को स्वीकार नहीं किया है जो चेक अपवाद को फेंकते हैं।

 try (BufferedReader r = Files.newBufferedReader(path, encoding)) { r.lines().forEach(System.out::println); } 

स्मृति उपयोग

पहली विधि, जो लाइन ब्रेक को संरक्षित करती है, अस्थायी रूप से फ़ाइल के आकार की कई बार स्मृति की आवश्यकता कर सकती है, क्योंकि कम समय के लिए कच्ची फाइल सामग्री (एक बाइट सरणी) और डीकोड वर्ण (जिनमें से प्रत्येक 16 बिट्स हैं, भले ही इनकोडेड फाइल में 8 बिट के रूप में) एक बार में स्मृति में रहते हैं। उपलब्ध फ़ाइलों को लागू करने के लिए यह सबसे सुरक्षित है कि आप उपलब्ध स्मृति के सापेक्ष छोटे हैं

दूसरी विधि, रीडिंग लाइनें, आमतौर पर अधिक कुशलता से स्मृति होती है, क्योंकि डीकोडिंग के लिए इनपुट बाइट बफ़र को पूरी फाइल को शामिल करने की आवश्यकता नहीं होती है हालांकि, यह अभी भी उपलब्ध फ़ाइलों के लिए उपयुक्त नहीं है जो उपलब्ध स्मृति के मुकाबले बहुत बड़ी है

बड़ी फ़ाइलों को पढ़ने के लिए, आपको अपने प्रोग्राम के लिए एक अलग डिज़ाइन की आवश्यकता होती है, जो कि किसी स्ट्रीम से पाठ का एक हिस्सा पढ़ता है, उसे क्रियान्वित करता है, और उसके बाद अगले पर चलता रहता है, वही निश्चित-आकार वाले स्मृति ब्लॉक का पुन: उपयोग करता है यहां, "बड़े" कंप्यूटर ऐनक पर निर्भर करता है आजकल, यह सीमा रैम के कई गीगाबाइट हो सकती है। तीसरी विधि, एक Stream<String> का उपयोग करके ऐसा करने का एक तरीका है, यदि आपका इनपुट "रिकॉर्ड्स" अलग-अलग लाइनों के होने पर होता है ( BufferedReader की readLine() विधि का उपयोग इस दृष्टिकोण के लिए प्रक्रियात्मक समकक्ष है।)

अक्षरों को सांकेतिक अक्षरों में बदलना

एक बात जो मूल पोस्ट में नमूने से गायब है वह वर्ण एन्कोडिंग है। ऐसे कुछ विशेष मामले हैं जहां प्लेटफ़ॉर्म डिफ़ॉल्ट है जो आप चाहते हैं, लेकिन वे दुर्लभ हैं, और आपको अपनी पसंद को सही ठहराना चाहिए।

StandardCharsets वर्ग सभी जावा रनटाइम के लिए आवश्यक एन्कोडिंग के लिए कुछ स्थिरांक को परिभाषित करता है:

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

Charset डिफ़ॉल्ट Charset क्लास से ही उपलब्ध है:

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

नोट: यह जवाब बड़े पैमाने पर मेरे जावा 6 संस्करण की जगह है जावा 7 की उपयोगिता कोड को सरलता से सरल करती है, और पुराने उत्तर, जो एक मैप किए गए बाइट बफ़र का इस्तेमाल करता था, उस फ़ाइल को रोका गया जिसे हटाए जाने से बरामद किए गए मैप बफर कचरा एकत्र किया गया था। आप इस उत्तर पर "संपादित" लिंक के माध्यम से पुराने संस्करण देख सकते हैं

कॉमन्स FileUtils.readFileToString :

 public static String readFileToString(File file) throws IOException 

किसी फ़ाइल की सामग्री को स्ट्रिंग में VM के लिए डिफ़ॉल्ट एन्कोडिंग का उपयोग करके पढ़ता है फाइल हमेशा बंद होती है।

पैरामीटर:

  • file – पढ़ने के लिए फ़ाइल, रिक्त नहीं होना चाहिए

रिटर्न: फ़ाइल सामग्री, कभी भी अशक्त नहीं

फेंकता है: – IOException – एक I / O त्रुटि के मामले में

चूंकि: कॉमन्स आईओ 1.3.1

उस वर्ग द्वारा उपयोग किए गए कोड (अप्रत्यक्ष रूप से) है:

अपाच लाइसेंस 2.0 के तहत IOUtils.java

 public static long copyLarge(InputStream input, OutputStream output) throws IOException { byte[] buffer = new byte[DEFAULT_BUFFER_SIZE]; long count = 0; int n = 0; while (-1 != (n = input.read(buffer))) { output.write(buffer, 0, n); count += n; } return count; } 

यह Ritche_W द्वारा उपयोग किए जाने वाले के समान है

इस पृष्ठ से बहुत खराब समाधान है:

 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 

यदि आप वर्णसेट सेट करना चाहते हैं

यदि आप किसी ऐसे विकल्प की तलाश कर रहे हैं जिसमें तीसरे पक्ष की लाइब्रेरी (जैसे कॉमन्स I / O ) शामिल नहीं है, तो आप स्कैनर वर्ग का उपयोग कर सकते हैं:

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

अमरूद का एक ऐसा तरीका है जो एक कॉमन्स आईओटील्स से है जो विल वीर रोहर ने उल्लेख किया है:

 import com.google.common.base.Charsets; import com.google.common.io.Files; // ... String text = Files.toString(new File(path), Charsets.UTF_8); 

ऑस्कर रेज द्वारा संपादित करें

उद्धृत पुस्तकालय पर यह (सरलीकृत) अंतर्निहित कोड है:

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

संपादित करें (जोनिक द्वारा): उपरोक्त हाल ही में गवा संस्करणों के स्रोत कोड से मिलान नहीं हुआ है। वर्तमान स्रोत के लिए, 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 

अधिक उदाहरण sample/lambda/BulkDataOperations नमूनों sample/lambda/BulkDataOperations में उपलब्ध हैं जिन्हें ओरेकल जावा एसई 8 डाउनलोड पृष्ठ से डाउनलोड किया जा सकता है।

एक और जहाज का उदाहरण

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

यह कोड लाइन ब्रेक के सामान्य होगा, जो आप वास्तव में करना चाहते हैं या नहीं हो सकता है

यहां एक ऐसा विकल्प है जो ऐसा नहीं करता, और जो (आईएमओ) एनआईओ कोड से समझने के लिए सरल है (हालांकि यह अभी भी 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 content = new String(Files.readAllBytes(Paths.get("readMe.txt"))); 

जावा 7 के बाद से आप ऐसा कर सकते हैं

अगर यह पाठ फ़ाइल है तो क्यों नहीं अपाचे कॉमन्स- IO का उपयोग करें?

इसमें निम्नलिखित विधि है

 public static String readFileToString(File file) throws IOException 

यदि आप लाइनों को सूची उपयोग के रूप में चाहते हैं

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

एक फाइल को द्विआधारी के रूप में पढ़ने के लिए और अंत में कनवर्ट करें

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

जावा यह सब करता है में बहुत सामान्य और लचीला होने का प्रयास करता है नतीजतन, एक स्क्रिप्टिंग भाषा में अपेक्षाकृत सरल है (आपके कोड को " open(file).read() साथ बदल दिया जाएगा। open(file).read() " अजगर में) बहुत अधिक जटिल है। बाहरी पुस्तकालय (जैसे विली ऑउंस रोहर का उल्लेख) को छोड़कर, ऐसा करने का कोई छोटा रास्ता नहीं लगता है। आपके विकल्प:

  • बाहरी पुस्तकालय का उपयोग करें
  • इस कोड को अपने सभी परियोजनाओं में कॉपी करें
  • अपनी स्वयं की मिनी-लाइब्रेरी बनाएं जिसमें आप अक्सर उपयोग किए जाने वाले फ़ंक्शन होते हैं।

आपका सबसे अच्छा शर्त संभवतः दूसरी है, क्योंकि इसमें कम से कम निर्भरताएं हैं

लाइन वैरिएबल को सीमित करने के लिए, एक लूप के बजाय एक लूप का उपयोग करने वाले एक ही विषय पर एक भिन्नता है। यह "बेहतर" है चाहे निजी स्वाद का मामला है

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

जावा 7 के साथ, यह यूटीएफ -8 फ़ाइल पढ़ने का मेरा पसंदीदा विकल्प है:

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

जावा 7 के बाद से, java.nio.file में नया java.nio.file एपीआई है, जो कई शॉर्टकट्स प्रदान करता है, इसलिए सरल फ़ाइल संचालन के लिए हमेशा तृतीय पक्ष पुस्तकालयों की आवश्यकता नहीं होती है।

 public static String slurp (final File file) throws IOException { StringBuilder result = new StringBuilder(); try { BufferedReader reader = new BufferedReader(new FileReader(file)); 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(); } 

यदि आपके पास फाइलों तक पहुंच नहीं है, तो आप अगले कार्य करते हैं:

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

स्ट्रैनवर्डर के संयोजन में अपाचे कॉमन्स- आईओ से आईओटील्स का उपयोग कर एक लचीला समाधान:

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

यह किसी भी पाठक या इनपुट स्ट्रीम (केवल फाइलों के साथ) के साथ काम करता है, उदाहरण के लिए जब कोई URL पढ़ रहा हो

fileInputStream.available() का उपयोग करते समय जागरूक रहें fileInputStream.available() रिटर्न पूर्णांक को वास्तविक फ़ाइल आकार का प्रतिनिधित्व नहीं करना है, बल्कि बाइट्स की fileInputStream.available() राशि, सिस्टम को आईओ को अवरुद्ध किए बिना स्ट्रीम से पढ़ने में सक्षम होना चाहिए। एक सुरक्षित और आसान तरीका ऐसा दिख सकता है

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

यह माना जाना चाहिए कि यह तरीका यूटीएफ -8 जैसी बहु-बाइट वर्ण एन्कोडिंग के लिए उपयुक्त नहीं है

यह एक विधि RandomAccessFile.readFully का उपयोग करता है, यह RandomAccessFile.readFully 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 } } } 

स्कैनर के बाद 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 या नए का उपयोग करते हैं (और आपको वास्तव में चाहिए) कोड को पढ़ने में आसान बनाने के लिए प्रयास-के-संसाधनों का उपयोग करने पर विचार करें। अब और नहीं डॉट-क्लोजफ़ॉर्म सब कुछ कचरा हो गया है। लेकिन यह ज्यादातर एक स्टाइलिश पसंद है।

मैं इसे पूरी तरह से पूरा करने के लिए पोस्ट कर रहा हूं, क्योंकि अगर आपको यह बहुत कुछ करना है, तो जावा.नियो.फ़ाइल में कुछ चीज़ें होनी चाहिए। फाइलें जो काम को बेहतर बनाती हैं

मेरा सुझाव फ़ाइलें # पढ़ने AllBytes (पथ) का उपयोग सभी बाइट्स को पकड़ने के लिए करना होगा, और इसे स्ट्रिंग (बाइट [] वर्णसेट पर फ़ीड करना होगा ) जिससे आप उस पर एक स्ट्रिंग प्राप्त कर सकते हैं जिसे आप विश्वास कर सकते हैं। वर्णक आपके जीवनकाल के दौरान आप का मतलब होगा, इसलिए अब इस सामान से सावधान रहें

दूसरों ने कोड और सामग्री दी है, और मैं उनकी महिमा चोरी करना नहीं चाहता। 😉

इस पुस्तकालय का उपयोग करना, यह एक पंक्ति है:

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

आप स्कैनर और फ़ाइल वर्ग की कोशिश कर सकते हैं, कुछ पंक्तियाँ समाधान

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

अगर आपकी फ़ाइल एक जार के अंदर होती है, तो आप इसका उपयोग भी कर सकते हैं:

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

मैं अभी तक अन्य प्रविष्टियों पर टिप्पणी नहीं कर सकता, इसलिए मैं इसे यहां छोड़ दूंगा।

यहां सर्वश्रेष्ठ उत्तर में से एक ( 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(); } } 

एक पंक्ति में (जावा 8), मान लें कि आपके पास एक रीडर है:

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

जावा 8 में, एक नई कक्षा है

java.util.stream.Stream

एक धारा तत्वों के अनुक्रम का प्रतिनिधित्व करती है और उन तत्वों पर संगणना करने के लिए विभिन्न प्रकार के कार्यों का समर्थन करती है

इसके बारे में और पढ़ें:

ओरेकल दस्तावेज़ीकरण

यहाँ एक उदाहरण:

 import java.nio.charset.StandardCharsets; import java.nio.file.Files; import java.nio.file.Paths; import java.util.stream.Stream; public Class ReadFile{ public static String readFile(String filePath) { StringBuilder stringBuilder = new StringBuilder(); String ls = System.getProperty("line.separator"); try { try (Stream<String> lines = Files.lines(Paths.get(filePath), StandardCharsets.UTF_8)) { for (String line : (Iterable<String>) lines::iterator) { stringBuilder.append(line); stringBuilder.append(ls); } } } catch (Exception e) { e.printStackTrace(); } return stringBuilder.toString(); } } 

कोड का उपयोग करें:

 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 स्ट्रिंग में आउटपुट है