Как мне прочитать / преобразовать InputStream в строку в Java?

avatar
Johnny Maelstrom
21 ноября 2008 в 16:47
2305551
63
4369

Если у вас есть объект java.io.InputStream, как вы должны обработать этот объект и создать String?


Предположим, у меня есть InputStream, который содержит текстовые данные, и я хочу преобразовать его в String, поэтому, например, я могу записать это в файл журнала.

Как проще всего взять InputStream и преобразовать его в String?

public String convertStreamToString(InputStream is) {
    // ???
}
Источник
Kevin Anderson
8 октября 2020 в 14:02
0

Отвечает ли это на ваш вопрос? Сканер пропускает nextLine () после использования next () или nextFoo ()?

Thorbjørn Ravn Andersen
30 октября 2020 в 09:52
0

Помните, что вам нужно учитывать кодировку входного потока. Системный параметр по умолчанию не всегда тот, который вам нужен.

Shmuel Newmark
28 мая 2021 в 21:19
0

Большинство этих ответов были написаны до Java 9, но теперь вы можете получить массив байтов из InputStream с помощью .readAllBytes. Итак, просто «new String (inputStream.readAllBytes ())» работает с использованием конструктора String byte [].

Ответы (63)

avatar
Harry Lime
21 ноября 2008 в 16:54
2706

Хороший способ сделать это - использовать Apache Commons IOUtils, чтобы скопировать InputStream в StringWriter ... что-то вроде

StringWriter writer = new StringWriter();
IOUtils.copy(inputStream, writer, encoding);
String theString = writer.toString();

или даже

// NB: does not close inputStream, you'll have to use try-with-resources for that
String theString = IOUtils.toString(inputStream, encoding); 

В качестве альтернативы вы можете использовать ByteArrayOutputStream, если вы не хотите смешивать свои потоки и писатели

RCB
2 июля 2020 в 15:26
0

ToString устарел? Я вижу IOUtils.convertStreamToString()

Timothy
6 июля 2021 в 00:03
0

Я добавил правку, чтобы включить в качестве ссылки доступную для поиска ссылку на сам исходный код. Я считаю, что это дополняет ответ для тех, кто хочет увидеть, как работает команда.

avatar
hertzsprung
25 апреля 2022 в 15:56
0

Если вы используете AWS SDK v2, вызовите IoUtils.toUtf8String():

public String convertStreamToString(InputStream is) {
    return IoUtils.toUtf8String(is);
}
avatar
somayaj
6 ноября 2021 в 16:34
-2

самый простой способ, однострочник

 public static void main(String... args) throws IOException {
        System.out.println(new String(Files.readAllBytes(Paths.get("csv.txt"))));
    }
avatar
NoisyBoy
13 сентября 2021 в 21:13
-2
Dont want anyone to waste time on reading such structured response

Just showing signature of get api method
getMyData(KeyValueObject<String, List<String>> input){} which returns List<KeyValueObject<String, String>>
where KVO is like this

public class KeyValueObject<T, K> {
  private T key;
  private K value;
}

to make a call from another api and reading response 

Response response = ClientBuilder.newClient()
                    .target("https:/something")
                    .request(MediaType.APPLICATION_JSON)
.put(Entity.json(new KeyValueObject<>()));

            if (response != null && response.getStatus() == 200) {
                @SuppressWarnings("unchecked")
                KeyValueObject<String, String>[] output= response.readEntity(KeyValueObject[].class);
                
            }
J. Doe
14 сентября 2021 в 11:36
1

Это буквально 0,0 связано с вопросом

Celery01
2 декабря 2021 в 10:23
0

Это ответ бота? Вам лучше придумать свой алгоритм.

avatar
Kaplan
12 декабря 2020 в 13:50
2

, если вам нужно преобразовать строку в определенный набор символов без внешних библиотек затем :

public String convertStreamToString(InputStream is) throws IOException {
  try (ByteArrayOutputStream baos = new ByteArrayOutputStream();) {
    is.transferTo(baos);
    return baos.toString(StandardCharsets.UTF_8);
  }
}
avatar
czerny
5 апреля 2020 в 00:03
14
String inputStreamToString(InputStream inputStream, Charset charset) throws IOException {
    try (
            final StringWriter writer = new StringWriter();
            final InputStreamReader reader = new InputStreamReader(inputStream, charset)
        ) {
        reader.transferTo(writer);
        return writer.toString();
    }
}
  • чистая стандартная библиотека Java - без библиотек
  • начиная с Java 10 - Reader # transferTo (java.io.Writer)
  • решение без петель
  • нет обработки символа новой строки
avatar
user12402945
20 ноября 2019 в 12:49
2

Этот код предназначен для начинающих изучать Java:

     private String textDataFromFile;

public String getFromFile(InputStream myInputStream) throws FileNotFoundException, IOException {

      BufferedReader bufferReader = new BufferedReader (new InputStreamReader(myInputStream));

       StringBuilder stringBuilder = new StringBuilder();

  String eachStringLine;

    while((eachStringLine=bufferReader.readLine()) != null){          
        stringBuilder.append(eachStringLine).append("\n");
    }

   textDataFromFile = stringBuilder.toString(); 



  return textDataFromFile;

}
avatar
Hasee Amarathunga
28 марта 2019 в 08:49
0

Я предлагаю класс StringWriter для решения этой проблемы.

StringWriter wt= new StringWriter();
IOUtils.copy(inputStream, wt, encoding);
String st= wt.toString();

toolforger
22 января 2020 в 08:29
0

В IOUtils для этого есть более простая функция.

avatar
Hans Brende
7 ноября 2018 в 23:21
2

ISO-8859-1

Вот очень способ сделать это, если вы знаете, что кодировка входного потока - ISO-8859-1 или ASCII. Он (1) избегает ненужной синхронизации, присутствующей во внутреннем массиве StringBuffer StringWriter, (2) избегает накладных расходов InputStreamReader, и (3) минимизирует количество раз, когда StringBuilder внутренний массив char необходимо скопировать.

public static String iso_8859_1(InputStream is) throws IOException {
    StringBuilder chars = new StringBuilder(Math.max(is.available(), 4096));
    byte[] buffer = new byte[4096];
    int n;
    while ((n = is.read(buffer)) != -1) {
        for (int i = 0; i < n; i++) {
            chars.append((char)(buffer[i] & 0xFF));
        }
    }
    return chars.toString();
}

UTF-8

Ту же общую стратегию можно использовать для потока, закодированного в UTF-8:

public static String utf8(InputStream is) throws IOException {
    StringBuilder chars = new StringBuilder(Math.max(is.available(), 4096));
    byte[] buffer = new byte[4096];
    int n;
    int state = 0;
    while ((n = is.read(buffer)) != -1) {
        for (int i = 0; i < n; i++) {
            if ((state = nextStateUtf8(state, buffer[i])) >= 0) {
                chars.appendCodePoint(state);
            } else if (state == -1) { //error
                state = 0;
                chars.append('\uFFFD'); //replacement char
            }
        }
    }
    return chars.toString();
}

где функция nextStateUtf8() определяется следующим образом:

/**
 * Returns the next UTF-8 state given the next byte of input and the current state.
 * If the input byte is the last byte in a valid UTF-8 byte sequence,
 * the returned state will be the corresponding unicode character (in the range of 0 through 0x10FFFF).
 * Otherwise, a negative integer is returned. A state of -1 is returned whenever an
 * invalid UTF-8 byte sequence is detected.
 */
static int nextStateUtf8(int currentState, byte nextByte) {
    switch (currentState & 0xF0000000) {
        case 0:
            if ((nextByte & 0x80) == 0) { //0 trailing bytes (ASCII)
                return nextByte;
            } else if ((nextByte & 0xE0) == 0xC0) { //1 trailing byte
                if (nextByte == (byte) 0xC0 || nextByte == (byte) 0xC1) { //0xCO & 0xC1 are overlong
                    return -1;
                } else {
                    return nextByte & 0xC000001F;
                }
            } else if ((nextByte & 0xF0) == 0xE0) { //2 trailing bytes
                if (nextByte == (byte) 0xE0) { //possibly overlong
                    return nextByte & 0xA000000F;
                } else if (nextByte == (byte) 0xED) { //possibly surrogate
                    return nextByte & 0xB000000F;
                } else {
                    return nextByte & 0x9000000F;
                }
            } else if ((nextByte & 0xFC) == 0xF0) { //3 trailing bytes
                if (nextByte == (byte) 0xF0) { //possibly overlong
                    return nextByte & 0x80000007;
                } else {
                    return nextByte & 0xE0000007;
                }
            } else if (nextByte == (byte) 0xF4) { //3 trailing bytes, possibly undefined
                return nextByte & 0xD0000007;
            } else {
                return -1;
            }
        case 0xE0000000: //3rd-to-last continuation byte
            return (nextByte & 0xC0) == 0x80 ? currentState << 6 | nextByte & 0x9000003F : -1;
        case 0x80000000: //3rd-to-last continuation byte, check overlong
            return (nextByte & 0xE0) == 0xA0 || (nextByte & 0xF0) == 0x90 ? currentState << 6 | nextByte & 0x9000003F : -1;
        case 0xD0000000: //3rd-to-last continuation byte, check undefined
            return (nextByte & 0xF0) == 0x80 ? currentState << 6 | nextByte & 0x9000003F : -1;
        case 0x90000000: //2nd-to-last continuation byte
            return (nextByte & 0xC0) == 0x80 ? currentState << 6 | nextByte & 0xC000003F : -1;
        case 0xA0000000: //2nd-to-last continuation byte, check overlong
            return (nextByte & 0xE0) == 0xA0 ? currentState << 6 | nextByte & 0xC000003F : -1;
        case 0xB0000000: //2nd-to-last continuation byte, check surrogate
            return (nextByte & 0xE0) == 0x80 ? currentState << 6 | nextByte & 0xC000003F : -1;
        case 0xC0000000: //last continuation byte
            return (nextByte & 0xC0) == 0x80 ? currentState << 6 | nextByte & 0x3F : -1;
        default:
            return -1;
    }
}

