streamalism.org

1. Introduksjon

Vi trenger ofte å konvertere mellom String og byte array i Java. I denne opplæringen vil vi undersøke disse operasjonene i detalj.

Først vil vi se på forskjellige måter å konvertere en String til en byte array. Deretter ser vi på lignende operasjoner i omvendt retning.

2. Konvertering String til Byte Array

EN String lagres som en rekke Unicode-tegn i Java. Å konvertere den til en byte array oversetter vi sekvensen av tegn til en bytesekvens. For denne oversettelsen, vi bruker en forekomst av Charset. Denne klassen spesifiserer en kartlegging mellom en sekvens av røyes og en sekvens av bytes.

Vi refererer til prosessen ovenfor som koding.

Vi kan kode en String inn i en byte array i Java på flere måter. La oss se på hver av dem i detalj med eksempler.

2.1. Ved hjelp av String.getBytes ()

De String klasse gir tre overbelastede getBytes metoder for å kode en String inn i en byte array:

• getBytes () - koder ved hjelp av plattformens standardtegnsett
• getBytes (String charsetName) - koder ved hjelp av det nevnte tegnsettet
• getBytes (Charset charset) - koder ved hjelp av det medfølgende tegnsettet

For det første, la oss kode en streng ved hjelp av plattformens standardtegnsett:

String inputString = "Hello World!"; byte [] byteArrray = inputString.getBytes ();

Ovennevnte metode er plattformavhengig da den bruker plattformens standardtegnsett. Vi kan få dette tegnsettet ved å ringe Charset.defaultCharset ().

For det andre, la oss kode en streng ved hjelp av et navngitt tegnsett:

@Test offentlig ugyldig nårGetBytesWithNamedCharset_thenOK () kaster UnsupportedEncodingException {String inputString = "Hello World!"; String charsetName = "IBM01140"; byte [] byteArrray = inputString.getBytes ("IBM01140"); assertArrayEquals (ny byte [] {-56, -123, -109, -109, -106, 64, -26, -106, -103, -109, -124, 90}, byteArrray); }

Denne metoden kaster Ikke-støttet koding unntak hvis det navngitte tegnsettet ikke støttes.

Oppførselen til de to ovennevnte versjonene er udefinert hvis inngangen inneholder tegn som ikke støttes av tegnsettet. Derimot bruker den tredje versjonen tegnsettets standard erstatningsbyte-array for å kode ikke-støttet inngang.

Neste, la oss kalle den tredje versjonen av getBytes () metode og passere en forekomst av Charset:

@Test offentlig ugyldig nårGetBytesWithCharset_thenOK () {String inputString = "Hei ਸੰਸਾਰ!"; Charset charset = Charset.forName ("ASCII"); byte [] byteArrray = inputString.getBytes (charset); assertArrayEquals (ny byte [] {72, 101, 108, 108, 111, 32, 63, 63, 63, 63, 63, 33}, byteArrray); }

Her bruker vi fabrikkmetoden Charset.forName for å få en forekomst av Charset. Denne metoden gir et runtime-unntak hvis navnet på det forespurte tegnsettet er ugyldig. Det gir også et runtime-unntak hvis tegnsettet støttes i gjeldende JVM.

Imidlertid er noen tegnsett garantert tilgjengelig på alle Java-plattformer. De StandardCharsets klasse definerer konstanter for disse tegnsettene.

Endelig, la oss kode ved hjelp av et av standardtegnene:

@Test offentlig ugyldig nårGetBytesWithStandardCharset_thenOK () {String inputString = "Hello World!"; Charset charset = StandardCharsets.UTF_16; byte [] byteArrray = inputString.getBytes (charset); assertArrayEquals (ny byte [] {-2, -1, 0, 72, 0, 101, 0, 108, 0, 108, 0, 111, 0, 32, 0, 87, 0, 111, 0, 114, 0 , 108, 0, 100, 0, 33}, byteArrray); }

Dermed fullfører vi gjennomgangen av de forskjellige getBytes versjoner. La oss deretter se på metoden som tilbys av Charset seg selv.

2.2. Ved hjelp av Charset.encode ()

De Charset klasse gir kode (), en praktisk metode som koder Unicode-tegn til byte. Denne metoden erstatter alltid ugyldige inndata og ikke-tildelbare tegn ved bruk av tegnsettets standard erstatningsbyte-array.

La oss bruke kode metode for å konvertere en String inn i en byte matrise:

@Test offentlig ugyldig nårEncodeWithCharset_thenOK () {String inputString = "Hei ਸੰਸਾਰ!"; Charset charset = StandardCharsets.US_ASCII; byte [] byteArrray = charset.encode (inputString) .array (); assertArrayEquals (ny byte [] {72, 101, 108, 108, 111, 32, 63, 63, 63, 63, 63, 33}, byteArrray); }

Som vi kan se ovenfor, er ikke-støttede tegn erstattet med tegnsettets standarderstatning byte 63.

Tilnærmingene som hittil er brukt, bruker CharsetEncoder klasse internt for å utføre koding. La oss undersøke denne klassen i neste avsnitt.

2.3. CharsetEncoder

CharsetEncoder forvandler Unicode-tegn til en sekvens av byte for et gitt tegnsett. Videre gir den finkornet kontroll over kodingsprosessen.

La oss bruke denne klassen til å konvertere en String inn i en byte matrise:

@Test offentlig ugyldig nårUsingCharsetEncoder_thenOK () kaster CharacterCodingException {String inputString = "Hei ਸੰਸਾਰ!"; CharsetEncoder encoder = StandardCharsets.US_ASCII.newEncoder (); encoder.onMalformedInput (CodingErrorAction.IGNORE) .onUnmappableCharacter (CodingErrorAction.REPLACE) .replaceWith (ny byte [] {0}); byte [] byteArrray = encoder.encode (CharBuffer.wrap (inputString)) .array (); assertArrayEquals (ny byte [] {72, 101, 108, 108, 111, 32, 0, 0, 0, 0, 0, 33}, byteArrray); }

