जावा में हेक्साडेसिमल के लिए एक स्ट्रिंग परिवर्तित

Question

मैं जावा में हेक्साडेसिमल रूप में "test123" जैसे एक स्ट्रिंग को बदलने की कोशिश कर रहा हूं। मैं वर्तमान में BlueJ का उपयोग कर रहा हूं।

और इसे वापस परिवर्तित करने के लिए, क्या यह पिछड़े को छोड़कर एक ही बात है?

Comments

अब तक आपके पास मौजूद कोड दिखाने के लिए कृपया अपने प्रश्न को संपादित करें । आपको उस कोड की कम से कम एक रूपरेखा (लेकिन अधिमानतः एक न्यूनतम प्रतिलिपि प्रस्तुत करने योग्य उदाहरण ) को शामिल करना चाहिए जिसमें आपको समस्या हो रही है, तो हम विशिष्ट समस्या के साथ मदद करने का प्रयास कर सकते हैं। आपको कैसे पूछना है यह भी पढ़ना चाहिए ।

— टोबे स्पाइट

Answer 1

यहाँ इसे हेक्स में बदलने का एक छोटा तरीका है:

public String toHex(String arg) {
    return String.format("%040x", new BigInteger(1, arg.getBytes(/*YOUR_CHARSET?*/)));
}

Comments