Автоопределение кодировки

Если ваш входной поток был закодирован с использованием ASCII, ISO-8859-1 или UTF-8, но вы не уверены, какой из них, мы можем использовать метод, аналогичный последнему, но с дополнительным компонентом обнаружения кодировки, чтобы автоматическое определение кодировки перед возвратом строки.

public static String autoDetect(InputStream is) throws IOException {
    StringBuilder chars = new StringBuilder(Math.max(is.available(), 4096));
    byte[] buffer = new byte[4096];
    int n;
    int state = 0;
    boolean ascii = true;
    while ((n = is.read(buffer)) != -1) {
        for (int i = 0; i < n; i++) {
            if ((state = nextStateUtf8(state, buffer[i])) > 0x7F)
                ascii = false;
            chars.append((char)(buffer[i] & 0xFF));
        }
    }

    if (ascii || state < 0) { //probably not UTF-8
        return chars.toString();
    }
    //probably UTF-8
    int pos = 0;
    char[] charBuf = new char[2];
    for (int i = 0, len = chars.length(); i < len; i++) {
        if ((state = nextStateUtf8(state, (byte)chars.charAt(i))) >= 0) {
            boolean hi = Character.toChars(state, charBuf, 0) == 2;
            chars.setCharAt(pos++, charBuf[0]);
            if (hi) {
                chars.setCharAt(pos++, charBuf[1]);
            }
        }
    }
    return chars.substring(0, pos);
}

Если ваш входной поток имеет кодировку, которая не является ни ISO-8859-1, ни ASCII, ни UTF-8, то я полагаюсь на другие уже имеющиеся ответы.

avatar
13hola
28 июня 2018 в 12:45
2

Я создал этот код, и он работает. Необходимые внешние плагины отсутствуют.

Существует преобразователь String в Stream и Stream в String:

import java.io.ByteArrayInputStream;
import java.io.InputStream;

public class STRINGTOSTREAM {

    public static void main(String[] args)
    {
        String text = "Hello Bhola..!\nMy Name Is Kishan ";

        InputStream strm = new ByteArrayInputStream(text.getBytes());    // Convert String to Stream

        String data = streamTostring(strm);

        System.out.println(data);
    }

    static String streamTostring(InputStream stream)
    {
        String data = "";

        try
        {
            StringBuilder stringbuld = new StringBuilder();
            int i;
            while ((i=stream.read())!=-1)
            {
                stringbuld.append((char)i);
            }
            data = stringbuld.toString();
        }
        catch(Exception e)
        {
            data = "No data Streamed.";
        }
        return data;
    }
avatar
drakeet
7 апреля 2018 в 12:53
3

С Okio:

String result = Okio.buffer(Okio.source(inputStream)).readUtf8();
avatar
Ilya Gazman
13 февраля 2018 в 21:30
57

Я провел тест на 14 различных ответах здесь (извините, что не предоставил кредиты, но есть слишком много дубликатов).

Результат очень удивительный. Оказывается, Apache IOUtils является самым медленным, а ByteArrayOutputStream - самым быстрым решением:

Итак, сначала рассмотрим лучший метод:

public String inputStreamToString(InputStream inputStream) throws IOException {
    try(ByteArrayOutputStream result = new ByteArrayOutputStream()) {
        byte[] buffer = new byte[1024];
        int length;
        while ((length = inputStream.read(buffer)) != -1) {
            result.write(buffer, 0, length);
        }

        return result.toString(UTF_8);
    }
}

Результаты теста, случайные байты 20 МБ за 20 циклов

Время в миллисекундах

  • ByteArrayOutputStreamTest: 194
  • NioStream: 198
  • Java9ISTransferTo: 201
  • Java9ISReadAllBytes: 205
  • BufferedInputStreamVsByteArrayOutputStream: 314
  • ApacheStringWriter2: 574
  • GuavaCharStreams: 589
  • ScannerReaderNoNextTest: 614
  • Считыватель сканера: 633
  • ApacheStringWriter: 1544
  • StreamApi: ошибка
  • ParallelStreamApi: ошибка
  • BufferReaderTest: ошибка
  • InputStreamAndStringBuilder: ошибка

Исходный код теста

import com.google.common.io.CharStreams;
import org.apache.commons.io.IOUtils;

import java.io.*;
import java.nio.ByteBuffer;
import java.nio.channels.Channels;
import java.nio.channels.ReadableByteChannel;
import java.nio.channels.WritableByteChannel;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
import java.util.stream.Collectors;

/**
 * Created by Ilya Gazman on 2/13/18.
 */
public class InputStreamToString {


    private static final String UTF_8 = "UTF-8";

