리소스의 텍스트 파일을 문자열로 읽는 데 도움이되는 유틸리티가 있습니까? 나는 이것이 대중적인 요구 사항이라고 생각하지만 인터넷 검색 후 유틸리티를 찾을 수 없습니다.

예, 구아바 는 Resources수업 시간에 이것을 제공합니다 . 예를 들면 다음과 같습니다.

URL url = Resources.getResource("foo.txt");
String text = Resources.toString(url, StandardCharsets.UTF_8);

구아바와 같은 추가 종속성없이 이전 Stupid Scanner 트릭 oneliner를 사용할 수 있습니다 .

String text = new Scanner(AppropriateClass.class.getResourceAsStream("foo.txt"), "UTF-8").useDelimiter("\\A").next();

여러분, 정말로 필요하지 않은 한 타사 제품을 사용하지 마십시오. JDK에는 이미 많은 기능이 있습니다.

자바 7의 경우 :

new String(Files.readAllBytes(Paths.get(getClass().getResource("foo.txt").toURI())));

순수하고 단순하며 항아리 친화적 인 Java 8+ 솔루션

아래의 간단한 방법은 Java 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()));
        }
    }
}

또한 jar 파일의 리소스와 함께 작동합니다 .

텍스트 인코딩 정보 : InputStreamReader지정하지 않은 경우 기본 시스템 문자 세트를 사용합니다. 다음과 같이 디코딩 문제를 피하기 위해 직접 지정할 수 있습니다.

new InputStreamReader(isr, StandardCharsets.UTF_8);

불필요한 의존성을 피하십시오

항상 크고 뚱뚱한 라이브러리에 의존하지 않는 것이 좋습니다. 다른 작업에 이미 Guava 또는 Apache Commons IO를 사용하지 않는 한 파일에서 읽을 수 있도록 해당 라이브러리를 프로젝트에 추가하는 것은 너무 많은 것 같습니다.

"간단한"방법? 농담 해

나는 순수한 Java가 이와 같은 간단한 작업을 수행 할 때 잘 작동하지 않는다는 것을 이해합니다. 예를 들어, 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()

슬프지만 Java 표준에서는 여전히 간단하며 위의 방법을 프로젝트에 복사하여 사용하기 만하면됩니다. 나는 거기에서 무슨 일이 일어나고 있는지 이해하지 않아도됩니다. 왜냐하면 그것은 누구에게나 중요하지 않기 때문입니다. 그냥 작동합니다. 기간 :-)

구아바 에는 파일을 문자열로 읽는 "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);

이 방법은 파일이 클래스 경로에 있어야 할 필요는 없습니다 ( Jon Skeet 이전 답변 에서와 같이 ).

yegor256 은 Apache Commons IO를 사용하여 훌륭한 솔루션을 찾았습니다 .

import org.apache.commons.io.IOUtils;

String text = IOUtils.toString(this.getClass().getResourceAsStream("foo.xml"),
                               "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

나는 종종이 문제를 스스로했다. 작은 프로젝트에 대한 의존성을 피하기 위해 공통점이 필요하지 않을 때 종종 작은 유틸리티 함수를 작성합니다. 다음은 파일의 내용을 문자열 버퍼에로드하는 코드입니다.

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로 편집 한 후 jar 파일에 넣고 파일을 여는 컴퓨터에 CP-1251이 기본 파일 인코딩으로있을 수 있기 때문입니다. ; 따라서이 경우 대상 인코딩을 알 수 없으므로 명시 적 인코딩 정보가 중요합니다. 또한 char로 파일 char를 읽는 루프는 비효율적이지만 BufferedReader에서 사용되므로 실제로 매우 빠릅니다.

다음 코드 양식 Java를 사용할 수 있습니다

new String(Files.readAllBytes(Paths.get(getClass().getResource("example.txt").toURI())));

프로젝트의 src / main / resources에있는 testcase / foo.json 파일과 같은 프로젝트 리소스에서 문자열을 가져 오려면 다음과 같이하십시오.

String myString= 
 new String(Files.readAllBytes(Paths.get(getClass().getClassLoader().getResource("testcase/foo.json").toURI())));

getClassLoader () 메소드는 다른 예제 중 일부에서 누락되었습니다.

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

타사 종속성이 필요하지 않습니다.

정적 수입 세트를 통해 Guava 솔루션은 매우 컴팩트 한 단일 라이너가 될 수 있습니다.

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

적어도 Apache commons-io 2.5에서 IOUtils.toString () 메소드는 URI 인수를 지원하고 클래스 경로의 jar 내에있는 파일의 컨텐츠를 리턴합니다.

IOUtils.toString(SomeClass.class.getResource(...).toURI(), ...)

나는 Stupid Scanner Trick에 대한 akosicki의 대답을 좋아합니다. Java 8에서 작동하는 외부 종속성없이 실제로 볼 수있는 가장 간단합니다 (실제로 Java 5로 돌아갑니다). Java 9 이상을 사용할 수 있다면 더 간단한 대답 이 있습니다 ( InputStream.readAllBytes()Java 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 가지 방법 ( 대 구아바 대 구아바 )을 비교 하려면 여기 를 참조하십시오 .BufferedReaderFilesResourcesString

여기 내 접근 방식이 제대로 작동했습니다.

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 () 메소드를 작성 했습니다. 그것은 Guava 라이브러리에 달려 있지만 다른 답변에서 제안 된 JDK 전용 방법을 좋아하며 이러한 방식으로 변경할 것이라고 생각합니다.

구아바를 포함하면 다음을 사용할 수 있습니다.

String fileContent = Files.asCharSource(new File(filename), Charset.forName("UTF-8")).read();

(다른 솔루션은 Guava에 대한 다른 방법을 언급했지만 더 이상 사용되지 않습니다)

다음 코드는 나를 위해 작동합니다.

compile group: 'commons-io', name: 'commons-io', version: '2.6'

@Value("classpath:mockResponse.json")
private Resource mockResponse;

String mockContent = FileUtils.readFileToString(mockResponse.getFile(), "UTF-8");

다음은 Java 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);
    }
}

나는 다음과 같이 NO 의존성 정적 방법을 만들었습니다.

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
}

필자는 이러한 유형의 물건에 대해 Apache commons utils를 좋아하고 특히 /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");