क्या कोई उपयोगिता है जो संसाधन में एक पाठ फ़ाइल को स्ट्रिंग में पढ़ने में मदद करती है। मुझे लगता है कि यह एक लोकप्रिय आवश्यकता है, लेकिन मुझे Googling के बाद कोई उपयोगिता नहीं मिली।
क्या कोई उपयोगिता है जो संसाधन में एक पाठ फ़ाइल को स्ट्रिंग में पढ़ने में मदद करती है। मुझे लगता है कि यह एक लोकप्रिय आवश्यकता है, लेकिन मुझे Googling के बाद कोई उपयोगिता नहीं मिली।
जवाबों:
हां, अमरूद इसे Resources
कक्षा में प्रदान करता है । उदाहरण के लिए:
URL url = Resources.getResource("foo.txt");
String text = Resources.toString(url, StandardCharsets.UTF_8);
getResource
उपयोग कर रहा है, Resource.class.getClassLoader
लेकिन वेब अनुप्रयोगों में, यह "आपके" वर्ग लोडर नहीं हो सकता है, इसलिए इसका उपयोग करने की सिफारिश की जाती है (जैसे [1] में) Thread.currentThread().getContextClassLoader().getResourceAsStream
इसके बजाय (संदर्भ [1]: stackoverflow.com/questions/676250/… )
Resources.toString(MyClass.getResource("foo.txt"), Charsets.UTF_8)
जो सही वर्ग लोडर के उपयोग की गारंटी देता है।
com.google.common.io.Resources
को सोनारक्यूब के अनुसार अस्थिर माना जाता है
guava
कार्यान्वयन को बदल दिया है। अमरूद 23 के लिए कार्यान्वयन निम्नलिखित पसंद करता है। ClassLoader loader = MoreObjects.firstNonNull( Thread.currentThread().getContextClassLoader(), Resources.class.getClassLoader());
आप पुराने स्टूपिड स्कैनर चाल oneliner का उपयोग कर सकते हैं कि अमरूद की तरह किसी भी अतिरिक्त निर्भरता के बिना:
String text = new Scanner(AppropriateClass.class.getResourceAsStream("foo.txt"), "UTF-8").useDelimiter("\\A").next();
दोस्तों, जब तक आपको वास्तव में आवश्यकता न हो, तब तक 3 पार्टी सामान का उपयोग न करें। JDK में पहले से ही बहुत अधिक कार्यक्षमता है।
CartApplication.class.getResourceAsStream
करने के CartApplication.class.getClassLoader().getResourceAsStream
लिए परिवर्तन..जैसे srm / परीक्षण / संसाधन
जावा 7 के लिए:
new String(Files.readAllBytes(Paths.get(getClass().getResource("foo.txt").toURI())));
getClass().getClassLoader()
लेकिन अन्यथा महान समाधान!
यदि आप जावा 8 या अधिक का उपयोग कर रहे हैं तो यह सरल विधि नीचे ठीक होगी:
/**
* Reads given resource file as a string.
*
* @param fileName path to the resource file
* @return the file's contents
* @throws IOException if read fails for any reason
*/
static String getResourceFileAsString(String fileName) throws IOException {
ClassLoader classLoader = ClassLoader.getSystemClassLoader();
try (InputStream is = classLoader.getResourceAsStream(fileName)) {
if (is == null) return null;
try (InputStreamReader isr = new InputStreamReader(is);
BufferedReader reader = new BufferedReader(isr)) {
return reader.lines().collect(Collectors.joining(System.lineSeparator()));
}
}
}
और यह जार फ़ाइलों में संसाधनों के साथ भी काम करता है ।
पाठ एन्कोडिंग के बारे में: InputStreamReader
यदि आप एक निर्दिष्ट नहीं करते हैं तो डिफ़ॉल्ट सिस्टम चारसेट का उपयोग करेगा। आप इस तरह से डिकोडिंग समस्याओं से बचने के लिए इसे स्वयं निर्दिष्ट करना चाह सकते हैं:
new InputStreamReader(isr, StandardCharsets.UTF_8);
हमेशा बड़े, वसा पुस्तकालयों के आधार पर नहीं पसंद करते हैं। जब तक आप पहले से ही अन्य कार्यों के लिए अमरूद या अपाचे कॉमन्स IO का उपयोग नहीं कर रहे हैं, उन पुस्तकालयों को अपनी परियोजना में जोड़ना बस एक फ़ाइल से पढ़ने में सक्षम होने के लिए बहुत अधिक लगता है।
मैं समझता हूं कि शुद्ध जावा एक अच्छा काम नहीं करता है जब इस तरह के सरल कार्य करने की बात आती है। उदाहरण के लिए, यह है कि हमने Node.js में एक फ़ाइल से कैसे पढ़ा है:
const fs = require("fs");
const contents = fs.readFileSync("some-file.txt", "utf-8");
सरल और पढ़ने में आसान (हालाँकि लोग अभी भी कई निर्भरता पर भरोसा करना पसंद करते हैं, ज्यादातर अज्ञानता के कारण)। या अजगर में:
with open('some-file.txt', 'r') as f:
content = f.read()
यह दुखद है, लेकिन यह जावा के मानकों के लिए अभी भी सरल है और आपको बस इतना करना है कि अपने प्रोजेक्ट के ऊपर की विधि को कॉपी करें और उसका उपयोग करें। मैं आपको यह समझने के लिए भी नहीं कहता कि वहां क्या चल रहा है, क्योंकि यह वास्तव में किसी के लिए भी मायने नहीं रखता। यह सिर्फ काम करता है, अवधि :-)
InputStream
जोड़ूंगा is
कि क्या चर है null
या नहीं।
अमरूद में एक स्ट्रिंग में एक फ़ाइल पढ़ने के लिए एक "toString" विधि है:
import com.google.common.base.Charsets;
import com.google.common.io.Files;
String content = Files.toString(new File("/home/x1/text.log"), Charsets.UTF_8);
इस पद्धति को फ़ाइल को क्लासपाथ में रखने की आवश्यकता नहीं है (जैसा कि जॉन स्कीट पिछले उत्तर में है)।
String stringFromStream = CharStreams.toString(new InputStreamReader(resourceAsStream, "UTF-8"));
yegor256 ने Apache Commons IO का उपयोग करके एक अच्छा समाधान पाया है :
import org.apache.commons.io.IOUtils;
String text = IOUtils.toString(this.getClass().getResourceAsStream("foo.xml"),
"UTF-8");
IOUtils.toString(this.getClass().getResource("foo.xml"), "UTF-8")
:।
getClassLoader()
तो विधि श्रृंखला में जोड़ने का प्रयास करें : String text = IOUtils.toString( getClass().getClassLoader().getResourceAsStream("foo.xml"), StandardCharsets.UTF_8);
Apache-commons-io का एक उपयोगिता नाम है FileUtils
:
URL url = Resources.getResource("myFile.txt");
File myFile = new File(url.toURI());
String content = FileUtils.readFileToString(myFile, "UTF-8"); // or any other encoding
मुझे अक्सर यह समस्या थी। छोटी परियोजनाओं पर निर्भरता से बचने के लिए, मैं अक्सर एक छोटी उपयोगिता फ़ंक्शन लिखता हूं जब मुझे कॉमन्स io या इस तरह की आवश्यकता नहीं होती है। यहाँ एक स्ट्रिंग बफर में फ़ाइल की सामग्री को लोड करने के लिए कोड है:
StringBuffer sb = new StringBuffer();
BufferedReader br = new BufferedReader(new InputStreamReader(getClass().getResourceAsStream("path/to/textfile.txt"), "UTF-8"));
for (int c = br.read(); c != -1; c = br.read()) sb.append((char)c);
System.out.println(sb.toString());
एन्कोडिंग को निर्दिष्ट करना है , उस मामले में महत्वपूर्ण है क्योंकि आप UTF-8 में अपनी फ़ाइल संपादित हो सकता है, और फिर एक जार में डाल दिया, और कंप्यूटर फ़ाइल को खोलता है कि सीपी-1251 अपने मूल फ़ाइल एन्कोडिंग के रूप में हो सकता है (उदाहरण के लिए) ; इसलिए इस मामले में आप लक्ष्य एन्कोडिंग को कभी नहीं जानते हैं, इसलिए स्पष्ट एन्कोडिंग जानकारी महत्वपूर्ण है। इसके अलावा लूप चार्ज द्वारा चार को पढ़ने के लिए अक्षम लगता है, लेकिन इसका उपयोग बफ़रडेडर पर किया जाता है, और इसलिए वास्तव में काफी तेज़ है।
आप निम्न कोड फ़ॉर्म जावा का उपयोग कर सकते हैं
new String(Files.readAllBytes(Paths.get(getClass().getResource("example.txt").toURI())));
यदि आप अपने स्ट्रिंग को किसी प्रोजेक्ट संसाधन से प्राप्त करना चाहते हैं जैसे फ़ाइल टेस्टकेस / foo.json in src / main / resource अपनी परियोजना में, ऐसा करें:
String myString=
new String(Files.readAllBytes(Paths.get(getClass().getClassLoader().getResource("testcase/foo.json").toURI())));
ध्यान दें कि getClassLoader () विधि कुछ अन्य उदाहरणों पर गायब है।
अपाचे कॉमन्स FileUtils का उपयोग करें। यह एक विधि readFileToString है
मैं निम्नलिखित से संसाधन फ़ाइलों को पढ़ने के लिए उपयोग कर रहा हूं classpath
:
import java.io.IOException;
import java.io.InputStream;
import java.net.URISyntaxException;
import java.util.Scanner;
public class ResourceUtilities
{
public static String resourceToString(String filePath) throws IOException, URISyntaxException
{
try (InputStream inputStream = ResourceUtilities.class.getClassLoader().getResourceAsStream(filePath))
{
return inputStreamToString(inputStream);
}
}
private static String inputStreamToString(InputStream inputStream)
{
try (Scanner scanner = new Scanner(inputStream).useDelimiter("\\A"))
{
return scanner.hasNext() ? scanner.next() : "";
}
}
}
किसी तीसरे पक्ष की निर्भरता की आवश्यकता नहीं है।
स्थैतिक आयात के सेट के साथ, अमरूद का घोल एक-एक लाइनर हो सकता है:
toString(getResource("foo.txt"), UTF_8);
निम्नलिखित आयात आवश्यक हैं:
import static com.google.common.io.Resources.getResource
import static com.google.common.io.Resources.toString
import static java.nio.charset.StandardCharsets.UTF_8
package test;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
try {
String fileContent = getFileFromResources("resourcesFile.txt");
System.out.println(fileContent);
} catch (Exception e) {
e.printStackTrace();
}
}
//USE THIS FUNCTION TO READ CONTENT OF A FILE, IT MUST EXIST IN "RESOURCES" FOLDER
public static String getFileFromResources(String fileName) throws Exception {
ClassLoader classLoader = Main.class.getClassLoader();
InputStream stream = classLoader.getResourceAsStream(fileName);
String text = null;
try (Scanner scanner = new Scanner(stream, StandardCharsets.UTF_8.name())) {
text = scanner.useDelimiter("\\A").next();
}
return text;
}
}
कम से कम अपाचे कॉमन्स-ओयो 2.5 के रूप में, IOUtils.toString () विधि एक यूआरआई तर्क का समर्थन करती है और क्लासपथ पर जार के अंदर स्थित फ़ाइलों की सामग्री लौटाती है:
IOUtils.toString(SomeClass.class.getResource(...).toURI(), ...)
मुझे स्टूपिड स्कैनर ट्रिक के साथ अकोसिक्की का जवाब पसंद है। यह सबसे सरल है जो मैं बाहरी निर्भरता के बिना देखता हूं जो जावा 8 में काम करता है (और वास्तव में सभी जावा 5 पर वापस जाता है)। यदि आप जावा 9 या उच्चतर का उपयोग कर सकते हैं तो इसका और भी सरल उत्तर है (चूंकि InputStream.readAllBytes()
जावा 9 में जोड़ा गया था):
String text = new String(AppropriateClass.class.getResourceAsStream("foo.txt").readAllBytes());
अमरूद भी Files.readLines()
अगर आप List<String>
लाइन-बाय-लाइन के रूप में रिटर्न वैल्यू चाहते हैं :
List<String> lines = Files.readLines(new File("/file/path/input.txt"), Charsets.UTF_8);
पाठ फ़ाइल से प्राप्त करने के लिए कृपया 3 तरीकों ( बनाम अमरूद बनाम अमरूद ) की तुलना करने के लिए यहां देखें ।BufferedReader
Files
Resources
String
Charsets
भी अमरूद में है। इसे देखें: google.github.io/guava/releases/23.0/api/docs
यहाँ मेरा दृष्टिकोण ठीक काम किया है
public String getFileContent(String fileName) {
String filePath = "myFolder/" + fileName+ ".json";
try(InputStream stream = Thread.currentThread().getContextClassLoader().getResourceAsStream(filePath)) {
return IOUtils.toString(stream, "UTF-8");
} catch (IOException e) {
// Please print your Exception
}
}
मैंने यहाँ readResource () विधियाँ लिखी हैं , एक सरल आह्वान में इसे करने में सक्षम होने के लिए। यह अमरूद लाइब्रेरी पर निर्भर करता है, लेकिन मुझे अन्य उत्तरों में सुझाए गए JDK- केवल तरीके पसंद हैं और मुझे लगता है कि मैं इन तरीकों को बदल दूंगा।
यहाँ जावा 11 का उपयोग कर एक समाधान है Files.readString
:
public class Utils {
public static String readResource(String name) throws URISyntaxException, IOException {
var uri = Utils.class.getResource("/" + name).toURI();
var path = Paths.get(uri);
return Files.readString(path);
}
}
मैंने इस तरह सं-निर्भरता स्थिर विधि बनाई:
import java.nio.file.Files;
import java.nio.file.Paths;
public class ResourceReader {
public static String asString(String resourceFIleName) {
try {
return new String(Files.readAllBytes(Paths.get(new CheatClassLoaderDummyClass().getClass().getClassLoader().getResource(resourceFIleName).toURI())));
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
class CheatClassLoaderDummyClass{//cheat class loader - for sql file loading
}
मैं इस तरह के सामान के लिए अपाचे कॉमन्स के बर्तन पसंद करता हूं और परीक्षण करते समय इस सटीक उपयोग-केस (क्लासपाथ से फाइलें पढ़ना) का बड़े पैमाने पर उपयोग करता हूं, विशेष /src/test/resources
रूप से यूनिट / एकीकरण परीक्षण के हिस्से के रूप में JSON फ़ाइलों को पढ़ने के लिए । जैसे
public class FileUtils {
public static String getResource(String classpathLocation) {
try {
String message = IOUtils.toString(FileUtils.class.getResourceAsStream(classpathLocation),
Charset.defaultCharset());
return message;
}
catch (IOException e) {
throw new RuntimeException("Could not read file [ " + classpathLocation + " ] from classpath", e);
}
}
}
परीक्षण के प्रयोजनों के लिए, इसे पकड़ना IOException
और फेंकना अच्छा हो सकता है RuntimeException
- आपका परीक्षण वर्ग उदाहरण की तरह दिख सकता है
@Test
public void shouldDoSomething () {
String json = FileUtils.getResource("/json/input.json");
// Use json as part of test ...
}
public static byte[] readResoureStream(String resourcePath) throws IOException {
ByteArrayOutputStream byteArray = new ByteArrayOutputStream();
InputStream in = CreateBffFile.class.getResourceAsStream(resourcePath);
//Create buffer
byte[] buffer = new byte[4096];
for (;;) {
int nread = in.read(buffer);
if (nread <= 0) {
break;
}
byteArray.write(buffer, 0, nread);
}
return byteArray.toByteArray();
}
Charset charset = StandardCharsets.UTF_8;
String content = new String(FileReader.readResoureStream("/resource/...*.txt"), charset);
String lines[] = content.split("\\n");