    public static void main(String... args) {
        log("App started");
        byte[] bytes = new byte[1024 * 1024];
        new Random().nextBytes(bytes);
        log("Stream is ready\n");

        try {
            test(bytes);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void test(byte[] bytes) throws IOException {
        List<Stringify> tests = Arrays.asList(
                new ApacheStringWriter(),
                new ApacheStringWriter2(),
                new NioStream(),
                new ScannerReader(),
                new ScannerReaderNoNextTest(),
                new GuavaCharStreams(),
                new StreamApi(),
                new ParallelStreamApi(),
                new ByteArrayOutputStreamTest(),
                new BufferReaderTest(),
                new BufferedInputStreamVsByteArrayOutputStream(),
                new InputStreamAndStringBuilder(),
                new Java9ISTransferTo(),
                new Java9ISReadAllBytes()
        );

        String solution = new String(bytes, "UTF-8");

        for (Stringify test : tests) {
            try (ByteArrayInputStream inputStream = new ByteArrayInputStream(bytes)) {
                String s = test.inputStreamToString(inputStream);
                if (!s.equals(solution)) {
                    log(test.name() + ": Error");
                    continue;
                }
            }
            long startTime = System.currentTimeMillis();
            for (int i = 0; i < 20; i++) {
                try (ByteArrayInputStream inputStream = new ByteArrayInputStream(bytes)) {
                    test.inputStreamToString(inputStream);
                }
            }
            log(test.name() + ": " + (System.currentTimeMillis() - startTime));
        }
    }

    private static void log(String message) {
        System.out.println(message);
    }

    interface Stringify {
        String inputStreamToString(InputStream inputStream) throws IOException;

        default String name() {
            return this.getClass().getSimpleName();
        }
    }

    static class ApacheStringWriter implements Stringify {

        @Override
        public String inputStreamToString(InputStream inputStream) throws IOException {
            StringWriter writer = new StringWriter();
            IOUtils.copy(inputStream, writer, UTF_8);
            return writer.toString();
        }
    }

    static class ApacheStringWriter2 implements Stringify {

        @Override
        public String inputStreamToString(InputStream inputStream) throws IOException {
            return IOUtils.toString(inputStream, UTF_8);
        }
    }

    static class NioStream implements Stringify {

        @Override
        public String inputStreamToString(InputStream in) throws IOException {
            ReadableByteChannel channel = Channels.newChannel(in);
            ByteBuffer byteBuffer = ByteBuffer.allocate(1024 * 16);
            ByteArrayOutputStream bout = new ByteArrayOutputStream();
            WritableByteChannel outChannel = Channels.newChannel(bout);
            while (channel.read(byteBuffer) > 0 || byteBuffer.position() > 0) {
                byteBuffer.flip();  //make buffer ready for write
                outChannel.write(byteBuffer);
                byteBuffer.compact(); //make buffer ready for reading
            }
            channel.close();
            outChannel.close();
            return bout.toString(UTF_8);
        }
    }

    static class ScannerReader implements Stringify {

        @Override
        public String inputStreamToString(InputStream is) throws IOException {
            java.util.Scanner s = new java.util.Scanner(is).useDelimiter("\\A");
            return s.hasNext() ? s.next() : "";
        }
    }

    static class ScannerReaderNoNextTest implements Stringify {

        @Override
        public String inputStreamToString(InputStream is) throws IOException {
            java.util.Scanner s = new java.util.Scanner(is).useDelimiter("\\A");
            return s.next();
        }
    }

    static class GuavaCharStreams implements Stringify {

        @Override
        public String inputStreamToString(InputStream is) throws IOException {
            return CharStreams.toString(new InputStreamReader(
                    is, UTF_8));
        }
    }

    static class StreamApi implements Stringify {

        @Override
        public String inputStreamToString(InputStream inputStream) throws IOException {
            return new BufferedReader(new InputStreamReader(inputStream))
                    .lines().collect(Collectors.joining("\n"));
        }
    }

    static class ParallelStreamApi implements Stringify {

        @Override
        public String inputStreamToString(InputStream inputStream) throws IOException {
            return new BufferedReader(new InputStreamReader(inputStream)).lines()
                    .parallel().collect(Collectors.joining("\n"));
        }
    }

    static class ByteArrayOutputStreamTest implements Stringify {

        @Override
        public String inputStreamToString(InputStream inputStream) throws IOException {
            try(ByteArrayOutputStream result = new ByteArrayOutputStream()) {
                byte[] buffer = new byte[1024];
                int length;
                while ((length = inputStream.read(buffer)) != -1) {
                    result.write(buffer, 0, length);
                }

                return result.toString(UTF_8);
            }
        }
    }

    static class BufferReaderTest implements Stringify {

        @Override
        public String inputStreamToString(InputStream inputStream) throws IOException {
            String newLine = System.getProperty("line.separator");
            BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
            StringBuilder result = new StringBuilder(UTF_8);
            String line;
            boolean flag = false;
            while ((line = reader.readLine()) != null) {
                result.append(flag ? newLine : "").append(line);
                flag = true;
            }
            return result.toString();
        }
    }

    static class BufferedInputStreamVsByteArrayOutputStream implements Stringify {

        @Override
        public String inputStreamToString(InputStream inputStream) throws IOException {
            BufferedInputStream bis = new BufferedInputStream(inputStream);
            ByteArrayOutputStream buf = new ByteArrayOutputStream();
            int result = bis.read();
            while (result != -1) {
                buf.write((byte) result);
                result = bis.read();
            }

            return buf.toString(UTF_8);
        }
    }

    static class InputStreamAndStringBuilder implements Stringify {

        @Override
        public String inputStreamToString(InputStream inputStream) throws IOException {
            int ch;
            StringBuilder sb = new StringBuilder(UTF_8);
            while ((ch = inputStream.read()) != -1)
                sb.append((char) ch);
            return sb.toString();
        }
    }

    static class Java9ISTransferTo implements Stringify {

        @Override
        public String inputStreamToString(InputStream inputStream) throws IOException {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            inputStream.transferTo(bos);
            return bos.toString(UTF_8);
        }
    }

    static class Java9ISReadAllBytes implements Stringify {

        @Override
        public String inputStreamToString(InputStream inputStream) throws IOException {
            return new String(inputStream.readAllBytes(), UTF_8);
        }
    }

}
Dalibor
16 мая 2019 в 22:08
0

Создание тестов на Java - непростая задача (особенно из-за JIT). Прочитав исходный код Benchmark, я убедился, что приведенные выше значения неточны, и всем следует быть осторожными, веря им.

Ilya Gazman
28 мая 2019 в 14:06
0

@Dalibor вам, вероятно, следует предоставить больше аргументов в пользу своей претензии, чем просто ссылку.

Dalibor
29 мая 2019 в 22:04
0

Я думаю, что это действительно известный факт, что сделать свой собственный бенчмарк непросто. Для тех, кто этого не знает, есть ссылка;)

Ilya Gazman
29 мая 2019 в 23:56
0

@Dalibor Я, возможно, не лучший, но я хорошо разбираюсь в тестах производительности Java, поэтому, если вы не укажете конкретную проблему, вы просто вводите в заблуждение, и я не буду продолжать разговор с вами в таких условиях.

DavidS
15 ноября 2019 в 18:48
0

В основном я согласен с Далибором. Вы говорите, что «хорошо разбираетесь в тестах производительности Java», но, похоже, применили самый наивный подход, явно игнорируя хорошо известные проблемы этого подхода. Для начала прочтите все сообщения по этому вопросу: coderhelper.com/questions/504103/…

Ilya Gazman
15 ноября 2019 в 20:59
0

@DavidS мой тест соответствует правилам в исключенном ответе, который вы связали. Можете ли вы указать на какие-либо проблемы в моей реализации?

DavidS
15 ноября 2019 в 21:55
0

Из принятого ответа: Правило 0: прочтите статью, в которой, по сути, содержится предостережение от попыток проведения микротеста. Правило 1: У вас нет фазы разминки. Правило 2-3: Вы не указали, что использовали эти флаги. Правило 8: Используйте такую ​​библиотеку, как JMH. С 135 голосами в комментариях: Не используйте System.currentTimeMillis(). Переходим к другим высоко оцененным ответам. Джон Скит: используйте System.gc() между итерациями и запускайте тест достаточно долго, чтобы измерять результаты в секундах, а не в миллисекундах. Смешивание тестов в одном запуске JVM - это плохо, поскольку оптимизация компилятора, выполненная для одного теста, повлияет на другой.

DavidS
19 ноября 2019 в 21:26
0

У меня есть немного свободного времени, так что вот еще несколько. Правило 5: Вы включаете первую итерацию в свою временную фазу. Правило 6: Вы не использовали никаких специальных инструментов, чтобы «читать мысли компилятора». Правило 7. Вы не указали, что использовали эти флаги. Думаю, это все. Я думаю, что это все правила, кроме правила 4.

Ilya Gazman
20 ноября 2019 в 03:36
0

Правило @DavidS 0,8: Как я уже упоминал, я знаю, что делаю, поэтому это здесь не применимо, есть несколько способов делать что-то. Правило 1: конечно, читаю мой код внимательнее, тест вызывается до того, как таймер начнет работать! Что касается System.gc (), это просто подсказка для системы, вы не можете доверять ей что-либо.

Ilya Gazman
20 ноября 2019 в 03:38
0

@DavidS, если вы не согласны с моей реализацией, запустите свой собственный тест, используя любую библиотеку, которую вы хотите, и приведите свои результаты здесь. Я буду счастлив сравнить

DavidS
20 ноября 2019 в 18:02
0

Вы просили меня указать на проблемы. Я так и сделал. Я почти закончил уговаривать вас, но мы идем еще раз. Правило 1. Одна итерация - это не «разминка»: JIT-компилятор оптимизирует не одну, а тысячи итераций. System.gc - это всего лишь подсказка, но она очень надежная и улучшит ваши тесты. Наконец, вы игнорируете все остальные моменты: флаги компилятора, currentTimeMillis, разделение тестов на несколько запусков JVM. Это серьезные проблемы с вашей попыткой тестирования производительности. Я не придумывал их сам: это хорошо известные практики и инструменты.

Ilya Gazman
20 ноября 2019 в 21:16
0

@DavidS Я думаю, ты скучаешь по этому поводу. Проверьте размер ввода. Это 1-мегабайтный массив байтов. Итерация по нему один раз означает, что реализация подчеркнутого потока будет делать много циклов.

DavidS
20 ноября 2019 в 21:32
0

Сколько петель на разминку? Будет ли количество циклов зависеть от используемого алгоритма? Достаточно ли этого, чтобы обеспечить оптимизацию JIT-компилятора? Как узнать, когда этого достаточно? Не лучше ли явно объявить фазу разминки с известным количеством итераций вместо того, чтобы полагаться на реализацию основного потока? Не лучше ли было бы использовать такой инструмент, как JMH, вместо того, чтобы пытаться учесть все это?

avatar
gil.fernandes
21 октября 2017 в 09:46
1

Это решение этого вопроса не самое простое, но поскольку потоки и каналы NIO не были упомянуты, вот версия, которая использует каналы NIO и ByteBuffer для преобразования потока в строку.

public static String streamToStringChannel(InputStream in, String encoding, int bufSize) throws IOException {
    ReadableByteChannel channel = Channels.newChannel(in);
    ByteBuffer byteBuffer = ByteBuffer.allocate(bufSize);
    ByteArrayOutputStream bout = new ByteArrayOutputStream();
    WritableByteChannel outChannel = Channels.newChannel(bout);
    while (channel.read(byteBuffer) > 0 || byteBuffer.position() > 0) {
        byteBuffer.flip();  //make buffer ready for write
        outChannel.write(byteBuffer);
        byteBuffer.compact(); //make buffer ready for reading
    }
    channel.close();
    outChannel.close();
    return bout.toString(encoding);
}

Вот пример его использования:

try (InputStream in = new FileInputStream("/tmp/large_file.xml")) {
    String x = streamToStringChannel(in, "UTF-8", 1);
    System.out.println(x);
}

Производительность этого метода должна быть хорошей для больших файлов.

avatar
yegor256
6 августа 2017 в 18:08
2

Вы можете использовать Cactoos:

String text = new TextOf(inputStream).asString();

Кодировка UTF-8 используется по умолчанию. Если вам нужен еще один:

String text = new TextOf(inputStream, "UTF-16").asString();
avatar
Halfacht
10 мая 2017 в 11:38
4

Рагху К. Наир Был единственным, кто использовал сканер. Код, который я использую, немного отличается:

String convertToString(InputStream in){
    Scanner scanner = new Scanner(in)
    scanner.useDelimiter("\\A");

    boolean hasInput = scanner.hasNext();
    if (hasInput) {
        return scanner.next();
    } else {
        return null;
    }

}

О разделителях: Как использовать разделитель в Java Scanner?

avatar
Snekse
26 января 2017 в 19:40
4

В Groovy

inputStream.getText()
avatar
Hao Zheng
9 января 2017 в 05:42
3
public String read(InputStream in) throws IOException {
    try (BufferedReader buffer = new BufferedReader(new InputStreamReader(in))) {
        return buffer.lines().collect(Collectors.joining("\n"));
    }
}
avatar
Raghu K Nair
9 августа 2016 в 20:18
10

Самый простой способ использовать JDK - использовать следующие фрагменты кода.

String convertToString(InputStream in){
    String resource = new Scanner(in).useDelimiter("\\Z").next();
    return resource;
}
avatar
James
29 июля 2016 в 20:58
17

Еще один, для всех пользователей Spring:

import java.nio.charset.StandardCharsets;
import org.springframework.util.FileCopyUtils;

public String convertStreamToString(InputStream is) throws IOException { 
    return new String(FileCopyUtils.copyToByteArray(is), StandardCharsets.UTF_8);
}

Служебные методы в org.springframework.util.StreamUtils аналогичны методам в FileCopyUtils, но по завершении они оставляют поток открытым.

avatar
Ravi
26 мая 2016 в 05:07
0

Также вы можете получить InputStream из указанного пути к ресурсу:

public static InputStream getResourceAsStream(String path)
{
    InputStream myiInputStream = ClassName.class.getResourceAsStream(path);
    if (null == myiInputStream)
    {
        mylogger.info("Can't find path = ", path);
    }

    return myiInputStream;
}

Чтобы получить InputStream по определенному пути:

public static URL getResource(String path)
{
    URL myURL = ClassName.class.getResource(path);
    if (null == myURL)
    {
        mylogger.info("Can't find resource path = ", path);
    }
    return myURL;
}
Stephen C
16 января 2019 в 13:27
0

Это не отвечает на вопрос.

avatar
Harsh
10 марта 2016 в 06:01
0
InputStream  inputStream = null;
BufferedReader bufferedReader = null;
try {
    BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
    String stringBuilder = new StringBuilder();
    String content;
    while((content = bufferedReader.readLine()) != null){
        stringBuilder.append(content);
    }
    System.out.println("content of file::" + stringBuilder.toString());
}
catch (IOException e) {
            e.printStackTrace();
        }finally{           
            if(bufferedReader != null){
                try{
                    bufferedReader.close();
                }catch(IoException ex){
                   ex.printStackTrace();
            }
avatar
Jitender Chahar
29 февраля 2016 в 17:18
0

Метод преобразования inputStream в String

public static String getStringFromInputStream(InputStream inputStream) {

    BufferedReader bufferedReader = null;
    StringBuilder stringBuilder = new StringBuilder();
    String line;

    try {
        bufferedReader = new BufferedReader(new InputStreamReader(
                inputStream));
        while ((line = bufferedReader.readLine()) != null) {
            stringBuilder.append(line);
        }
    } catch (IOException e) {
        logger.error(e.getMessage());
    } finally {
        if (bufferedReader != null) {
            try {
                bufferedReader.close();
            } catch (IOException e) {
                logger.error(e.getMessage());
            }
        }
    }
    return stringBuilder.toString();
}
avatar
Slava Vedenin
17 февраля 2016 в 00:58
2910

Обобщите другие ответы. Я нашел 11 основных способов сделать это (см. Ниже). И я написал несколько тестов производительности (см. Результаты ниже):

Способы преобразования InputStream в строку:

  1. Использование IOUtils.toString (Apache Utils)

     String result = IOUtils.toString(inputStream, StandardCharsets.UTF_8);
    
  2. Использование CharStreams (Guava)

     String result = CharStreams.toString(new InputStreamReader(
           inputStream, Charsets.UTF_8));
    
  3. Использование Scanner (JDK)

     Scanner s = new Scanner(inputStream).useDelimiter("\\A");
     String result = s.hasNext() ? s.next() : "";
    
  4. Использование Stream API (Java 8). Предупреждение : это решение преобразует различные разрывы строк (например, \r\n) в \n.

     String result = new BufferedReader(new InputStreamReader(inputStream))
       .lines().collect(Collectors.joining("\n"));
    
  5. Использование API параллельного потока (Java 8). Предупреждение : это решение преобразует различные разрывы строк (например, \r\n) в \n.

     String result = new BufferedReader(new InputStreamReader(inputStream))
        .lines().parallel().collect(Collectors.joining("\n"));
    
  6. Использование InputStreamReader и StringBuilder (JDK)

     int bufferSize = 1024;
     char[] buffer = new char[bufferSize];
     StringBuilder out = new StringBuilder();
     Reader in = new InputStreamReader(stream, StandardCharsets.UTF_8);
     for (int numRead; (numRead = in.read(buffer, 0, buffer.length)) > 0; ) {
         out.append(buffer, 0, numRead);
     }
     return out.toString();
    
  7. Использование StringWriter и IOUtils.copy (Apache Commons)

     StringWriter writer = new StringWriter();
     IOUtils.copy(inputStream, writer, "UTF-8");
     return writer.toString();
    
  8. Использование ByteArrayOutputStream и inputStream.read (JDK)

     ByteArrayOutputStream result = new ByteArrayOutputStream();
     byte[] buffer = new byte[1024];
     for (int length; (length = inputStream.read(buffer)) != -1; ) {
         result.write(buffer, 0, length);
     }
     // StandardCharsets.UTF_8.name() > JDK 7
     return result.toString("UTF-8");
    
  9. Использование BufferedReader (JDK). Предупреждение: Это решение преобразует различные разрывы строк (например, \n\r) в line.separator системное свойство (например, в Windows в "\ r \ n").

     String newLine = System.getProperty("line.separator");
     BufferedReader reader = new BufferedReader(
             new InputStreamReader(inputStream));
     StringBuilder result = new StringBuilder();
     for (String line; (line = reader.readLine()) != null; ) {
         if (result.length() > 0) {
             result.append(newLine);
         }
         result.append(line);
     }
     return result.toString();
    
  10. Использование BufferedInputStream и ByteArrayOutputStream (JDK)

    BufferedInputStream bis = new BufferedInputStream(inputStream);
    ByteArrayOutputStream buf = new ByteArrayOutputStream();
    for (int result = bis.read(); result != -1; result = bis.read()) {
        buf.write((byte) result);
    }
    // StandardCharsets.UTF_8.name() > JDK 7
    return buf.toString("UTF-8");
    
  11. Использование inputStream.read() и StringBuilder (JDK). Предупреждение : у этого решения есть проблемы с Unicode, например, с русским текстом (корректно работает только с текстом, отличным от Unicode)

    StringBuilder sb = new StringBuilder();
    for (int ch; (ch = inputStream.read()) != -1; ) {
        sb.append((char) ch);
    }
    return sb.toString();
    

Предупреждение :

  1. Решения 4, 5 и 9 преобразуют разные разрывы строк в один.

  2. Решение 11 не может правильно работать с текстом Unicode

Тесты производительности

Тесты производительности для маленьких String (длина = 175), URL в github (режим = Среднее время, система = Linux, 1343 балла - лучший):

              Benchmark                         Mode  Cnt   Score   Error  Units
 8. ByteArrayOutputStream and read (JDK)        avgt   10   1,343 ± 0,028  us/op
 6. InputStreamReader and StringBuilder (JDK)   avgt   10   6,980 ± 0,404  us/op
10. BufferedInputStream, ByteArrayOutputStream  avgt   10   7,437 ± 0,735  us/op
11. InputStream.read() and StringBuilder (JDK)  avgt   10   8,977 ± 0,328  us/op
 7. StringWriter and IOUtils.copy (Apache)      avgt   10  10,613 ± 0,599  us/op
 1. IOUtils.toString (Apache Utils)             avgt   10  10,605 ± 0,527  us/op
 3. Scanner (JDK)                               avgt   10  12,083 ± 0,293  us/op
 2. CharStreams (guava)                         avgt   10  12,999 ± 0,514  us/op
 4. Stream Api (Java 8)                         avgt   10  15,811 ± 0,605  us/op
 9. BufferedReader (JDK)                        avgt   10  16,038 ± 0,711  us/op
 5. parallel Stream Api (Java 8)                avgt   10  21,544 ± 0,583  us/op

Тесты производительности для большого String (длина = 50100), URL в github (режим = Среднее время, система = Linux, лучший результат - 200,715):

               Benchmark                        Mode  Cnt   Score        Error  Units
 8. ByteArrayOutputStream and read (JDK)        avgt   10   200,715 ±   18,103  us/op
 1. IOUtils.toString (Apache Utils)             avgt   10   300,019 ±    8,751  us/op
 6. InputStreamReader and StringBuilder (JDK)   avgt   10   347,616 ±  130,348  us/op
 7. StringWriter and IOUtils.copy (Apache)      avgt   10   352,791 ±  105,337  us/op
 2. CharStreams (guava)                         avgt   10   420,137 ±   59,877  us/op
 9. BufferedReader (JDK)                        avgt   10   632,028 ±   17,002  us/op
 5. parallel Stream Api (Java 8)                avgt   10   662,999 ±   46,199  us/op
 4. Stream Api (Java 8)                         avgt   10   701,269 ±   82,296  us/op
10. BufferedInputStream, ByteArrayOutputStream  avgt   10   740,837 ±    5,613  us/op
 3. Scanner (JDK)                               avgt   10   751,417 ±   62,026  us/op
11. InputStream.read() and StringBuilder (JDK)  avgt   10  2919,350 ± 1101,942  us/op

Графики (тесты производительности в зависимости от длины входного потока в системе Windows 7)
enter image description here

Тест производительности (среднее время) в зависимости от длины входного потока в системе Windows 7:

 length  182    546     1092    3276    9828    29484   58968

 test8  0.38    0.938   1.868   4.448   13.412  36.459  72.708
 test4  2.362   3.609   5.573   12.769  40.74   81.415  159.864
 test5  3.881   5.075   6.904   14.123  50.258  129.937 166.162
 test9  2.237   3.493   5.422   11.977  45.98   89.336  177.39
 test6  1.261   2.12    4.38    10.698  31.821  86.106  186.636
 test7  1.601   2.391   3.646   8.367   38.196  110.221 211.016
 test1  1.529   2.381   3.527   8.411   40.551  105.16  212.573
 test3  3.035   3.934   8.606   20.858  61.571  118.744 235.428
 test2  3.136   6.238   10.508  33.48   43.532  118.044 239.481
 test10 1.593   4.736   7.527   20.557  59.856  162.907 323.147
 test11 3.913   11.506  23.26   68.644  207.591 600.444 1211.545
Steve Chambers
1 августа 2020 в 11:16
0

Хорошая работа. Может быть полезно предоставить сводку tl; dr внизу, то есть отбросить решения, у которых есть проблемы с разрывами строк / Unicode, а затем (из оставшихся) указать, что быстрее всего с внешними библиотеками или без них.

Gigino
26 августа 2020 в 06:59
39

Кажется, этот ответ неполный

M. Justin
19 ноября 2020 в 08:03
1

Мне было интересно узнать о решениях Java 9 InputStream.transferTo и Java 10 Reader.transferTo, которые были добавлены после публикации этого ответа, поэтому я проверил связанный код и добавил для них тесты. Я тестировал только тесты «большой строки». InputStream.transferTo был самым быстрым из всех протестированных решений, работая в 60% случаев, как и test8 на моей машине. Reader.transferTo был медленнее, чем test8, но быстрее, чем все другие тесты. Тем не менее, в 95% случаев он работал как test1, так что это не является значительным улучшением.

Luke Hutchison
28 февраля 2021 в 02:10
2

Я преобразовал все циклы while в циклы for в редактировании этого сообщения, чтобы избежать загрязнения пространства имен переменной, которая не используется вне цикла. Это изящный трюк, который работает в большинстве циклов чтения / записи Java.

Shmuel Newmark
28 мая 2021 в 21:18
1

В Java 9 вы можете получить массив байтов из InputStream, используя .readAllBytes. Итак, «new String (inputStream.readAllBytes ())» работает с использованием конструктора String byte [].

avatar
jmehrens
28 января 2016 в 15:55
19

Используйте java.io.InputStream.transferTo (OutputStream), поддерживаемый в Java 9, и ByteArrayOutputStream.toString (String), который принимает имя набора символов: <8293784>

public static String gobble(InputStream in, String charsetName) throws IOException {
    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    in.transferTo(bos);
    return bos.toString(charsetName);
}

avatar
libnull-dev
21 января 2016 в 14:28
8

В терминах reduce и concat это может быть выражено в Java 8 как:

String fromFile = new BufferedReader(new   
InputStreamReader(inputStream)).lines().reduce(String::concat).get();
avatar
Steve Chambers
24 декабря 2015 в 11:08
5

На основе второй части принятый ответ Apache Commons, но с небольшим заполнением пробела для постоянного закрытия потока:

    String theString;
    try {
        theString = IOUtils.toString(inputStream, encoding);
    } finally {
        IOUtils.closeQuietly(inputStream);
    }
Ilya Gazman
5 апреля 2018 в 14:57
0

Обратите внимание, что это решение является наиболее неэффективным по результатам моих тестов.

avatar
hyper-neutrino
17 ноября 2015 в 03:23
0

Примечание. Вероятно, это плохая идея. Этот метод использует рекурсию и поэтому очень быстро попадет в StackOverflowError:

public String read (InputStream is) {
    byte next = is.read();
    return next == -1 ? "" : next + read(is); // Recursive part: reads next byte recursively
}

Пожалуйста, не голосуйте против этого только потому, что это плохой выбор; в основном это было креативно :)

Stephen C
16 января 2019 в 13:33
0

Это не просто плохой выбор. Он завершится ошибкой с StackOverflowError, если входной поток содержит более нескольких сотен символов.

hyper-neutrino
16 января 2019 в 16:30
0

@StephenC На мой взгляд, это плохой выбор

Stephen C
16 января 2019 в 22:20
3

Согласен. «Плохой выбор» - использовать метод, который не работает (за исключением тривиальных случаев). Но не , а просто «плохой выбор». Во всяком случае, я голосую против, потому что это неправильно ... а не потому, что это «плохой выбор». А также потому, что вы не объясняете , почему не следует использовать этот подход.

hyper-neutrino
17 января 2019 в 15:47
0

@StephenC Я принципиально не согласен с вами, но спасибо, что по крайней мере оставили комментарий, а не просто пролетают вниз. Проблемы переполнения рекурсии являются системными ограничениями, и этот метод не является неправильным, он просто вызывает проблемы с памятью быстрее (хотя и НАМНОГО быстрее), чем другие методы.

Stephen C
17 января 2019 в 22:30
1

Для языка Java и его реализаций отсутствие оптимизации хвостового вызова является преднамеренным выбором дизайна; см. softwareengineering.stackexchange.com/questions/272061/…. Это следует рассматривать как неотъемлемую часть Java. Конечно, это характерно для всех существующих основных реализаций Java ... включая Android.

parsecer
13 мая 2019 в 23:28
0

Мне понравился ваш метод, он очень необычный. Однако я не понимаю, почему это «вызывает проблемы с памятью намного быстрее»?

hyper-neutrino
14 мая 2019 в 18:20
1

@parsecer, потому что вместо того, чтобы закончиться, когда ОЗУ не может обрабатывать используемую память, она умирает, когда стек не может обрабатывать больше вызовов стека, что намного меньше числа в любой разумной системе.

avatar
Tagir Valeev
2 сентября 2015 в 11:50
125

Для полноты здесь Java 9 решение:

public static String toString(InputStream input) throws IOException {
    return new String(input.readAllBytes(), StandardCharsets.UTF_8);
}

Здесь используется метод readAllBytes, который был добавлен в Java 9.

M. Justin
19 ноября 2020 в 08:05
0

Я протестировал это здесь и обнаружил, что это самое быстрое решение на моей машине, работающее примерно на 60% быстрее, чем у следующего по скорости теста.

avatar
Christian Rädel
2 сентября 2015 в 11:19
8

Вот мое решение на основе Java 8 , которое использует новый Stream API для сбора всех строк из InputStream:

public static String toString(InputStream inputStream) {
    BufferedReader reader = new BufferedReader(
        new InputStreamReader(inputStream));
    return reader.lines().collect(Collectors.joining(
        System.getProperty("line.separator")));
}
avatar
Paul de Vrieze
15 июля 2015 в 10:23
308

С учетом файла сначала нужно получить экземпляр java.io.Reader. Затем его можно прочитать и добавить в StringBuilder (нам не нужен StringBuffer, если мы не обращаемся к нему в нескольких потоках, а StringBuilder быстрее). Хитрость здесь в том, что мы работаем блоками и поэтому не нуждаемся в других потоках буферизации. Размер блока параметризован для оптимизации производительности во время выполнения.

public static String slurp(final InputStream is, final int bufferSize) {
    final char[] buffer = new char[bufferSize];
    final StringBuilder out = new StringBuilder();
    try (Reader in = new InputStreamReader(is, "UTF-8")) {
        for (;;) {
            int rsz = in.read(buffer, 0, buffer.length);
            if (rsz < 0)
                break;
            out.append(buffer, 0, rsz);
        }
    }
    catch (UnsupportedEncodingException ex) {
        /* ... */
    }
    catch (IOException ex) {
        /* ... */
    }
    return out.toString();
}
avatar
Vadzim
9 июля 2015 в 13:20
4

Guava предоставляет гораздо более короткое эффективное решение для автоматического закрытия в случае, когда входной поток поступает из ресурса пути к классам (что кажется популярной задачей):

byte[] bytes = Resources.toByteArray(classLoader.getResource(path));

или

String text = Resources.toString(classLoader.getResource(path), StandardCharsets.UTF_8);

Существует также общая концепция ByteSource и CharSource, которые аккуратно заботятся как об открытии, так и о закрытии потока.

Так, например, вместо явного открытия небольшого файла для чтения его содержимого:

String content = Files.asCharSource(new File("robots.txt"), StandardCharsets.UTF_8).read();
byte[] data = Files.asByteSource(new File("favicon.ico")).read();

или просто

String content = Files.toString(new File("robots.txt"), StandardCharsets.UTF_8);
byte[] data = Files.toByteArray(new File("favicon.ico"));
avatar
czerny
26 февраля 2015 в 18:39
34

Чистое решение Java с использованием Stream s, работает с Java 8.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.stream.Collectors;

// ...
public static String inputStreamToString(InputStream is) throws IOException {
    try (BufferedReader br = new BufferedReader(new InputStreamReader(is))) {
        return br.lines().collect(Collectors.joining(System.lineSeparator()));
    }
}

Как упомянул Кристофер Хаммарстрём ниже другого ответа, безопаснее явно указать Charset. Т.е. Конструктор InputStreamReader можно изменить следующим образом:

new InputStreamReader(is, Charset.forName("UTF-8"))
avatar
Alex
4 февраля 2015 в 01:12
15

Пользователи Kotlin просто делают:

println(InputStreamReader(is).readText())

тогда как

readText()

- это встроенный метод расширения стандартной библиотеки Kotlin.

avatar
Luke Hutchison
11 сентября 2014 в 08:22
1

Нижеследующее не касается исходного вопроса, а скорее некоторых ответов.

В нескольких ответах предполагается наличие петель в форме

String line = null;
while((line = reader.readLine()) != null) {
  // ...
}

или

for(String line = reader.readLine(); line != null; line = reader.readLine()) {
    // ...
}

Первая форма загрязняет пространство имен охватывающей области, объявляя переменную "read" во включающей области, которая не будет использоваться для чего-либо вне цикла for. Вторая форма дублирует вызов readline ().

Вот более простой способ написания такого рода цикла на Java. Оказывается, первое предложение в цикле for не требует фактического значения инициализатора. Это сохраняет область видимости переменной "line" внутри тела цикла for. Намного элегантнее! Я нигде не видел, чтобы кто-нибудь использовал эту форму (я случайно обнаружил ее однажды много лет назад), но я использую ее постоянно.

for (String line; (line = reader.readLine()) != null; ) {
    //...
}
avatar
Vaishali Sutariya
25 августа 2014 в 12:30
4
InputStream is = Context.openFileInput(someFileName); // whatever format you have

ByteArrayOutputStream bos = new ByteArrayOutputStream();

byte[] b = new byte[8192];
for (int bytesRead; (bytesRead = is.read(b)) != -1;) {
    bos.write(b, 0, bytesRead);
}

String output = bos.toString(someEncoding);
avatar
Hai Zhang
3 августа 2014 в 09:47
19

Это ответ, адаптированный из org.apache.commons.io.IOUtils исходного кода, для тех, кто хочет иметь реализацию apache, но не хочет всю библиотеку.

private static final int BUFFER_SIZE = 4 * 1024;

public static String inputStreamToString(InputStream inputStream, String charsetName)
        throws IOException {
    StringBuilder builder = new StringBuilder();
    InputStreamReader reader = new InputStreamReader(inputStream, charsetName);
    char[] buffer = new char[BUFFER_SIZE];
    int length;
    while ((length = reader.read(buffer)) != -1) {
        builder.append(buffer, 0, length);
    }
    return builder.toString();
}
avatar
Simon Kuang
17 июля 2014 в 17:58
41

Я бы использовал некоторые уловки Java 8.

public static String streamToString(final InputStream inputStream) throws Exception {
    // buffering optional
    try
    (
        final BufferedReader br
           = new BufferedReader(new InputStreamReader(inputStream))
    ) {
        // parallel optional
        return br.lines().parallel().collect(Collectors.joining("\n"));
    } catch (final IOException e) {
        throw new RuntimeException(e);
        // whatever.
    }
}

По сути то же самое, что и некоторые другие ответы, за исключением более краткого.

avatar
Daniel De León
8 июня 2014 в 07:46
19

Этот хорош, потому что:

  • Он безопасно обрабатывает кодировку.
  • Вы управляете размером буфера чтения.
  • Вы можете указать длину компоновщика, и это не обязательно должно быть точное значение.
  • Не зависит от библиотек.
  • Для Java 7 или выше.

Как это сделать?

public static String convertStreamToString(InputStream is) throws IOException {
   StringBuilder sb = new StringBuilder(2048); // Define a size if you have an idea of it.
   char[] read = new char[128]; // Your buffer size.
   try (InputStreamReader ir = new InputStreamReader(is, StandardCharsets.UTF_8)) {
     for (int i; -1 != (i = ir.read(read)); sb.append(read, 0, i));
   }
   return sb.toString();
}

Для JDK 9

public static String inputStreamString(InputStream inputStream) throws IOException {
    try (inputStream) {
        return new String(inputStream.readAllBytes(), StandardCharsets.UTF_8);
    }
}
avatar
Dinis Cruz
12 мая 2014 в 18:04
-1

У меня был доступный log4j, поэтому я смог использовать org.apache.log4j.lf5.util.StreamUtils.getBytes для получения байтов, которые я смог преобразовать в строку с помощью String ctor

String result = new String(StreamUtils.getBytes(inputStream));
robinst
14 августа 2014 в 05:51
4

-1. То, что что-то доступно, не означает, что это нужно использовать. Когда вы меняете поставщика ведения журнала, вам придется заменить это. Кроме того, похоже, что он внутренний и не должен использоваться вне log4j.

avatar
laksys
9 апреля 2014 в 10:37
16

Вот полный метод преобразования InputStream в String без использования сторонней библиотеки. Используйте StringBuilder для однопоточной среды, в противном случае используйте StringBuffer.

public static String getString( InputStream is) throws IOException {
    int ch;
    StringBuilder sb = new StringBuilder();
    while((ch = is.read()) != -1)
        sb.append((char)ch);
    return sb.toString();
}
avatar
Ben Barkay
20 февраля 2014 в 17:24
5

Я написал класс, который делает именно это, поэтому решил поделиться им со всеми. Иногда вы не хотите добавлять Apache Commons только по одной причине и хотите чего-то более глупого, чем Scanner, который не проверяет контент.

Используется следующим образом

// Read from InputStream
String data = new ReaderSink(inputStream, Charset.forName("UTF-8")).drain();

// Read from File
data = new ReaderSink(file, Charset.forName("UTF-8")).drain();

// Drain input stream to console
new ReaderSink(inputStream, Charset.forName("UTF-8")).drainTo(System.out);

Вот код для ReaderSink:

import java.io.*;
import java.nio.charset.Charset;

/**
 * A simple sink class that drains a {@link Reader} to a {@link String} or
 * to a {@link Writer}.
 *
 * @author Ben Barkay
 * @version 2/20/2014
 */
public class ReaderSink {
    /**
     * The default buffer size to use if no buffer size was specified.
     */
    public static final int DEFAULT_BUFFER_SIZE = 1024;

    /**
     * The {@link Reader} that will be drained.
     */
    private final Reader in;

    /**
     * Constructs a new {@code ReaderSink} for the specified file and charset.
     * @param file      The file to read from.
     * @param charset   The charset to use.
     * @throws FileNotFoundException    If the file was not found on the filesystem.
     */
    public ReaderSink(File file, Charset charset) throws FileNotFoundException {
        this(new FileInputStream(file), charset);
    }

    /**
     * Constructs a new {@code ReaderSink} for the specified {@link InputStream}.
     * @param in        The {@link InputStream} to drain.
     * @param charset   The charset to use.
     */
    public ReaderSink(InputStream in, Charset charset) {
        this(new InputStreamReader(in, charset));
    }

    /**
     * Constructs a new {@code ReaderSink} for the specified {@link Reader}.
     * @param in    The reader to drain.
     */
    public ReaderSink(Reader in) {
        this.in = in;
    }

    /**
     * Drains the data from the underlying {@link Reader}, returning a {@link String} containing
     * all of the read information. This method will use {@link #DEFAULT_BUFFER_SIZE} for
     * its buffer size.
     * @return  A {@link String} containing all of the information that was read.
     */
    public String drain() throws IOException {
        return drain(DEFAULT_BUFFER_SIZE);
    }

    /**
     * Drains the data from the underlying {@link Reader}, returning a {@link String} containing
     * all of the read information.
     * @param bufferSize    The size of the buffer to use when reading.
     * @return  A {@link String} containing all of the information that was read.
     */
    public String drain(int bufferSize) throws IOException {
        StringWriter stringWriter = new StringWriter();
        drainTo(stringWriter, bufferSize);
        return stringWriter.toString();
    }

    /**
     * Drains the data from the underlying {@link Reader}, writing it to the
     * specified {@link Writer}. This method will use {@link #DEFAULT_BUFFER_SIZE} for
     * its buffer size.
     * @param out   The {@link Writer} to write to.
     */
    public void drainTo(Writer out) throws IOException {
        drainTo(out, DEFAULT_BUFFER_SIZE);
    }

    /**
     * Drains the data from the underlying {@link Reader}, writing it to the
     * specified {@link Writer}.
     * @param out           The {@link Writer} to write to.
     * @param bufferSize    The size of the buffer to use when reader.
     */
    public void drainTo(Writer out, int bufferSize) throws IOException {
        char[] buffer = new char[bufferSize];
        int read;
        while ((read = in.read(buffer)) > -1) {
            out.write(buffer, 0, read);
        }
    }
}
avatar
Fred
20 февраля 2014 в 15:28
0

Этот фрагмент был найден в \ sdk \ samples \ android-19 \ connectivity \ NetworkConnect \ NetworkConnectSample \ src \ main \ java \ com \ example \ android \ networkconnect \ MainActivity.java, который лицензирован под лицензией Apache, версии 2.0 и написано Google.

/** Reads an InputStream and converts it to a String.
 * @param stream InputStream containing HTML from targeted site.
 * @param len Length of string that this method returns.
 * @return String concatenated according to len parameter.
 * @throws java.io.IOException
 * @throws java.io.UnsupportedEncodingException
 */
private String readIt(InputStream stream, int len) throws IOException, UnsupportedEncodingException {
    Reader reader = null;
    reader = new InputStreamReader(stream, "UTF-8");
    char[] buffer = new char[len];
    reader.read(buffer);
    return new String(buffer);
}
avatar
JavaTechnical
7 февраля 2014 в 05:17
4

Попробуйте эти 4 утверждения ..

Согласно пункту, который напомнил Фред, не рекомендуется добавлять String с оператором +=, поскольку каждый раз новый char добавляется к существующему String, создавая новый объект String. и присвоение его адреса st, в то время как старый объект st становится мусором.

public String convertStreamToString(InputStream is)
{
    int k;
    StringBuffer sb=new StringBuffer();
    while((k=fin.read()) != -1)
    {
        sb.append((char)k);
    }
    return sb.toString();
}

Не рекомендуется, но это тоже способ

public String convertStreamToString(InputStream is) { 
    int k;
    String st="";
    while((k=is.read()) != -1)
    {
        st+=(char)k;
    }
    return st;
}
Fred
20 февраля 2014 в 15:24
2

Объединение строк в цикле с оператором += - не лучшая идея. Лучше использовать StringBuilder или StringBuffer.

avatar
Rys
16 января 2014 в 14:03
4

Вы можете использовать Apache Commons.

В IOUtils вы можете найти метод toString с тремя полезными реализациями.

public static String toString(InputStream input) throws IOException {
        return toString(input, Charset.defaultCharset());
}

public static String toString(InputStream input) throws IOException {
        return toString(input, Charset.defaultCharset());
}

public static String toString(InputStream input, String encoding)
            throws IOException {
        return toString(input, Charsets.toCharset(encoding));
}
rkosegi
3 октября 2018 в 19:13
1

В чем разница между первыми двумя методами?

avatar
voidmain
5 декабря 2013 в 17:53
5

Ответ JDK 7/8, который закрывает поток и по-прежнему генерирует исключение IOException:

StringBuilder build = new StringBuilder();
byte[] buf = new byte[1024];
int length;
try (InputStream is = getInputStream()) {
  while ((length = is.read(buf)) != -1) {
    build.append(new String(buf, 0, length));
  }
}
avatar
Omkar Khot
30 мая 2013 в 14:52
2
InputStreamReader i = new InputStreamReader(s);
BufferedReader str = new BufferedReader(i);
String msg = str.readLine();
System.out.println(msg);

Здесь s - ваш объект InputStream, который будет преобразован в String

KNU
7 апреля 2014 в 11:34
0

будет ли работать, если последние 2 строки будут вставлены в цикл do-while?

user207421
24 февраля 2017 в 00:10
0

В вопросе о линиях нет ничего.

avatar
FK386
10 мая 2013 в 17:25
-3
  InputStream IS=new URL("http://www.petrol.si/api/gas_prices.json").openStream();   

  ByteArrayOutputStream BAOS=new ByteArrayOutputStream();
  IOUtils.copy(IS, BAOS);
  String d= new String(BAOS.toByteArray(),"UTF-8");           

System.out.println(d);
Martin Schröder
15 мая 2013 в 15:23
0

Посмотрите на комету Кристоффера Хаммарстрема в ответе Гарри Лайма.

FK386
27 января 2017 в 16:06
0

В вопросе нет ничего, что бы отдаленно подсказывало, в какую кодировку преобразовать или что решение должно быть невосприимчивым к любой кодировке.

Peter Mortensen
5 января 2019 в 10:38
0

Объяснение было бы в порядке.

avatar
Victor
9 марта 2013 в 20:13
5

Ну, можете запрограммировать под себя ... Это несложно ...

String Inputstream2String (InputStream is) throws IOException
    {
        final int PKG_SIZE = 1024;
        byte[] data = new byte [PKG_SIZE];
        StringBuilder buffer = new StringBuilder(PKG_SIZE * 10);
        int size;

        size = is.read(data, 0, data.length);
        while (size > 0)
        {
            String str = new String(data, 0, size);
            buffer.append(str);
            size = is.read(data, 0, data.length);
        }
        return buffer.toString();
    }
user246645
8 ноября 2013 в 10:27
1

Поскольку вы используете переменную buffer локально без возможности совместного использования несколькими потоками, вам следует подумать об изменении ее типа на StringBuilder, чтобы избежать накладных расходов на (бесполезную) синхронизацию.

Victor
8 ноября 2013 в 16:19
0

Хороший момент, Алекс !. Я считаю, что мы оба согласны с тем, что этот метод во многих отношениях не является потокобезопасным. Даже операции с потоком ввода не являются потокобезопасными.

Vlad Lifliand
8 августа 2014 в 22:47
1

Если поток содержит символ UTF-8, который занимает несколько строк, этот алгоритм может разрезать символ пополам, разбивая строку.

Christian Hujer
31 января 2016 в 22:05
1

@VladLifliand Как именно символ UTF-8 может занимать несколько строк? Это невозможно по определению. Вы, наверное, имели в виду другое.

ᴠɪɴᴄᴇɴᴛ
17 марта 2019 в 20:07
0

@ChristianHujer Вероятно, он имел в виду buffers вместо lines. Кодовые точки / символы UTF-8 могут быть многобайтовыми.

avatar
Drew Noakes
1 января 2013 в 03:43
66

Вот самое элегантное решение на чистой Java (без библиотеки), которое я придумал после некоторых экспериментов:

public static String fromStream(InputStream in) throws IOException
{
    BufferedReader reader = new BufferedReader(new InputStreamReader(in));
    StringBuilder out = new StringBuilder();
    String newLine = System.getProperty("line.separator");
    String line;
    while ((line = reader.readLine()) != null) {
        out.append(line);
        out.append(newLine);
    }
    return out.toString();
}
avatar
Thamme Gowda
17 ноября 2012 в 12:39
20

Не забудьте закрыть потоки в конце, если вы используете Stream Readers

private String readStream(InputStream iStream) throws IOException {
    //build a Stream Reader, it can read char by char
    InputStreamReader iStreamReader = new InputStreamReader(iStream);
    //build a buffered Reader, so that i can read whole line at once
    BufferedReader bReader = new BufferedReader(iStreamReader);
    String line = null;
    StringBuilder builder = new StringBuilder();
    while((line = bReader.readLine()) != null) {  //Read till end
        builder.append(line);
        builder.append("\n"); // append new line to preserve lines
    }
    bReader.close();         //close all opened stuff
    iStreamReader.close();
    //iStream.close(); //EDIT: Let the creator of the stream close it!
                       // some readers may auto close the inner stream
    return builder.toString();
}

РЕДАКТИРОВАТЬ: В JDK 7+ можно использовать конструкцию try-with-resources.

/**
 * Reads the stream into a string
 * @param iStream the input stream
 * @return the string read from the stream
 * @throws IOException when an IO error occurs
 */
private String readStream(InputStream iStream) throws IOException {

    //Buffered reader allows us to read line by line
    try (BufferedReader bReader =
                 new BufferedReader(new InputStreamReader(iStream))){
        StringBuilder builder = new StringBuilder();
        String line;
        while((line = bReader.readLine()) != null) {  //Read till end
            builder.append(line);
            builder.append("\n"); // append new line to preserve lines
        }
        return builder.toString();
    }
}
avatar
Matt Shannon
2 ноября 2012 в 12:37
15

Вот как это сделать, используя только JDK с использованием буферов байтовых массивов. Именно так работают все методы commons-io IOUtils.copy(). Вы можете заменить byte[] на char[], если копируете из Reader вместо InputStream.

import java.io.ByteArrayOutputStream;
import java.io.InputStream;

...

InputStream is = ....
ByteArrayOutputStream baos = new ByteArrayOutputStream(8192);
byte[] buffer = new byte[8192];
int count = 0;
try {
  while ((count = is.read(buffer)) != -1) {
    baos.write(buffer, 0, count);
  }
}
finally {
  try {
    is.close();
  }
  catch (Exception ignore) {
  }
}

String charset = "UTF-8";
String inputStreamAsString = baos.toString(charset);
avatar
Anand N
24 июля 2012 в 10:19
5

Приведенный ниже код работал у меня.

URL url = MyClass.class.getResource("/" + configFileName);
BufferedInputStream bi = (BufferedInputStream) url.getContent();
byte[] buffer = new byte[bi.available() ];
int bytesRead = bi.read(buffer);
String out = new String(buffer);

Обратите внимание, согласно документации Java, метод available() может не работать с InputStream, но всегда работает с BufferedInputStream. Если вы не хотите использовать метод available(), мы всегда можем использовать приведенный ниже код

URL url = MyClass.class.getResource("/" + configFileName);
BufferedInputStream bi = (BufferedInputStream) url.getContent();
File f = new File(url.getPath());
byte[] buffer = new byte[ (int) f.length()];
int bytesRead = bi.read(buffer);
String out = new String(buffer);

Я не уверен, возникнут ли проблемы с кодировкой. Прокомментируйте, если возникнут проблемы с кодом.

avatar
soBinary
19 июля 2012 в 17:33
-9

Быстро и просто:

String result = (String)new ObjectInputStream( inputStream ).readObject();
XXL
20 июля 2012 в 11:13
1

Я получаю java.io.StreamCorruptedException: invalid stream header

Brice
3 апреля 2013 в 14:17
3

ObjectInputStream касается десериализации, и для работы поток должен соблюдать протокол сериализации, что не всегда может быть верным в контексте этого вопроса.

Peter Mortensen
5 января 2019 в 10:37
0

Объяснение было бы в порядке.

avatar
TacB0sS
8 мая 2012 в 20:24
129

Это лучшее решение на чистой Java, которое идеально подходит для Android и любой другой JVM.

Это решение работает на удивление хорошо ... оно простое, быстрое и одинаково работает как с маленькими, так и с большими потоками !! (см. тест выше .. № 8 )

public String readFullyAsString(InputStream inputStream, String encoding)
        throws IOException {
    return readFully(inputStream).toString(encoding);
}

public byte[] readFullyAsBytes(InputStream inputStream)
        throws IOException {
    return readFully(inputStream).toByteArray();
}

private ByteArrayOutputStream readFully(InputStream inputStream)
        throws IOException {
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    byte[] buffer = new byte[1024];
    int length = 0;
    while ((length = inputStream.read(buffer)) != -1) {
        baos.write(buffer, 0, length);
    }
    return baos;
}
avatar
TKH
30 марта 2012 в 19:52
27

Вот более или менее ответ сампата, немного очищенный и представленный в виде функции:

String streamToString(InputStream in) throws IOException {
  StringBuilder out = new StringBuilder();
  BufferedReader br = new BufferedReader(new InputStreamReader(in));
  for(String line = br.readLine(); line != null; line = br.readLine()) 
    out.append(line);
  br.close();
  return out.toString();
}
avatar
Jack
7 марта 2012 в 07:32
26

Если вы любите приключения, вы можете смешать Scala и Java и получить следующее:

scala.io.Source.fromInputStream(is).mkString("")

Сочетание кода и библиотек Java и Scala имеет свои преимущества.

См. Полное описание здесь: Идиоматический способ преобразования InputStream в String в Scala

avatar
Brett Holt
12 октября 2011 в 17:23
36

Я провел несколько тестов времени, потому что время всегда имеет значение.

Я попытался получить ответ в виде строки тремя разными способами. (показано ниже)
Я исключил блоки try / catch для удобства чтения.

Чтобы дать контекст, это предыдущий код для всех трех подходов:

   String response;
   String url = "www.blah.com/path?key=value";
   GetMethod method = new GetMethod(url);
   int status = client.executeMethod(method);

1)

