Tukar rentetan kepada tatasusunan bait menggunakan kaedah getBytes(pengekodan) dalam Java

Dalam dunia pengaturcaraan Java, anda boleh menukar rentetan kepada tatasusunan bait dengan menggunakan fungsi "getBytes()". Hasil akhir proses ini adalah untuk mendapatkan perwakilan tatasusunan bait bagi rentetan permulaan, dengan pengekodan ditentukan oleh spesifikasi kaedah. Terdapat dua cara berbeza untuk menukar rentetan kepada tatasusunan bait dalam Java dengan menggunakan fungsi "getBytes()". Strategi pertama melibatkan penggunaan pengekodan set aksara lalai JVM, yang merupakan teknik pengekodan. Kaedah kedua bergantung pada pengekodan set aksara khusus yang disediakan dan menentukan pengekodan yang hendak digunakan berdasarkan keperluan aplikasi yang dipersoalkan.

Dalam artikel ini, kami akan melihat dengan lebih dekat kedua-dua kaedah, sambil turut menyediakan contoh pelaksanaan kod dan output untuk setiap kaedah.

Kaedah penggunaan

Artikel ini membincangkan tiga cara berbeza untuk menukar rentetan kepada tatasusunan bait dalam Java.

• Kaedah 1 - Kaedah pertama melibatkan penggunaan pengekodan set aksara lalai. Memanggil kaedah 'getBytes()' pada objek rentetan tanpa pengekodan ditentukan menyebabkan pengekodan set aksara lalai digunakan. Kaedah ini sesuai apabila penukaran tidak memerlukan pengekodan khusus.

• Kaedah 2 - Kaedah kedua melibatkan penggunaan pengekodan set aksara khusus untuk kaedah "getBytes()". Kaedah ini berguna apabila penukaran memerlukan pengekodan yang berbeza daripada pengekodan lalai. Pilihan pengekodan bergantung pada keperluan khusus aplikasi.

• Kaedah 3 - Kaedah ketiga menggunakan kelas `ByteBuffer` dalam Java. Kelas ini menyediakan kaedah untuk menukar rentetan kepada tatasusunan bait dan sebaliknya. Kelas `Charset` digunakan untuk menentukan pengekodan yang digunakan untuk penukaran. Pendekatan ini boleh membantu apabila berurusan dengan pengekodan aksara yang kompleks atau apabila lebih banyak penukaran boleh disesuaikan diperlukan.

Kaedah

getBytes(pengekodan) mengambil pengekodan parameter rentetan, yang menentukan skema pengekodan aksara yang akan digunakan. Kaedah ini mengembalikan tatasusunan bait yang mewakili rentetan dalam pengekodan yang ditentukan. Sintaks kaedah ini adalah seperti berikut -

Tatabahasa

byte[] byteArray = str.getBytes(encoding);

Di mana str ialah rentetan yang hendak ditukar dan pengekodan ialah nama skim pengekodan.

Algoritma

Untuk menukar rentetan kepada tatasusunan bait dalam Java, anda boleh mengikuti langkah ini -

• Langkah 1 - Dapatkan rentetan yang anda mahu tukar kepada tatasusunan bait.

• Langkah 2 - Tentukan pengekodan untuk digunakan untuk penukaran. Jika tiada pengekodan dinyatakan, pengekodan set aksara lalai akan digunakan.

• Langkah 3 - Panggil kaedah "getBytes()" pada objek rentetan dan lulus pengekodan sebagai parameter. Ini mengembalikan perwakilan tatasusunan bait rentetan.

• Langkah 4 - Simpan tatasusunan bait dalam pembolehubah untuk kegunaan masa hadapan.

• Langkah 5 - Jika JVM tidak menyokong pengekodan yang ditentukan, kaedah "getBytes()" akan membuang "UnsupportedEncodingException". Anda boleh mengendalikan pengecualian ini menggunakan blok cuba-tangkap.

• Langkah 6 - Cetak tatasusunan bait dalam format yang boleh dibaca menggunakan kaedah `Arrays.toString()`.

• Langkah 7 - Jika perlu, tukarkan tatasusunan bait kembali kepada rentetan menggunakan kaedah "String(byteArray,encoding)" baharu.

