Java InputStream karakterláncra

1. Áttekintés

Ebben az oktatóanyagban megnézzük hogyan lehet átalakítani egy InputStream egy húrra, a Guava, az Apache Commons IO könyvtár és a sima Java használatával.

Ez a cikk a „Java - Vissza az alapokhoz” sorozat része, itt, Baeldungon.

2. Konvertálás Guava-val

Kezdjük egy guavai példával - a ByteSource funkcionalitás:

@Test public void givenUsingGuava_whenConvertingAnInputStreamToAString_thenCorrect () dobja az IOException {String originalString = randomAlphabetic (8); InputStream inputStream = new ByteArrayInputStream (originalString.getBytes ()); ByteSource byteSource = új ByteSource () {@Orride public InputStream openStream () dobja az IOException {return inputStream; }}; Karaktersorozat = byteSource.asCharSource (Charsets.UTF_8) .read (); assertThat (szöveg, egyenlőTo (eredetiString)); }

Térjünk át a lépésekre:

  • első - becsomagoljuk a magunkét InputStream a ByteSource - és tudomásom szerint ez a legegyszerűbb módja ennek
  • azután - nézzük a mi ByteSource mint a CharSource UTF8 karakterkészlettel.
  • végül - használjuk a CharSource húrként olvasni.

A az átalakítás egyszerűbb módja Guava-val, de a patakot kifejezetten le kell zárni; szerencsére egyszerűen a try-with-resources szintaxist használhatjuk erre:

@Test public void givenUsingGuavaAndJava7_whenConvertingAnInputStreamToAString_thenCorrect () dobja IOException {String originalString = randomAlphabetic (8); InputStream inputStream = new ByteArrayInputStream (originalString.getBytes ()); Karakterlánc szöveg = null; try (Reader olvasó = új InputStreamReader (inputStream)) {text = CharStreams.toString (olvasó); } assertThat (szöveg, egyenlőTo (eredetiString)); }

3. Konvertálás az Apache Commons IO-val

Most nézzük meg, hogyan lehet ezt megtenni a Commons IO könyvtárral.

Fontos figyelmeztetés, hogy - Guavával ellentétben - egyik sem zárja be a példát InputStream - ezért személy szerint inkább a guavai megoldást preferálom.

@Test public void givenUsingCommonsIo_whenConvertingAnInputStreamToAString_thenCorrect () dobja az IOException {String originalString = randomAlphabetic (8); InputStream inputStream = new ByteArrayInputStream (originalString.getBytes ()); Karakterlánc-szöveg = IOUtils.toString (inputStream, StandardCharsets.UTF_8.name ()); assertThat (szöveg, egyenlőTo (eredetiString)); }

Használhatjuk a StringWriter az átalakítás elvégzéséhez:

@Test public void givenUsingCommonsIoWithCopy_whenConvertingAnInputStreamToAString_thenCorrect () dobja az IOException-t {String originalString = randomAlphabetic (8); InputStream inputStream = new ByteArrayInputStream (originalString.getBytes ()); StringWriter író = new StringWriter (); Karaktersorozat kódolása = StandardCharsets.UTF_8.name (); IOUtils.copy (inputStream, író, kódolás); assertThat (író.String (), egyenlőTo (EredetiString)); }

4. Konvertálás Java-val - InputStream

Nézzünk most egy alacsonyabb szintű megközelítést a sima Java - an használatával InputStream és egy egyszerű StringBuilder:

@Test public void givenUsingJava5_whenConvertingAnInputStreamToAString_thenCorrect () dobja az IOException {String originalString = randomAlphabetic (DEFAULT_SIZE); InputStream inputStream = new ByteArrayInputStream (originalString.getBytes ()); StringBuilder textBuilder = new StringBuilder (); próbálkozzon (Reader olvasó = új BufferedReader (új InputStreamReader (inputStream, Charset.forName (StandardCharsets.UTF_8.name ()))))) {int c = 0; míg ((c = olvasó.olvasott ())! = -1) {textBuilder.append ((char) c); }} assertEquals (textBuilder.toString (), originalString); }

4.1. Java 8 használata

A Java 8 újat hoz vonalak () módszer a BufferedReader. Lássuk, hogyan használhatjuk fel az átalakítására InputStream a Húr:

@Test public void givenUsingJava8_whenConvertingAnInputStreamToAString_thenCorrect () {String originalString = randomAlphabetic (DEFAULT_SIZE); InputStream inputStream = new ByteArrayInputStream (originalString.getBytes ()); Karakterlánc szövege = new BufferedReader (új InputStreamReader (inputStream, StandardCharsets.UTF_8))) .lines () .collect (Collectors.joining ("\ n")); assertThat (szöveg, egyenlőTo (eredetiString)); }