+1 मैंने कभी देखा 3vilness का सबसे शुद्ध नमूना: एक बाइट से कन्वर्ट करने के लिए एक BigInteger का उपयोग करते हुए [... ...

— एडुआर्डो कोस्टा

इसे प्यार करना! न कोई लूप और न ही कोई फ़्लिपिंग। मैं आपको 0xFF

— अपवोट्स

40 वर्णों को सुनिश्चित करने के लिए, आपको शून्य पैडिंग जोड़ना चाहिए: रिटर्न String.format ("% 040x", नया BigInteger (arg.getBytes (/ * your_CHARSET? * /)));

— रॉन

@ कालेब क्या आपको पता है कि यदि संभव हो तो परिणामी स्ट्रिंग को वापस बदलना होगा? यदि, हाँ, तो क्या आप मुझे कुछ संकेत दे सकते हैं? धन्यवाद!

— आर्टैक्सरिक्स

आपको BigInteger(int,byte[])कंस्ट्रक्टर का उपयोग करना होगा ; अन्यथा यदि पहली बाइट ऋणात्मक है तो आपको एक नकारात्मक बिगइंटर मिलता है।

— जोनी

Answer 2

यह सुनिश्चित करने के लिए कि हेक्स हमेशा 40 वर्ण लंबा है, BigInteger को सकारात्मक होना चाहिए:

public String toHex(String arg) {
  return String.format("%x", new BigInteger(1, arg.getBytes(/*YOUR_CHARSET?*/)));
}

Comments

यह विधि वास्तव में सही है। कोशिश byte[] data = { -1, 1 };- इस जवाब में कोड ठीक काम करता है, जबकि 17 अपवोट के साथ विफल रहता है।

— हुदोल्जेव

क्या -1एक स्ट्रिंग से मूल्य के साथ बाइट प्राप्त करना संभव है (उदाहरण में अनुरोध किया गया था)?

— कालेब पेडरसन

@KalebPederson हाँ। यह बहुत कठिन नहीं है। । यदि आपका चुना हुआ एन्कोडिंग कभी भी किसी भी वर्ण का सबसे महत्वपूर्ण बिट का उपयोग करता है (जैसे, UTF- * करते हैं), तो आपके पास byteआपके सरणी में नकारात्मक s है।

— निधि मोनिका का मुकदमा

Answer 3

import org.apache.commons.codec.binary.Hex;
...

String hexString = Hex.encodeHexString(myString.getBytes(/* charset */));

http://commons.apache.org/codec/apidocs/org/apache/commons/codec/binary/Hex.html

Comments

दिलचस्प है, अगर आप पहिया को फिर से संगठित नहीं करना चाहते हैं।

— फ़ेडरिको ज़नकैन

@MelNicholson को बाइट [] में जाने के लिए हेक्स में एक डिकोडेक्स फ़ंक्शन है। आपको इसका उपयोग करने की आवश्यकता है क्योंकि कुछ भी गारंटी नहीं देता है कि यादृच्छिक एचईएक्स स्ट्रिंग को आपके एन्कोडिंग में स्ट्रिंग में परिवर्तित किया जा सकता है।

— BxlSofty

Answer 4

संख्या जो आप हेक्साडेसिमल में एनकोड करते हैं, उसे वर्णों के कुछ एन्कोडिंग का प्रतिनिधित्व करना चाहिए, जैसे कि यूटीएफ -8। इसलिए पहले स्ट्रिंग को बाइट में परिवर्तित करें [] उस एन्कोडिंग में स्ट्रिंग का प्रतिनिधित्व करते हैं, फिर प्रत्येक बाइट को हेक्साडेसिमल में बदलते हैं।

public static String hexadecimal(String input, String charsetName) throws UnsupportedEncodingException {
    if (input == null) throw new NullPointerException();
    return asHex(input.getBytes(charsetName));
}

private static final char[] HEX_CHARS = "0123456789abcdef".toCharArray();

public static String asHex(byte[] buf)
{
    char[] chars = new char[2 * buf.length];
    for (int i = 0; i < buf.length; ++i)
    {
        chars[2 * i] = HEX_CHARS[(buf[i] & 0xF0) >>> 4];
        chars[2 * i + 1] = HEX_CHARS[buf[i] & 0x0F];
    }
    return new String(chars);
}

Comments

यह एक दिलचस्प समाधान है और एक है जो डेटा के डिजिटल प्रतिनिधित्व के मूल पर प्रहार करता है। क्या आप बता सकते हैं कि आप हालांकि क्या कर रहे हैं, और आपके समाधान में "मैजिक नंबर" क्या दर्शाते हैं? एक नवागंतुक को पता नहीं हो सकता है कि >>> ऑपरेटर का क्या अर्थ है, हम बिटएक्स-एंड का उपयोग क्यों करते हैं और 0xF0 के मास्क के साथ, या वर्ण सरणी का आकार क्यों है [2 * buf.length]।

— बोरिस

Answer 5

उपयोग करें DatatypeConverter.printHexBinary():

public static String toHexadecimal(String text) throws UnsupportedEncodingException
{
    byte[] myBytes = text.getBytes("UTF-8");

    return DatatypeConverter.printHexBinary(myBytes);
}

उदाहरण का उपयोग:

System.out.println(toHexadecimal("Hello StackOverflow"));

प्रिंटों:

48656C6C6F20537461636B4F766572666C6F77

नोट : इससे थोड़ी अतिरिक्त परेशानी होती हैJava 9 एपीआई के डिफ़ॉल्ट रूप से शामिल नहीं होने के । संदर्भ के लिए उदाहरण के लिए इस GitHub मुद्दे को देखें ।

Answer 6

यहाँ एक अन्य समाधान है

public static String toHexString(byte[] ba) {
    StringBuilder str = new StringBuilder();
    for(int i = 0; i < ba.length; i++)
        str.append(String.format("%x", ba[i]));
    return str.toString();
}

public static String fromHexString(String hex) {
    StringBuilder str = new StringBuilder();
    for (int i = 0; i < hex.length(); i+=2) {
        str.append((char) Integer.parseInt(hex.substring(i, i + 2), 16));
    }
    return str.toString();
}

Comments

अच्छा, लेकिन मैं format("%02x")इतना प्रारूप () हमेशा 2 वर्णों का उपयोग करता हूं । हालांकि ASCII डबल डिजिट हेक्स है, A = 0x65

— माइक जोंस

Answer 7

String.getBytes () पर आधारित सभी उत्तरों में Charset के अनुसार आपके स्ट्रिंग को एन्कोड करना शामिल है । जरूरी नहीं कि आप अपने स्ट्रिंग बनाने वाले 2-बाइट वर्णों का हेक्स मान प्राप्त करें । यदि आप वास्तव में चाहते हैं कि एक हेक्स दर्शक के बराबर है, तो आपको सीधे वर्णों तक पहुंचने की आवश्यकता है। यहां वह फ़ंक्शन है जो मैं यूनिकोड मुद्दों को डीबग करने के लिए अपने कोड में उपयोग करता हूं:

static String stringToHex(String string) {
  StringBuilder buf = new StringBuilder(200);
  for (char ch: string.toCharArray()) {
    if (buf.length() > 0)
      buf.append(' ');
    buf.append(String.format("%04x", (int) ch));
  }
  return buf.toString();
}

फिर, stringToHex ("टेस्टिंग123") आपको देगा:

0074 0065 0073 0074 0069 006e 0067 0031 0032 0033

Comments

यह ठीक है अगर आप चाहते हैं कि जावा वर्णों का आंतरिक प्रतिनिधित्व देखना है, जो यूटीएफ -16 है, जो यूनिकोड का विशिष्ट प्रतिनिधित्व है।

— जोनाथन रोसेन

Answer 8

byte[] bytes = string.getBytes(CHARSET); // you didn't say what charset you wanted
BigInteger bigInt = new BigInteger(bytes);
String hexString = bigInt.toString(16); // 16 is the radix

आप hexStringइस बिंदु पर लौट सकते हैं , इस चेतावनी के साथ कि प्रमुख अशक्तियाँ छीन ली जाएंगी, और परिणाम में एक विषम लंबाई होगी यदि पहली बाइट 16 से कम है। यदि आपको उन मामलों को संभालने की आवश्यकता है, तो आप कुछ अतिरिक्त कोड जोड़ सकते हैं 0s के साथ पैड करने के लिए:

StringBuilder sb = new StringBuilder();
while ((sb.length() + hexString.length()) < (2 * bytes.length)) {
  sb.append("0");
}
sb.append(hexString);
return sb.toString();

Answer 9

हेक्स के पूर्णांक मूल्य प्राप्त करने के लिए

        //hex like: 0xfff7931e to int
        int hexInt = Long.decode(hexString).intValue();

Answer 10

पत्र में हेक्स कोड और हेक्स कोड में एक पत्र में परिवर्तित करें।

        String letter = "a";
    String code;
    int decimal;

    code = Integer.toHexString(letter.charAt(0));
    decimal = Integer.parseInt(code, 16);

    System.out.println("Hex code to " + letter + " = " + code);
    System.out.println("Char to " + code + " = " + (char) decimal);

Answer 11

मैं कुछ इस तरह का सुझाव दूंगा, जहां strआपका इनपुट स्ट्रिंग है:

StringBuffer hex = new StringBuffer();
char[] raw = tokens[0].toCharArray();
for (int i=0;i<raw.length;i++) {
    if     (raw[i]<=0x000F) { hex.append("000"); }
    else if(raw[i]<=0x00FF) { hex.append("00" ); }
    else if(raw[i]<=0x0FFF) { hex.append("0"  ); }
    hex.append(Integer.toHexString(raw[i]).toUpperCase());
}

Comments

सुधार के लिए धन्यवाद, सॉफ्टवेयर बंदर। जब मैंने उत्तर लिखा तो मैं बहुत थक गया था, और 'कच्चे [i] <= 9' के लिए मेरा परीक्षण स्पष्ट रूप से अपर्याप्त है।

— रोडिओन

यह वास्तव में अच्छा काम करता है, क्या उत्पन्न हेक्स को फिर से स्ट्रिंग में वापस करने का एक तरीका है?

इसमें कहां फंसा है?

— विश्वनाथ लीक्षमान 21

Answer 12

पहले इसे getBytes () फ़ंक्शन का उपयोग करके बाइट में परिवर्तित करें और फिर इसे हेक्स usign में परिवर्तित करें:

private static String hex(byte[] bytes) {
    StringBuilder sb = new StringBuilder();
    for (int i=0; i<bytes.length; i++) {
        sb.append(String.format("%02X ",bytes[i]));
    }
    return sb.toString();
}

Answer 13

दूसरे तरीके से जाने के लिए (हेक्स टू स्ट्रिंग), आप उपयोग कर सकते हैं

public String hexToString(String hex) {
    return new String(new BigInteger(hex, 16).toByteArray());
}

Answer 14

import java.io.*;
import java.util.*;

public class Exer5{

    public String ConvertToHexadecimal(int num){
        int r;
        String bin="\0";

        do{
            r=num%16;
            num=num/16;

            if(r==10)
            bin="A"+bin;

            else if(r==11)
            bin="B"+bin;

            else if(r==12)
            bin="C"+bin;

            else if(r==13)
            bin="D"+bin;

            else if(r==14)
            bin="E"+bin;

            else if(r==15)
            bin="F"+bin;

            else
            bin=r+bin;
        }while(num!=0);

        return bin;
    }

    public int ConvertFromHexadecimalToDecimal(String num){
        int a;
        int ctr=0;
        double prod=0;

        for(int i=num.length(); i>0; i--){

            if(num.charAt(i-1)=='a'||num.charAt(i-1)=='A')
            a=10;

            else if(num.charAt(i-1)=='b'||num.charAt(i-1)=='B')
            a=11;

            else if(num.charAt(i-1)=='c'||num.charAt(i-1)=='C')
            a=12;

            else if(num.charAt(i-1)=='d'||num.charAt(i-1)=='D')
            a=13;

            else if(num.charAt(i-1)=='e'||num.charAt(i-1)=='E')
            a=14;

            else if(num.charAt(i-1)=='f'||num.charAt(i-1)=='F')
            a=15;

            else
            a=Character.getNumericValue(num.charAt(i-1));
            prod=prod+(a*Math.pow(16, ctr));
            ctr++;
        }
        return (int)prod;
    }

    public static void main(String[] args){

        Exer5 dh=new Exer5();
        Scanner s=new Scanner(System.in);

        int num;
        String numS;
        int choice;

        System.out.println("Enter your desired choice:");
        System.out.println("1 - DECIMAL TO HEXADECIMAL             ");
        System.out.println("2 - HEXADECIMAL TO DECIMAL              ");
        System.out.println("0 - EXIT                          ");

        do{
            System.out.print("\nEnter Choice: ");
            choice=s.nextInt();

            if(choice==1){
                System.out.println("Enter decimal number: ");
                num=s.nextInt();
                System.out.println(dh.ConvertToHexadecimal(num));
            }

            else if(choice==2){
                System.out.println("Enter hexadecimal number: ");
                numS=s.next();
                System.out.println(dh.ConvertFromHexadecimalToDecimal(numS));
            }
        }while(choice!=0);
    }
}

Answer 15

new BigInteger(1, myString.getBytes(/*YOUR_CHARSET?*/)).toString(16)

Answer 16

परिवर्तित स्ट्रिंग को हेक्साडेसिमल :

public String hexToString(String hex) {
    return Integer.toHexString(Integer.parseInt(hex));
}

निश्चित रूप से यह आसान तरीका है।

Comments

यह कोई हल नहीं है। सवाल पूछ रहा है कि एक मनमाने ढंग से स्ट्रिंग की सामग्री का हेक्स प्रतिनिधित्व कैसे प्राप्त करें, और विशेष रूप से उदाहरण के रूप में "परीक्षण -123" प्रदान किया ।

— skomisa

Answer 17

मल्टीपल पीपल्स का उपयोग करने से कई थ्रेड्स की मदद मिलती है।

मुझे पता है कि यह उत्तर दिया गया है, लेकिन मैं अपनी उसी स्थिति में किसी अन्य के लिए पूर्ण सांकेतिक शब्दों में बदलना और डिकोड विधि देना चाहूंगा।

यहाँ मेरे एन्कोडिंग और डिकोडिंग के तरीके हैं ..

// Global Charset Encoding
public static Charset encodingType = StandardCharsets.UTF_8;

// Text To Hex
public static String textToHex(String text)
{
    byte[] buf = null;
    buf = text.getBytes(encodingType);
    char[] HEX_CHARS = "0123456789abcdef".toCharArray();
    char[] chars = new char[2 * buf.length];
    for (int i = 0; i < buf.length; ++i)
    {
        chars[2 * i] = HEX_CHARS[(buf[i] & 0xF0) >>> 4];
        chars[2 * i + 1] = HEX_CHARS[buf[i] & 0x0F];
    }
    return new String(chars);
}

// Hex To Text
public static String hexToText(String hex)
{
    int l = hex.length();
    byte[] data = new byte[l / 2];
    for (int i = 0; i < l; i += 2)
    {
        data[i / 2] = (byte) ((Character.digit(hex.charAt(i), 16) << 4)
            + Character.digit(hex.charAt(i + 1), 16));
    }
    String st = new String(data, encodingType);
    return st;
}

Comments

अच्छा! केवल लाइन 13, ">>>" पर ">>" होना चाहिए

— स्पाइकयांग

Answer 18

काफी बेहतर:

public static String fromHexString(String hex, String sourceEncoding ) throws  IOException{
    ByteArrayOutputStream bout = new ByteArrayOutputStream();
    byte[] buffer = new byte[512];
    int _start=0;
    for (int i = 0; i < hex.length(); i+=2) {
        buffer[_start++] = (byte)Integer.parseInt(hex.substring(i, i + 2), 16);
        if (_start >=buffer.length || i+2>=hex.length()) {
            bout.write(buffer);
            Arrays.fill(buffer, 0, buffer.length, (byte)0);
            _start  = 0;
        }
    }

    return  new String(bout.toByteArray(), sourceEncoding);
}

Answer 19

यहां कुछ दृष्टिकोण अलग-अलग दृष्टिकोणों और पुस्तकालयों की तुलना कर रहे हैं । अमरूद डिकोडिंग पर अपाचे कॉमन्स कोडेक को हराता है। कॉमन्स कोडेक एन्कोडिंग में अमरूद को हराता है। और JHEX डिकोडिंग और एन्कोडिंग दोनों के लिए उन्हें हरा देता है।

JHex उदाहरण

String hexString = "596f752772652077656c636f6d652e";
byte[] decoded = JHex.decodeChecked(hexString);
System.out.println(new String(decoded));
String reEncoded = JHex.encode(decoded);

सब कुछ JHex के लिए एक एकल वर्ग फ़ाइल में है । यदि आप अभी तक अपने निर्भरता के पेड़ में एक और पुस्तकालय नहीं चाहते हैं तो पेस्ट कॉपी करने के लिए स्वतंत्र महसूस करें। यह भी ध्यान दें, यह केवल जावा 9 जार के रूप में उपलब्ध है, जब तक मैं यह पता नहीं लगा सकता कि ग्रैडल और बिंट्रे प्लगइन के साथ कई रिलीज़ लक्ष्यों को कैसे प्रकाशित किया जाए।

Answer 20

स्ट्रिंग को अपने हेक्साडेसिमल संकेतन में बदलने का एक छोटा और सुविधाजनक तरीका है:

public static void main(String... args){
String str = "Hello! This is test string.";
char ch[] = str.toCharArray();
StringBuilder sb = new StringBuilder();
    for (int i = 0; i < ch.length; i++) {
        sb.append(Integer.toHexString((int) ch[i]));
    }
    System.out.println(sb.toString());
}

Answer 21

स्ट्रिंग टू हेक्स और हेक्स टू स्ट्रिंग विसे-वर्सा के लिए इस समाधान की जाँच करें

public class TestHexConversion {
public static void main(String[] args) {
    try{
        String clearText = "testString For;0181;with.love";
        System.out.println("Clear Text  = " + clearText);
        char[] chars = clearText.toCharArray();
        StringBuffer hex = new StringBuffer();
        for (int i = 0; i < chars.length; i++) {
            hex.append(Integer.toHexString((int) chars[i]));
        }
        String hexText = hex.toString();
        System.out.println("Hex Text  = " + hexText);
        String decodedText = HexToString(hexText);
        System.out.println("Decoded Text = "+decodedText);
    } catch (Exception e){
        e.printStackTrace();
    }
}

public static String HexToString(String hex){

      StringBuilder finalString = new StringBuilder();
      StringBuilder tempString = new StringBuilder();

      for( int i=0; i<hex.length()-1; i+=2 ){
          String output = hex.substring(i, (i + 2));
          int decimal = Integer.parseInt(output, 16);
          finalString.append((char)decimal);
          tempString.append(decimal);
      }
    return finalString.toString();
}

आउटपुट निम्नानुसार है:

क्लियर टेक्स्ट = टेस्टस्ट्रीमिंग फॉर; 0181; with.love

हेक्स पाठ = 67४६५47३45४47४47६६६६६६६६६६६६६६ परफोर्मा १३83३83३३३b३b३e६e६c६६६६६६६६65६65६६५

डिकोडेड पाठ = परीक्षण के लिए; 0181; with.love