 response = method.getResponseBodyAsString();

2)

InputStream resp = method.getResponseBodyAsStream();
InputStreamReader is=new InputStreamReader(resp);
BufferedReader br=new BufferedReader(is);
String read = null;
StringBuffer sb = new StringBuffer();
while((read = br.readLine()) != null) {
    sb.append(read);
}
response = sb.toString();

3)

InputStream iStream  = method.getResponseBodyAsStream();
StringWriter writer = new StringWriter();
IOUtils.copy(iStream, writer, "UTF-8");
response = writer.toString();

Итак, после запуска 500 тестов для каждого подхода с одинаковыми данными запроса / ответа, вот числа. Опять же, это мои выводы, и ваши выводы могут быть не совсем такими же, но я написал это, чтобы указать другим на различия в эффективности этих подходов.

Звания:
Подход № 1
Подход №3 - на 2,6% медленнее, чем №1
Подход №2 - на 4,3% медленнее, чем №1

Любой из этих подходов является подходящим решением для получения ответа и создания из него строки.

avatar
sampathpremarathna
4 августа 2011 в 08:29
260

Использование:

InputStream in = /* Your InputStream */;
StringBuilder sb = new StringBuilder();
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String read;

while ((read=br.readLine()) != null) {
    //System.out.println(read);
    sb.append(read);
}

