Convertir une chaîne (comme testing123) en binaire en Java
10 réponses
La manière habituelle est d'utiliser String#getBytes() pour obtenir les octets sous-jacents et ensuite présenter ces octets sous une autre forme (hex, binaire ou autre).
Notez que getBytes() utilise le jeu de caractères par défaut, donc si vous voulez que la chaîne soit convertie en un codage de caractères spécifique, vous devez utiliser getBytes(String encoding) au lieu de cela, mais souvent (surtout lorsqu'il s'agit D'ASCII)getBytes() est suffisant (et a l'avantage de ne pas lancer une exception cochée).
Pour la conversion en binaire, voici un exemple:
String s = "foo";
byte[] bytes = s.getBytes();
StringBuilder binary = new StringBuilder();
for (byte b : bytes)
{
int val = b;
for (int i = 0; i < 8; i++)
{
binary.append((val & 128) == 0 ? 0 : 1);
val <<= 1;
}
binary.append(' ');
}
System.out.println("'" + s + "' to binary: " + binary);
L'exécution de cet exemple donnera:
'foo' to binary: 01100110 01101111 01101111
un exemple plus court
private static final Charset UTF_8 = Charset.forName("UTF-8");
String text = "Hello World!";
byte[] bytes = text.getBytes(UTF_8);
System.out.println("bytes= "+Arrays.toString(bytes));
System.out.println("text again= "+new String(bytes, UTF_8));
imprime
bytes= [72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]
text again= Hello World!
String en Java peut être converti en "binaire" avec ses getBytes(Charset) méthode.
byte[] encoded = "こんにちは、世界!".getBytes(StandardCharsets.UTF_8);
L'argument de cette méthode est un "codage des caractères"; c'est normalisée mappage entre un personnage et une séquence d'octets. Souvent, chaque caractère est codé sur un octet, mais il n'y a pas assez d'octets valeurs pour représenter chaque caractère dans chaque langue. D'autres encodages utilisent plusieurs octets, de sorte qu'ils peuvent traiter une plus grande gamme de caractère.
habituellement, le codage à utiliser sera spécifié par une norme ou un protocole que vous mettez en œuvre. Si vous créez votre propre interface, et que vous avez la liberté de choisir, "UTF-8" est un encodage facile, sûr et largement supporté.
- c'est facile, parce que plutôt que d'inclure un moyen de noter le codage de chaque message, vous pouvez par défaut à UTF-8.
- c'est sûr, parce que UTF-8 peut encoder personnage qui peut être utilisé dans une chaîne de caractères Java.
- il est largement supporté, car il fait partie d'une petite poignée d'encodages de caractères qui doivent être présents dans toute implémentation Java, jusqu'à J2ME. La plupart des autres plates-formes le supportent aussi, et il est utilisé par défaut dans les normes comme XML.
Voici mes solutions. Leurs avantages sont: Code facile à comprendre, fonctionne pour tous les caractères. Profiter.
Solution 1:
public static void main(String[] args) {
String str = "CC%";
String result = "";
char[] messChar = str.toCharArray();
for (int i = 0; i < messChar.length; i++) {
result += Integer.toBinaryString(messChar[i]) + " ";
}
System.out.println(result);
}
imprime :
1000011 1000011 100101
Solution 2:
Possibilité de choisir le nombre de bits par caractère.
public static String toBinary(String str, int bits) {
String result = "";
String tmpStr;
int tmpInt;
char[] messChar = str.toCharArray();
for (int i = 0; i < messChar.length; i++) {
tmpStr = Integer.toBinaryString(messChar[i]);
tmpInt = tmpStr.length();
if(tmpInt != bits) {
tmpInt = bits - tmpInt;
if (tmpInt == bits) {
result += tmpStr;
} else if (tmpInt > 0) {
for (int j = 0; j < tmpInt; j++) {
result += "0";
}
result += tmpStr;
} else {
System.err.println("argument 'bits' is too small");
}
} else {
result += tmpStr;
}
result += " "; // separator
}
return result;
}
public static void main(String args[]) {
System.out.println(toBinary("CC%", 8));
}
imprime :
01000011 01000011 00100101
Ceci est mon implémentation.
public class Test {
public String toBinary(String text) {
StringBuilder sb = new StringBuilder();
for (char character : text.toCharArray()) {
sb.append(Integer.toBinaryString(character) + "\n");
}
return sb.toString();
}
}
import java.lang.*;
import java.io.*;
class d2b
{
public static void main(String args[]) throws IOException{
BufferedReader b = new BufferedReader(new InputStreamReader(System.in));
System.out.println("Enter the decimal value:");
String h = b.readLine();
int k = Integer.parseInt(h);
String out = Integer.toBinaryString(k);
System.out.println("Binary: " + out);
}
}
en jouant avec les réponses que j'ai trouvées ici pour me familiariser avec elle, j'ai un peu tordu la solution de Nuoji pour que je puisse la comprendre plus rapidement en la regardant dans le futur.
public static String stringToBinary(String str, boolean pad ) {
byte[] bytes = str.getBytes();
StringBuilder binary = new StringBuilder();
for (byte b : bytes)
{
binary.append(Integer.toBinaryString((int) b));
if(pad) { binary.append(' '); }
}
return binary.toString();
}
> int no=44; > String bNo=Integer.toString(no,2);//binary output 101100 > String oNo=Integer.toString(no,8);//Oct output 54 > String hNo=Integer.toString(no,16);//Hex output 2C > > String sBNo="101100"; > no=Integer.parseInt(sBNo,2);//binary to int output 44 > String sONo="54"; > no=Integer.parseInt(sONo,8);//oct to int output 44 > String sHNo="2C"; > no=Integer.parseInt(sHNo,16);//hex to int output 44
public class HexadecimalToBinaryAndLong{
public static void main(String[] args) throws IOException{
BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
System.out.println("Enter the hexa value!");
String hex = bf.readLine();
int i = Integer.parseInt(hex); //hex to decimal
String by = Integer.toBinaryString(i); //decimal to binary
System.out.println("This is Binary: " + by);
}
}
Vous pouvez aussi le faire avec l'ol " bonne méthode :
String inputLine = "test123";
String translatedString = null;
char[] stringArray = inputLine.toCharArray();
for(int i=0;i<stringArray.length;i++){
translatedString += Integer.toBinaryString((int) stringArray[i]);
}