Ổi tương đương cho IOUtils.toString (InputStream)

Apache Commons IO có một phương thức tiện lợi IOUtils.toString () để đọc InputStreammột chuỗi.

Vì tôi đang cố gắng di chuyển khỏi Apache Commons và đến Guava : có loại tương đương trong Guava không? Tôi đã xem xét tất cả các lớp trong com.google.common.iogói và tôi không thể tìm thấy thứ gì gần như đơn giản.

Chỉnh sửa: Tôi hiểu và đánh giá cao các vấn đề với bảng mã. Điều xảy ra là tôi biết rằng tất cả các nguồn của tôi đều ở dạng ASCII (vâng, ASCII, không phải ANSI, v.v.), vì vậy trong trường hợp này, mã hóa không phải là vấn đề đối với tôi.

Bạn đã nêu trong bình luận của mình về câu trả lời của Calum rằng bạn sẽ sử dụng

CharStreams.toString(new InputStreamReader(supplier.get(), Charsets.UTF_8))

Mã này có vấn đề vì trạng CharStreams.toString(Readable)thái quá tải :

Không đóng Readable.

Điều này có nghĩa là của bạn InputStreamReadervà theo phần mở rộng được InputStreamtrả về supplier.get(), sẽ không bị đóng sau khi mã này hoàn thành.

Mặt khác, nếu bạn lợi dụng thực tế là bạn đã có InputSupplier<InputStream>và sử dụng quá tải CharStreams.toString(InputSupplier<R extends Readable & Closeable>), toStringphương thức sẽ xử lý cả việc tạo và đóng Readercho bạn.

Đây chính xác là những gì Jon Skeet đề xuất, ngoại trừ việc thực sự không có bất kỳ quá tải CharStreams.newReaderSuppliernào lấy một InputStreamđầu vào làm đầu vào ... bạn phải cung cấp cho nó một InputSupplier:

InputSupplier<? extends InputStream> supplier = ...
InputSupplier<InputStreamReader> readerSupplier = 
    CharStreams.newReaderSupplier(supplier, Charsets.UTF_8);

// InputStream and Reader are both created and closed in this single call
String text = CharStreams.toString(readerSupplier);

Mục đích InputSupplierlà làm cho cuộc sống của bạn dễ dàng hơn bằng cách cho phép Guava xử lý các phần yêu cầu một try-finallykhối xấu xí để đảm bảo rằng các tài nguyên được đóng đúng cách.

Chỉnh sửa: Cá nhân tôi thấy điều sau (đó là cách tôi thực sự viết nó, chỉ là chia nhỏ các bước trong đoạn mã ở trên)

String text = CharStreams.toString(
    CharStreams.newReaderSupplier(supplier, Charsets.UTF_8));

là xa ít tiết hơn này:

String text;
InputStreamReader reader = new InputStreamReader(supplier.get(), 
    Charsets.UTF_8);
boolean threw = true;
try {
  text = CharStreams.toString(reader);
  threw = false;
}
finally {
  Closeables.close(reader, threw);
}

Đó là ít nhiều những gì bạn phải viết để tự xử lý việc này đúng cách.

Chỉnh sửa: Tháng 2 năm 2014

InputSuppliervà OutputSuppliercác phương pháp sử dụng chúng đã không được chấp nhận trong Guava 16.0. Thay thế của họ là ByteSource, CharSource, ByteSinkvà CharSink. Với một ByteSource, bây giờ bạn có thể nhận được nội dung của nó Stringnhư sau:

ByteSource source = ...
String text = source.asCharSource(Charsets.UTF_8).read();

Nếu bạn có một, Readablebạn có thể sử dụng CharStreams.toString(Readable). Vì vậy, bạn có thể làm như sau:

String string = CharStreams.toString( new InputStreamReader( inputStream, "UTF-8" ) );

Buộc bạn chỉ định một bộ ký tự, mà tôi đoán bạn nên làm theo cách nào đó.

CẬP NHẬT : Nhìn lại, tôi không thích giải pháp cũ của mình. Bên cạnh đó, bây giờ là năm 2013 và hiện có nhiều lựa chọn thay thế tốt hơn cho Java7. Vì vậy, đây là những gì tôi sử dụng bây giờ:

InputStream fis = ...;
String text;
try (  InputStreamReader reader = new InputStreamReader(fis, Charsets.UTF_8)){
        text = CharStreams.toString(reader);
}