br.close();
return sb.toString();
Rangi Keen
15 марта 2021 в 22:11
0

readLine() удаляет символ перевода строки, поэтому результирующая строка не будет содержать разрывов строки, если вы не добавите разделитель строк между каждой строкой, которую вы добавляете в построитель.

avatar
Pavel Repin
26 марта 2011 в 20:40
2337

Вот способ использования только стандартной библиотеки Java (обратите внимание, что поток не закрыт, ваш пробег может отличаться).

static String convertStreamToString(java.io.InputStream is) {
    java.util.Scanner s = new java.util.Scanner(is).useDelimiter("\\A");
    return s.hasNext() ? s.next() : "";
}

Я узнал об этом трюке из статьи "Глупые трюки со сканером". Причина, по которой это работает, заключается в том, что Scanner выполняет итерацию по токенам в потоке, и в этом случае мы разделяем токены, используя «начало входной границы» (\ A), тем самым давая нам только один токен для всего содержимого. потока.

Обратите внимание: если вам нужно уточнить кодировку входного потока, вы можете предоставить второй аргумент конструктору Scanner, который указывает, какой набор символов использовать (например, «UTF-8»).

Наконечник шляпы также достанется Джейкобу, который однажды указал мне на указанную статью.

Oleg Markelov
19 октября 2020 в 06:13
0

