Kaynaktaki bir metin dosyasını bir String'e okumaya yardımcı olan herhangi bir yardımcı program var mı? Bunun popüler bir gereklilik olduğunu düşünüyorum, ancak Google'dan sonra herhangi bir yardımcı program bulamadım.

Evet, Guava bunu Resourcessınıfta sağlıyor. Örneğin:

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

Bunu yapmak için eski Stupid Scanner hile oneliner'ı guava gibi ek bir bağımlılık olmadan kullanabilirsiniz:

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

Çocuklar, gerçekten ihtiyacınız olmadığı sürece 3. parti eşyalarını kullanmayın. JDK'da zaten çok fazla işlevsellik var.

Java 7 için:

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

Saf ve basit, kavanoz dostu, Java 8+ çözümü

Java 8 veya üstünü kullanıyorsanız aşağıdaki basit yöntem işe yarayacaktır:

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

Ayrıca jar dosyalarındaki kaynaklarla da çalışır .

Metin kodlaması hakkında: InputStreamReaderbir tane belirtmemeniz durumunda varsayılan sistem karakter kümesini kullanır. Aşağıdaki gibi kod çözme sorunlarından kaçınmak için kendiniz belirtmek isteyebilirsiniz:

new InputStreamReader(isr, StandardCharsets.UTF_8);

Gereksiz bağımlılıklardan kaçının

Her zaman büyük, şişman kütüphanelere bağlı kalmamayı tercih edin. Zaten başka görevler için Guava veya Apache Commons IO kullanmıyorsanız, bu kütüphaneleri bir dosyadan okuyabilmek için projenize eklemek biraz fazla görünüyor.

"Basit" yöntem? Benimle dalga geçiyor olmalısın

Bu gibi basit görevler söz konusu olduğunda saf Java'nın iyi bir iş yapmadığını anlıyorum. Örneğin, Node.js'deki bir dosyadan şu şekilde okuyoruz:

const fs = require("fs");
const contents = fs.readFileSync("some-file.txt", "utf-8");

Basit ve okunması kolay (insanlar yine de çoğunlukla cehalet nedeniyle birçok bağımlılığa güvenmek ister). Veya Python'da:

with open('some-file.txt', 'r') as f:
    content = f.read()

Üzücü, ama Java'nın standartları için hala basit ve tek yapmanız gereken yukarıdaki yöntemi projenize kopyalayıp kullanmak. Orada neler olup bittiğini anlamanızı bile istemiyorum, çünkü bu gerçekten kimsenin önemi yok. Sadece çalışıyor, nokta :-)

Guava , bir dosyayı bir String'e okumak için "toString" yöntemine sahiptir:

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

Bu yöntem, dosyanın sınıf yolunda olmasını gerektirmez ( önceki Jon Skeet yanıtında olduğu gibi).

yegor256 , Apache Commons IO kullanarak güzel bir çözüm buldu :

import org.apache.commons.io.IOUtils;

String text = IOUtils.toString(this.getClass().getResourceAsStream("foo.xml"),
                               "UTF-8");

apache-commons-io bir yardımcı program adına sahiptir FileUtils:

URL url = Resources.getResource("myFile.txt");
File myFile = new File(url.toURI());

String content = FileUtils.readFileToString(myFile, "UTF-8");  // or any other encoding

Sık sık bu problemi kendim yaşadım. Küçük projelere bağımlılıklardan kaçınmak için, ortak kullanıma veya başka bir şeye ihtiyacım olmadığında genellikle küçük bir yardımcı program işlevi yazarım. Dosyanın içeriğini bir dize arabelleğine yüklemek için kod:

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

Kodlamayı belirtilmesi olan UTF-8 dosyanızı düzenlenmiş ve daha sonra bir kavanoza koyun ve dosyayı açar bilgisayar CP-1251 onun doğal dosya kodlama olarak sahip olabilir olabilir, çünkü bu durumda önemli (örneğin) ; bu nedenle hedef kodlamayı asla bilemezsiniz, bu nedenle açık kodlama bilgileri çok önemlidir. Ayrıca char'ı char ile okumak için döngü verimsiz görünüyor, ancak bir BufferedReader'da kullanılıyor ve bu yüzden oldukça hızlı.

Aşağıdaki kod formunu Java kullanabilirsiniz

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

Dizenizi, projenizdeki src / main / resources içindeki testcase / foo.json gibi bir proje kaynağından almak istiyorsanız, şunu yapın:

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

Bazı örneklerde getClassLoader () yönteminin eksik olduğunu unutmayın.

Apache ortaklarının FileUtils'ini kullanın. ReadFileToString yöntemine sahip

Kaynak dosyaları okumak için aşağıdakileri kullanıyorum 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() : "";
        }
    }
}

Üçüncü taraf bağımlılığı gerekmez.

Statik ithalat seti ile Guava çözümü çok kompakt bir astar olabilir:

toString(getResource("foo.txt"), UTF_8);

Aşağıdaki ithalatlar gereklidir:

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

En azından Apache commons-io 2.5'den itibaren, IOUtils.toString () yöntemi bir URI bağımsız değişkenini destekler ve sınıfyolundaki kavanozların içinde bulunan dosyaların içeriğini döndürür:

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

Akosicki'nin Stupid Scanner Trick ile cevabını seviyorum. Java 8'de çalışan dış bağımlılıklar olmadan gördüğüm en basit şey (ve aslında Java 5'e kadar). Java 9 veya üstünü kullanabiliyorsanız (Java 9'daInputStream.readAllBytes() eklendiğinden beri) daha da basit bir cevap :

String text = new String(AppropriateClass.class.getResourceAsStream("foo.txt").readAllBytes());

Guava ayrıca satır satır satır Files.readLines()olarak bir dönüş değeri istiyorsanız List<String>:

List<String> lines = Files.readLines(new File("/file/path/input.txt"), Charsets.UTF_8);

Bir metin dosyasından ulaşmak için 3 yolu ( Guava'ya karşı Guava'ya karşı ) karşılaştırmak için lütfen buraya bakın .BufferedReaderFilesResourcesString

İşte yaklaşımım iyi çalıştı

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

Ben basit bir çağrıda yapabilmek için, burada readResource () yöntemleri yazdım . Bu Guava kütüphanesine bağlıdır, ancak diğer cevaplarda önerilen yalnızca JDK yöntemlerini seviyorum ve bunları bu şekilde değiştireceğim.

Guava'yı eklerseniz şunları kullanabilirsiniz:

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

(Diğer çözümler Guava için başka bir yöntemden bahsetmiştir ancak kullanımdan kaldırılmıştır)

Aşağıdaki kodlar benim için çalışıyor:

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'leri kullanan bir çözüm 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);
    }
}

Böyle NO bağımlılık statik yöntem yaptı:

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 bu tür şeyler için araçlar gibi ve test ederken, özellikle /src/test/resourcesbirim / entegrasyon testinin bir parçası olarak JSON dosyalarını okumak için bu sınıf tam olarak kullanmak (sınıf yolundan dosyaları okuma) yaygın kullanın . Örneğin

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

}

Test amacıyla, yakalamak IOExceptionve atmak güzel olabilir RuntimeException- test sınıfınız örn.

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