Fontos ezt megemlíteni vonalak () használja a readLine () módszer a motorháztető alatt. readLine () feltételezi, hogy egy sort a sor előtolás („\ n”), a kocsi visszaadása („\ r”) vagy a kocsi visszaadása bármelyikével vetnek véget, amelyet azonnal sorvezetés követ. Más szavakkal, támogatja az összes közöset A vonal vége stílusok - Unix, Windows, sőt a régi Mac OS is.

Másrészről, amikor használjuk Collectors.joining (), kifejezetten el kell döntenünk, hogy melyik típusú EOL-t akarjuk használni a létrehozotthoz Húr.

Használhatnánk a Collectors.joining (System.lineSeparator ()), ebben az esetben a kimenet a rendszer beállításaitól függ.

5. Konvertálás Java-val és a Scanner

Ezután - nézzünk meg egy sima Java példát - egy szabványos szöveg használatával Scanner:

@Test public void givenUsingJava7_whenConvertingAnInputStreamToAString_thenCorrect () dob IOException {String originalString = randomAlphabetic (8); InputStream inputStream = new ByteArrayInputStream (originalString.getBytes ()); Karakterlánc szöveg = null; próbáld ki (Szkenner szkenner = új Szkenner (inputStream, StandardCharsets.UTF_8.name ())) {text = szkenner.useDelimiter ("\ A"). következő (); } assertThat (szöveg, egyenlőTo (eredetiString)); }

Vegye figyelembe, hogy a InputStream lezárása a Scanner.

Azt is érdemes tisztázni, hogy mi useDelimiter (“\ A”) csinál. Itt adtuk át az „\ A” -t, amely egy határjel-regex, amely a bemenet kezdetét jelöli. Lényegében ez azt jelenti, hogy a következő() hívás beolvassa a teljes bemeneti adatfolyamot.

Ennek egyetlen oka a Java 7 példa, és nem a Java 5 példa a erőforrásokkal próbálkozzon nyilatkozat - ezt szabványossá alakítva próbálkozz végre Blokk remekül fog fordítani a Java 5-tel.

6. Konvertálás használatával ByteArrayOutputStream

Végül nézzünk meg egy másik egyszerű Java példát, ezúttal a ByteArrayOutputStream osztály:

@Test public void givenUsingPlainJava_whenConvertingAnInputStreamToString_thenCorrect () dobja az IOException {String originalString = randomAlphabetic (8); InputStream inputStream = new ByteArrayInputStream (originalString.getBytes ()); ByteArrayOutputStream puffer = new ByteArrayOutputStream (); int nRead; bájt [] adatok = új bájt [1024]; while (((nRead = inputStream.read (data, 0, data.length))! = -1) {buffer.write (adatok, 0, nRead); } buffer.flush (); byte [] byteArray = puffer.toByteArray (); Karakterlánc szövege = új karakterlánc (byteArray, StandardCharsets.UTF_8); assertThat (szöveg, egyenlőTo (eredetiString)); }

Ebben a példában először a InputStream átalakul a-vá ByteArrayOutputStream byte blokkok olvasásával és írásával, majd a OutputStream átalakul bájt tömbgé, amelyet a Húr.

7. Konvertálás vele java.nio

Egy másik megoldás az InputStream fájlba, majd konvertálja ezt a Húr:

@Test public void givenUsingTempFile_whenConvertingAnInputStreamToAString_thenCorrect () dobja az IOException {String originalString = randomAlphabetic (DEFAULT_SIZE); InputStream inputStream = new ByteArrayInputStream (originalString.getBytes ()); Path tempFile = Files.createTempDirectory (""). Feloldás (UUID.randomUUID (). ToString () + ".tmp"); Files.copy (inputStream, tempFile, StandardCopyOption.REPLACE_EXISTING); Karakterlánc eredménye = új karakterlánc (Files.readAllBytes (tempFile)); assertThat (eredmény, egyenlőTo (eredetiString)); }

Itt használjuk a java.nio.file.Files osztály egy ideiglenes fájl létrehozásához, valamint a InputStream az aktába. Ezután ugyanazt az osztályt használják a fájl tartalmának a-ba konvertálására Húr a ... val readAllBytes () módszer.

8. Következtetés

Miután összeállítottam az egyszerű konverzió - InputStream a String-hez - helyes és olvasható módon a legjobb módját, és miután megannyi vad válaszot és megoldást láttam, azt hiszem, hogy erre világos és tömör legjobb gyakorlatra van szükség.

Mindezen példák és kódrészletek megvalósítása megtalálható a GitHub oldalon - ez egy Maven-alapú projekt, ezért könnyen importálhatónak és futtathatónak kell lennie.