Разве мы не должны закрыть сканер перед возвратом значения?

Pavel Repin
9 ноября 2020 в 20:05
0

@OlegMarkelov наверное.

avatar
Sakuraba
13 июля 2010 в 15:56
176

Если вы используете Google-Collections / Guava, вы можете сделать следующее:

InputStream stream = ...
String content = CharStreams.toString(new InputStreamReader(stream, Charsets.UTF_8));
Closeables.closeQuietly(stream);

Обратите внимание, что второй параметр (например, Charsets.UTF_8) для InputStreamReader необязателен, но обычно рекомендуется указывать кодировку, если вы ее знаете (что вам следует!)

avatar
DJDaveMark
18 мая 2010 в 12:57
24

Если вы не можете использовать Commons IO (FileUtils / IOUtils / CopyUtils), вот пример использования BufferedReader для чтения файла построчно:

public class StringFromFile {
    public static void main(String[] args) /*throws UnsupportedEncodingException*/ {
        InputStream is = StringFromFile.class.getResourceAsStream("file.txt");
        BufferedReader br = new BufferedReader(new InputStreamReader(is/*, "UTF-8"*/));
        final int CHARS_PER_PAGE = 5000; //counting spaces
        StringBuilder builder = new StringBuilder(CHARS_PER_PAGE);
        try {
            for(String line=br.readLine(); line!=null; line=br.readLine()) {
                builder.append(line);
                builder.append('\n');
            }
        } 
        catch (IOException ignore) { }

        String text = builder.toString();
        System.out.println(text);
    }
}