hoặc nếu với InputSupplier

InputSupplier<InputStreamReader> spl = ...
try (  InputStreamReader reader = spl.getInput()){
        text = CharStreams.toString(reader);
    }

Gần. Bạn có thể sử dụng một cái gì đó như thế này:

InputSupplier<InputStreamReader> readerSupplier = CharStreams.newReaderSupplier
    (streamSupplier, Charsets.UTF_8);
String text = CharStreams.toString(readerSupplier);

Cá nhân tôi không nghĩ đó IOUtils.toString(InputStream)là "tốt đẹp" - bởi vì nó luôn sử dụng mã hóa mặc định của nền tảng, hầu như không bao giờ là những gì bạn muốn. Có một sự quá tải lấy tên của bảng mã, nhưng sử dụng tên không phải là một ý tưởng tuyệt vời IMO. Đó là lý do tại sao tôi thích Charsets.*.

CHỈNH SỬA: Không phải là ở trên cần một InputSupplier<InputStream>như streamSupplier. Tuy nhiên, nếu bạn đã có luồng, bạn có thể triển khai dễ dàng:

InputSupplier<InputStream> supplier = new InputSupplier<InputStream>() {
    @Override public InputStream getInput() {
        return stream;
    }
};

Một tùy chọn khác là đọc các byte từ Luồng và tạo Chuỗi từ chúng:

new String(ByteStreams.toByteArray(inputStream))
new String(ByteStreams.toByteArray(inputStream), Charsets.UTF_8)

Nó không phải là Ổi 'nguyên chất', nhưng nó ngắn hơn một chút.

Dựa trên câu trả lời được chấp nhận, đây là một phương thức tiện ích chế nhạo hành vi của IOUtils.toString()(và cả một phiên bản quá tải với một bộ ký tự). Phiên bản này nên an toàn, phải không?

public static String toString(final InputStream is) throws IOException{
    return toString(is, Charsets.UTF_8);
}


public static String toString(final InputStream is, final Charset cs)
throws IOException{
    Closeable closeMe = is;
    try{
        final InputStreamReader isr = new InputStreamReader(is, cs);
        closeMe = isr;
        return CharStreams.toString(isr);
    } finally{
        Closeables.closeQuietly(closeMe);
    }
}

Có giải pháp tự động đóng gói ngắn hơn nhiều trong trường hợp luồng đầu vào đến từ tài nguyên classpath:

URL resource = classLoader.getResource(path);
byte[] bytes = Resources.toByteArray(resource);
String text = Resources.toString(resource, StandardCharsets.UTF_8);

Sử dụng Tài nguyên Ổi , lấy cảm hứng từ IOExplained .

CHỈNH SỬA (2015): Okio là công cụ và công cụ trừu tượng tốt nhất cho I / O trong Java / Android mà tôi biết. Tôi sử dụng nó mọi lúc.

FWIW đây là những gì tôi sử dụng.

Nếu tôi đã có một luồng trong tay, thì:

final InputStream stream; // this is received from somewhere
String s = CharStreams.toString(CharStreams.newReaderSupplier(new InputSupplier<InputStream>() {
    public InputStream getInput() throws IOException {
        return stream;
    }
}, Charsets.UTF_8));

Nếu tôi đang tạo luồng:

String s = CharStreams.toString(CharStreams.newReaderSupplier(new InputSupplier<InputStream>() {
    public InputStream getInput() throws IOException {
        return <expression creating the stream>;
    }
}, Charsets.UTF_8));

Như một ví dụ cụ thể, tôi có thể đọc nội dung tệp văn bản Android như sau:

final Context context = ...;
String s = CharStreams.toString(CharStreams.newReaderSupplier(new InputSupplier<InputStream>() {
    public InputStream getInput() throws IOException {
        return context.getAssets().open("my_asset.txt");
    }
}, Charsets.UTF_8));

Đối với một ví dụ cụ thể, đây là cách tôi có thể đọc nội dung tệp văn bản Android:

public static String getAssetContent(Context context, String file) {
    InputStreamReader reader = null;
    InputStream stream = null;
    String output = "";

    try {
        stream = context.getAssets().open(file);
        reader = new InputStreamReader(stream, Charsets.UTF_8);
        output = CharStreams.toString(reader);
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (stream != null) {
            try {
                stream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        if (reader != null) {
            try {
                reader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    return output;
}