Her lager vi en forekomst av CharsetEncoder ved å ringe newEncoder metode på en Charset gjenstand.

Deretter spesifiserer vi handlinger for feilforhold ved å ringe onMalformedInput () og onUnmappableCharacter () metoder. Vi kan spesifisere følgende handlinger:

• IGNORER - slipp feil feil
• ERSTATT - erstatt feil feilinngang
• RAPPORT - rapporter feilen ved å returnere en CoderResult objekt eller kaste a CharacterCodingException

Videre bruker vi Erstatt med() metode for å spesifisere erstatning byte array.

Dermed fullfører vi gjennomgangen av ulike tilnærminger for å konvertere en streng til en byte-array. La oss se på omvendt operasjon.

3. Konvertering av Byte Array til String

Vi viser til prosessen med å konvertere en byte array til en String som dekoding. I likhet med koding krever denne prosessen en Charset.

Vi kan imidlertid ikke bare bruke et hvilket som helst tegnsett til å dekode et byte-utvalg. Vi bør bruke tegnsettet som ble brukt til å kode String inn i det byte array.

Vi kan konvertere en byte-array til en streng på mange måter. La oss undersøke hver av dem i detalj.

3.1. Bruker String Konstruktør

De String klassen har få konstruktører som tar en byte array som input. De ligner alle på getBytes metode, men arbeid i omvendt retning.

Først, la oss konvertere en byte-array til String ved hjelp av plattformens standardtegnsett:

@Test offentlig ugyldig nårStringConstructorWithDefaultCharset_thenOK () {byte [] byteArrray = {72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33}; Strengstreng = ny streng (byteArrray); assertNotNull (streng); }

Merk at vi ikke hevder noe her om innholdet i den dekodede strengen. Dette er fordi det kan dekode til noe annet, avhengig av plattformens standardtegnsett.

Av denne grunn bør vi generelt unngå denne metoden.

For det andre, la oss bruke et navngitt tegnsett for avkoding:

@Test offentlig ugyldig nårStringConstructorWithNamedCharset_thenOK () kaster UnsupportedEncodingException {String charsetName = "IBM01140"; byte [] byteArrray = {-56, -123, -109, -109, -106, 64, -26, -106, -103, -109, -124, 90}; Strengstreng = ny streng (byteArrray, charsetName); assertEquals ("Hello World!", streng); }

Denne metoden gir et unntak hvis det navngitte tegnsettet ikke er tilgjengelig på JVM.

For det tredje la oss bruke en Charset motsette seg å gjøre dekoding:

@Test offentlig ugyldig nårStringConstructorWithCharSet_thenOK () {Charset charset = Charset.forName ("UTF-8"); byte [] byteArrray = {72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33}; Strengstreng = ny streng (byteArrray, charset); assertEquals ("Hello World!", streng); }

Endelig, la oss bruke en standard Charset for det samme:

@Test offentlig ugyldig nårStringConstructorWithStandardCharSet_thenOK () {Charset charset = StandardCharsets.UTF_16; byte [] byteArrray = {-2, -1, 0, 72, 0, 101, 0, 108, 0, 108, 0, 111, 0, 32, 0, 87, 0, 111, 0, 114, 0, 108, 0, 100, 0, 33}; Strengstreng = ny streng (byteArrray, charset); assertEquals ("Hello World!", streng); }

Så langt har vi konvertert en byte rekke i en String ved hjelp av konstruktøren. La oss nå se på de andre tilnærmingene.

3.2. Ved hjelp av Charset.decode ()

De Charset klasse gir dekode() metode som konverterer a ByteBuffer til String:

@Test offentlig ugyldig nårDecodeWithCharset_thenOK () {byte [] byteArrray = {72, 101, 108, 108, 111, 32, -10, 111, 114, 108, -63, 33}; Charset charset = StandardCharsets.US_ASCII; Strengstreng = charset.decode (ByteBuffer.wrap (byteArrray)) .toString (); assertEquals ("Hei  orl !", streng); }

Her, den ugyldige inngangen erstattes med standard erstatningstegnet for tegnsettet.

3.3. CharsetDecoder

Alle de tidligere tilnærmingene for dekoding internt bruker CharsetDecoder klasse. Vi kan bruke denne klassen direkte for finkornet kontroll på avkodingsprosessen:

@Test offentlig ugyldig nårUsingCharsetDecoder_thenOK () kaster CharacterCodingException {byte [] byteArrray = {72, 101, 108, 108, 111, 32, -10, 111, 114, 108, -63, 33}; CharsetDecoder dekoder = StandardCharsets.US_ASCII.newDecoder (); decoder.onMalformedInput (CodingErrorAction.REPLACE) .onUnmappableCharacter (CodingErrorAction.REPLACE) .replaceWith ("?"); Strengstreng = dekoder.dekode (ByteBuffer.wrap (byteArrray)) .toString (); assertEquals ("Hei? orl ?!", streng); }

Her erstatter vi ugyldige innganger og tegn som ikke støttes med “?”.

Hvis vi ønsker å bli informert i tilfelle ugyldige innganger, kan vi endre dekoder som:

decoder.onMalformedInput (CodingErrorAction.REPORT) .onUnmappableCharacter (CodingErrorAction.REPORT)

4. Konklusjon

I denne artikkelen undersøkte vi flere måter å konvertere String til en byteoppstilling og reversere. Vi bør velge riktig metode basert på inngangsdata samt nivået på kontroll som kreves for ugyldige innganger.

Som vanlig finner du full kildekode på GitHub.