Или, если вам нужна чистая скорость, я бы предложил вариант того, что предложил Поль де Вриз (который позволяет избежать использования StringWriter (который использует StringBuffer внутри):

public class StringFromFileFast {
    public static void main(String[] args) /*throws UnsupportedEncodingException*/ {
        InputStream is = StringFromFileFast.class.getResourceAsStream("file.txt");
        InputStreamReader input = new InputStreamReader(is/*, "UTF-8"*/);
        final int CHARS_PER_PAGE = 5000; //counting spaces
        final char[] buffer = new char[CHARS_PER_PAGE];
        StringBuilder output = new StringBuilder(CHARS_PER_PAGE);
        try {
            for(int read = input.read(buffer, 0, buffer.length);
                    read != -1;
                    read = input.read(buffer, 0, buffer.length)) {
                output.append(buffer, 0, read);
            }
        } catch (IOException ignore) { }

        String text = output.toString();
        System.out.println(text);
    }
}
avatar
Jon Moore
10 июня 2009 в 21:07
71

Использование:

import java.io.BufferedInputStream;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.io.IOException;

public static String readInputStreamAsString(InputStream in)
    throws IOException {

    BufferedInputStream bis = new BufferedInputStream(in);
    ByteArrayOutputStream buf = new ByteArrayOutputStream();
    int result = bis.read();
    while(result != -1) {
      byte b = (byte)result;
      buf.write(b);
      result = bis.read();
    }
    return buf.toString();
}
avatar
Chinnery
8 декабря 2008 в 20:13
870

Apache Commons позволяет:

String myString = IOUtils.toString(myInputStream, "UTF-8");

Конечно, вы можете выбрать другие кодировки символов, кроме UTF-8.

См. Также: (документацию)

Shantaram Tupe
24 февраля 2021 в 12:06
0

Пытаюсь вернуть InputStream, не работает coderhelper.com/q/66349701/3425489