Konverter streng til Byte Array og Reverse i Java
1. Introduktion
Vi har ofte brug for at konvertere mellem Snor og byte array i Java. I denne vejledning undersøger vi disse operationer i detaljer.
Først ser vi på forskellige måder at konvertere en Snor til en byte array. Derefter ser vi på lignende operationer i omvendt rækkefølge.
2. Konvertering Snor til Byte Array
EN Snor er gemt som en række Unicode-tegn i Java. At konvertere det til en byte array oversætter vi rækkefølgen af tegn til en række af bytes. Til denne oversættelse vi bruger en forekomst af Charset. Denne klasse angiver en kortlægning mellem en sekvens af chars og en sekvens af bytes.
Vi henviser til ovenstående proces som indkodning.
Vi kan kode en Snor ind i en byte array i Java på flere måder. Lad os se på hver af dem i detaljer med eksempler.
2.1. Ved brug af String.getBytes ()
Det Snor klasse giver tre overbelastede getBytes metoder til at kode en Snor ind i en byte array:
- getBytes () - koder ved hjælp af platformens standardtegn
- getBytes (String charsetName) - koder ved hjælp af det navngivne tegnsæt
- getBytes (Charset-charset) - koder ved hjælp af det medfølgende tegnsæt
For det første, lad os kode en streng ved hjælp af platformens standardtegn:
String inputString = "Hej verden!"; byte [] byteArrray = inputString.getBytes ();Ovenstående metode er platformafhængig, da den bruger platformens standardtegn. Vi kan få dette tegnsæt ved at ringe Charset.defaultCharset ().
For det andet lad os kode en streng ved hjælp af et navngivet tegn:
@Test offentlig ugyldigt nårGetBytesWithNamedCharset_thenOK () kaster UnsupportedEncodingException {String inputString = "Hej verden!"; 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 metode kaster Ikke-understøttet kodningUndtagelse hvis det navngivne tegnsæt ikke understøttes.
Opførelsen af ovenstående to versioner er udefineret, hvis inputet indeholder tegn, som ikke understøttes af tegnsættet. I modsætning hertil bruger den tredje version charsets standard erstatningsbyte-array til at kode ikke-understøttet input.
Næste, lad os kalde den tredje version af getBytes () metode og videregive en forekomst af Charset:
@Test offentlig ugyldig nårGetBytesWithCharset_thenOK () {String inputString = "Hej ਸੰਸਾਰ!"; 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 bruger vi fabriksmetoden Charset.forName for at få en forekomst af Charset. Denne metode kaster en undtagelse for kørsel, hvis navnet på det anmodede tegnsæt er ugyldigt. Det giver også en runtime-undtagelse, hvis tegnsættet understøttes i den aktuelle JVM.
Dog er nogle tegnsæt garanteret tilgængelige på alle Java-platforme. Det Standardcharsæt klasse definerer konstanter for disse tegnsæt.
Langt om længe, lad os kode ved hjælp af et af standardtegnene:
@Test offentlig ugyldig nårGetBytesWithStandardCharset_thenOK () {String inputString = "Hej verden!"; 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); }Således gennemfører vi gennemgangen af de forskellige getBytes versioner. Lad os derefter se på metoden leveret af Charset sig selv.
2.2. Ved brug af Charset.encode ()
Det Charset klasse giver kode (), en praktisk metode, der koder Unicode-tegn i bytes. Denne metode erstatter altid ugyldige input og tegn, der ikke kan omstilles, ved hjælp af tegnets standardbyte-array.
Lad os bruge kode metode til at konvertere en Snor ind i en byte matrix:
@Test offentlig ugyldig nårEncodeWithCharset_thenOK () {String inputString = "Hej ਸੰਸਾਰ!"; 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-understøttede tegn blevet erstattet med tegnsættets standardudskiftning byte 63.
De hidtil anvendte tilgange bruger CharsetEncoder klasse internt for at udføre kodning. Lad os undersøge denne klasse i det næste afsnit.
2.3. CharsetEncoder
CharsetEncoder omdanner Unicode-tegn til en sekvens af bytes for et givet tegnsæt. Desuden giver det finkornet kontrol over kodningsprocessen.
Lad os bruge denne klasse til at konvertere en Snor ind i en byte matrix:
@Test offentlig ugyldig nårUsingCharsetEncoder_thenOK () kaster CharacterCodingException {String inputString = "Hej ਸੰਸਾਰ!"; 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 opretter vi en forekomst af CharsetEncoder ved at ringe til newEncoder metode på en Charset objekt.
Derefter specificerer vi handlinger for fejltilstande ved at ringe til onMalformedInput () og onUmappableCharacter () metoder. Vi kan specificere følgende handlinger:
- IGNORE - slip det fejlagtige input
- ERSTAT - udskift den fejlagtige input
- RAPPORT - rapporter fejlen ved at returnere en CoderResult objekt eller kaste en CharacterCodingException
Desuden bruger vi Erstat med() metode til at specificere udskiftningen byte array.
Således gennemfører vi gennemgangen af forskellige tilgange til at konvertere en streng til en byte-array. Lad os næste se på den omvendte operation.
3. Konvertering af byte-array til streng
Vi henviser til processen med at konvertere en byte array til en Snor som afkodning. Svarende til kodning kræver denne proces en Charset.
Vi kan dog ikke bare bruge et hvilket som helst tegn til afkodning af et byte-array. Vi skal bruge det tegnsæt, der blev brugt til at kode Snor ind i byte array.
Vi kan konvertere et byte-array til en streng på mange måder. Lad os undersøge hver af dem i detaljer.
3.1. Bruger Snor Konstruktør
Det Snor klasse har få konstruktører, der tager en byte array som input. De ligner alle getBytes metode, men arbejd omvendt.
Først, lad os konvertere et byte-array til Snor ved hjælp af platformens standardtegn:
@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); }Bemærk, at vi ikke hævder noget her om indholdet af den afkodede streng. Dette skyldes, at det kan afkode til noget andet, afhængigt af platformens standardtegn.
Af denne grund bør vi generelt undgå denne metode.
For det andet lad os bruge et navngivet tegnsæt til afkodning:
@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 metode giver en undtagelse, hvis det navngivne tegn ikke er tilgængeligt på JVM.
For det tredje lad os bruge en Charset modsætter sig afkodning:
@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); }Langt om længe, lad os bruge 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); }Indtil videre har vi konverteret en byte array i en Snor ved hjælp af konstruktøren. Lad os nu se på de andre tilgange.
3.2. Ved brug af Charset.decode ()
Det Charset klasse giver afkode () metode, der konverterer en ByteBuffer til Snor:
@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 ("Hej orl !", streng); }Her, den ugyldige input erstattes med standard erstatningstegnet for tegnsættet.
3.3. CharsetDecoder
Alle de tidligere tilgange til afkodning internt bruger CharsetDecoder klasse. Vi kan bruge denne klasse direkte til finkornet kontrol af afkodningsprocessen:
@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 = decoder.decode (ByteBuffer.wrap (byteArrray)) .toString (); assertEquals ("Hej? orl ?!", streng); }Her erstatter vi ugyldige input og ikke-understøttede tegn med “?”.
Hvis vi ønsker at blive informeret i tilfælde af ugyldige input, kan vi ændre dekoder som:
decoder.onMalformedInput (CodingErrorAction.REPORT) .onUnmappableCharacter (CodingErrorAction.REPORT)4. Konklusion
I denne artikel undersøgte vi flere måder at konvertere på Snor til et byte-array og reverse. Vi bør vælge den passende metode baseret på inputdataene samt niveauet for kontrol, der kræves for ugyldige input.
Som sædvanlig kan den fulde kildekode findes på GitHub.