• Langkah 8 - Tatasusunan bait yang ditukar kini sedia untuk penghantaran atau pemprosesan selanjutnya.

Perhatikan bahawa langkah atau pengubahsuaian tambahan mungkin diperlukan bergantung pada keperluan khusus permohonan anda.

Kaedah 1

Kaedah menukar rentetan kepada tatasusunan bait dalam Java menggunakan pengekodan set aksara lalai, iaitu pengekodan yang digunakan oleh JVM secara lalai. Pendekatan ini mudah dan mudah, tetapi mungkin tidak sesuai jika aplikasi memerlukan pengekodan khusus.

Contoh

import java.util.Arrays;

public class StringToByteArray {
   public static void main(String[] args) {
      String str = "Hello, world!";
      byte[] byteArray = str.getBytes();
      System.out.println("Byte array using default charset encoding: " + Arrays.toString(byteArray));
   }
}

Output

Byte array using default charset encoding: [72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33]

Kaedah 2

Kaedah menukar rentetan kepada tatasusunan bait dalam Java membolehkan kami menentukan pengekodan set aksara tertentu untuk digunakan. Ini memberi kami kawalan yang lebih besar ke atas pengekodan yang digunakan untuk penukaran dan memastikan tatasusunan bait serasi dengan sistem sasaran.

Di bawah ialah kod program yang sama.

Contoh

import java.util.Arrays;
import java.io.UnsupportedEncodingException;

public class StringToByteArray {
   public static void main(String[] args) {
      String str = "Hello, world!";
      String encoding = "UTF-16";
      byte[] byteArray = null;
      try {
          byteArray = str.getBytes(encoding);
      } catch (UnsupportedEncodingException e) {
         e.printStackTrace();
      }
      System.out.println("Byte array using " + encoding + " encoding: " + Arrays.toString(byteArray));
   }
}

Output

Byte array using UTF-16 encoding: [-2, -1, 0, 72, 0, 101, 0, 108, 0, 108, 0, 111, 0, 44, 0, 32, 0, 119, 0, 111, 0, 114, 0, 108, 0, 100, 0, 33, 0]

Dalam output ini, kita dapat melihat bahawa tatasusunan bait mengandungi dua bait tambahan (-2 dan -1) pada permulaan berbanding kaedah pengekodan lalai. Kedua-dua bait ini mewakili susunan bait pengekodan UTF-16.

Kaedah 3

Kaedah menukar rentetan kepada tatasusunan bait dalam Java menggunakan kelas ByteBuffer untuk menyediakan kaedah untuk menukar rentetan kepada tatasusunan bait dan begitu juga sebaliknya. Kaedah ini sangat berguna apabila kita perlu melakukan operasi lain pada tatasusunan bait menggunakan kaedah yang disediakan oleh kelas ByteBuffer.

Contoh

import java.nio.ByteBuffer;
import java.nio.charset.Charset;
import java.util.Arrays;

public class StringToByteArray {
   public static void main(String[] args) {
      String str = "Hello, world!";
      Charset charset = Charset.forName("UTF-8");
      ByteBuffer byteBuffer = charset.encode(str);
      byte[] byteArray = byteBuffer.array();
      System.out.println("Byte array using ByteBuffer class: " + Arrays.toString(byteArray));
   }
}

Output

Byte array using ByteBuffer class: [72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33, 0]

Kesimpulan

Ringkasnya, menukar rentetan kepada tatasusunan bait dalam Java boleh dicapai melalui kaedah "getBytes()". Terdapat dua kaedah, satu menggunakan pengekodan set aksara lalai dan satu lagi menggunakan pengekodan set aksara tertentu. Pilihan kaedah bergantung kepada keperluan permohonan. Kelas "ByteBuffer" juga boleh digunakan untuk penukaran ini, menggunakan kelas "Charset" untuk menentukan pengekodan. Kami menyediakan contoh dan output kod terperinci untuk setiap kaedah.

Atas ialah kandungan terperinci Tukar rentetan kepada tatasusunan bait menggunakan kaedah getBytes(pengekodan) dalam Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!