Java Language
स्ट्रिंग्स से और से परिवर्तित

स्ट्रिंग के लिए अन्य डेटाटाइप्स परिवर्तित करना

• आप एक स्ट्रिंग एक स्ट्रिंग वर्ग का उपयोग जैसे अन्य पुराने डेटा प्रकार के मूल्य प्राप्त कर सकते हैं valueOf तरीकों।

  उदाहरण के लिए:

  int i = 42;
  String string = String.valueOf(i);
  //string now equals "42”.
  

  यह विधि अन्य डेटाैटिप्स के लिए भी भरी हुई है, जैसे कि float , double , boolean और यहां तक कि Object ।

• तुम भी फोन करके एक स्ट्रिंग के रूप में किसी अन्य वस्तु (किसी भी वर्ग के किसी भी मामले) प्राप्त कर सकते हैं .toString उस पर। इसके लिए उपयोगी आउटपुट देने के लिए, क्लास को toString() चाहिए। अधिकांश मानक जावा पुस्तकालय कक्षाएं करते हैं, जैसे कि Date और अन्य।

  उदाहरण के लिए:

  Foo foo = new Foo(); //Any class.
  String stringifiedFoo = foo.toString().
  

  यहाँ stringifiedFoo का प्रतिनिधित्व होता है foo एक स्ट्रिंग के रूप में।

आप किसी भी संख्या प्रकार को नीचे दिए गए संक्षिप्त संकेतन के साथ बदल सकते हैं।

int i = 10;
String str = i + "";

या बस आसान तरीका है

String str = 10 + "";

बाइट्स से / में रूपांतरण

एक स्ट्रिंग को बाइट सरणी में एनकोड करने के लिए, आप किसी भी String#getBytes() क्रम में किसी भी मानक रन सेट के साथ String#getBytes() विधि का उपयोग कर सकते हैं:

byte[] bytes = "test".getBytes(StandardCharsets.UTF_8);

और डीकोड करने के लिए:

String testString = new String(bytes, StandardCharsets.UTF_8);

आप स्थैतिक आयात का उपयोग करके कॉल को सरल बना सकते हैं:

import static java.nio.charset.StandardCharsets.UTF_8;
...
byte[] bytes = "test".getBytes(UTF_8);

कम सामान्य वर्ण सेटों के लिए आप स्ट्रिंग के साथ सेट किए गए वर्ण को इंगित कर सकते हैं:

byte[] bytes = "test".getBytes("UTF-8");

और रिवर्स:

String testString = new String (bytes, "UTF-8");

हालांकि इसका मतलब यह है कि आपको चेक किए गए UnsupportedCharsetException को संभालना होगा।

निम्न कॉल डिफ़ॉल्ट वर्ण सेट का उपयोग करेगा। डिफ़ॉल्ट वर्ण सेट प्लेटफ़ॉर्म विशिष्ट है और आम तौर पर विंडोज, मैक और लिनक्स प्लेटफार्मों के बीच भिन्न होता है।

byte[] bytes = "test".getBytes();

और रिवर्स:

String testString = new String(bytes);

ध्यान दें कि अमान्य वर्ण और बाइट इन विधियों द्वारा प्रतिस्थापित या छोड़ दिए जा सकते हैं। अधिक नियंत्रण के लिए - उदाहरण के लिए इनपुट को मान्य करने के लिए - आपको CharsetEncoder और CharsetDecoder कक्षाओं का उपयोग करने के लिए प्रोत्साहित किया जाता है।

बेस 64 एनकोडिंग / डिकोडिंग

कभी-कभी आपको द्विआधारी डेटा को बेस 64- एन्कोडेड स्ट्रिंग के रूप में एन्कोड करने की आवश्यकता होगी।

इसके लिए हम javax.xml.bind पैकेज से DatatypeConverter क्लास का उपयोग कर सकते हैं:

import javax.xml.bind.DatatypeConverter;
import java.util.Arrays;

// arbitrary binary data specified as a byte array
byte[] binaryData = "some arbitrary data".getBytes("UTF-8");

// convert the binary data to the base64-encoded string
String encodedData = DatatypeConverter.printBase64Binary(binaryData);
// encodedData is now "c29tZSBhcmJpdHJhcnkgZGF0YQ=="

// convert the base64-encoded string back to a byte array
byte[] decodedData = DatatypeConverter.parseBase64Binary(encodedData);

// assert that the original data and the decoded data are equal
assert Arrays.equals(binaryData, decodedData);

अपाचे कॉमन्स-कोडेक

वैकल्पिक रूप से, हम अपाचे कॉमन्स-कोडेक से Base64 उपयोग कर सकते हैं।

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

// your blob of binary as a byte array
byte[] blob = "someBinaryData".getBytes();

// use the Base64 class to encode
String binaryAsAString = Base64.encodeBase64String(blob);

// use the Base64 class to decode
byte[] blob2 = Base64.decodeBase64(binaryAsAString);

// assert that the two blobs are equal
System.out.println("Equal : " + Boolean.toString(Arrays.equals(blob, blob2)));

यदि आप चल रहे इस प्रोग्राम का निरीक्षण करते हैं, तो आप देखेंगे कि someBinaryData c29tZUJpbmFyeURhdGE= , बहुत प्रबंधनीय UTF-8 स्ट्रिंग ऑब्जेक्ट को एन्कोड करता है।

// encode with padding
String encoded = Base64.getEncoder().encodeToString(someByteArray);

// encode without padding
String encoded = Base64.getEncoder().withoutPadding().encodeToString(someByteArray);

// decode a String
byte [] barr = Base64.getDecoder().decode(encoded); 

एक न्यूमेरिकल वैल्यू के लिए स्ट्रिंग्स को पार्स करना

एक आदिम संख्यात्मक प्रकार या एक संख्यात्मक आवरण प्रकार के लिए स्ट्रिंग:

प्रत्येक न्यूमेरिक रैपर क्लास एक parseXxx विधि प्रदान करता है जो String को संबंधित आदिम प्रकार में परिवर्तित करता है। निम्न कोड एक String को Integer.parseInt पद्धति का उपयोग करके एक int परिवर्तित करता है:

String string = "59";
int primitive = Integer.parseInteger(string);

एक में बदलने के लिए String एक अंकीय आवरण वर्ग या तो आप आवरण वर्गों की एक अधिभार उपयोग कर सकते हैं का एक उदाहरण के लिए valueOf विधि:

String string = "59";
Integer wrapper = Integer.valueOf(string);

या ऑटो मुक्केबाजी पर निर्भर (जावा 5 और बाद में):

String string = "59";
Integer wrapper = Integer.parseInteger(string);  // 'int' result is autoboxed

उपरोक्त पैटर्न byte , short , int , long , float और double और संबंधित रैपर क्लास ( Byte , Short , Integer , Long , Float और Double ) के लिए काम करता है।

मूलांक का उपयोग करके पूर्णांक तक स्ट्रिंग:

String integerAsString = "0101"; // binary representation
int parseInt = Integer.parseInt(integerAsString,2);
Integer valueOfInteger = Integer.valueOf(integerAsString,2);
System.out.println(valueOfInteger); // prints 5 
System.out.println(parseInt); // prints 5 

अपवाद

यदि कोई संख्यात्मक parseXxx(...) valueOf(String) या parseXxx(...) विधि को एक स्ट्रिंग के लिए कहा जाता है जो स्वीकार्य सांख्यिक प्रतिनिधित्व नहीं है, या जो उस मान को दर्शाता है जो सीमा से बाहर है, तो parseXxx(...) NumberFormatException अपवाद को फेंक दिया जाएगा।

एक `इनपुटस्ट्रीम` से` स्ट्रिंग` प्राप्त करना

एक String बाइट सरणी कंस्ट्रक्टर का उपयोग करके एक InputStream से पढ़ा जा सकता है।

import java.io.*;

public String readString(InputStream input) throws IOException {
    byte[] bytes = new byte[50]; // supply the length of the string in bytes here
    input.read(bytes);
    return new String(bytes);
}

यह सिस्टम डिफ़ॉल्ट चारसेट का उपयोग करता है, हालांकि एक वैकल्पिक चारसेट निर्दिष्ट किया जा सकता है:

return new String(bytes, Charset.forName("UTF-8"));

स्ट्रिंग को अन्य डेटाटाइप में परिवर्तित करना।

आप एक संख्यात्मक स्ट्रिंग को विभिन्न जावा संख्यात्मक प्रकारों में परिवर्तित कर सकते हैं:

स्ट्रिंग करने के लिए int:

String number = "12";
int num = Integer.parseInt(number);

स्ट्रिंग फ्लोट करने के लिए:

String number = "12.0";
float num = Float.parseFloat(number);

स्ट्रिंग टू डबल:

String double = "1.47";
double num = Double.parseDouble(double);

स्ट्रिंग टू बूलियन:

String falseString = "False";
boolean falseBool = Boolean.parseBoolean(falseString);   // falseBool = false 
    
String trueString = "True";
boolean trueBool = Boolean.parseBoolean(trueString);     // trueBool = true

लंबे समय तक स्ट्रिंग:

String number = "47";
long num = Long.parseLong(number);

स्ट्रिंग करने के लिए BigInteger:

String bigNumber = "21";
BigInteger reallyBig = new BigInteger(bigNumber);

स्ट्रिंग करने के लिए BigDecimal:

String bigFraction = "17.21455";
BigDecimal reallyBig = new BigDecimal(bigFraction);

रूपांतरण अपवाद:

यदि आप एक स्ट्रिंग को पार्स करने का प्रयास करते हैं, जो एक उपयुक्त स्वरूपित संख्या नहीं है, या लक्ष्य प्रकार के लिए सीमा से बाहर है, तो ऊपर दिए गए संख्यात्मक रूपांतरण सभी एक (अनियंत्रित) NumberFormatException फेंक देंगे। अपवाद विषय में इस तरह के अपवादों से निपटने के तरीके पर चर्चा की गई है।

यदि आप परीक्षण करना चाहते हैं कि आप एक स्ट्रिंग को पार्स कर सकते हैं, तो आप एक tryParse... को लागू कर सकते हैं tryParse... इस तरह की विधि:

boolean tryParseInt (String value) {  
    try {  
        String somechar = Integer.parseInt(value);
        return true;  
     } catch (NumberFormatException e) { 
        return false;  
     }  
}

हालाँकि, इस tryParse... कॉल tryParse... पार्स करने से ठीक पहले विधि (यकीनन) खराब अभ्यास है। बेहतर होगा कि आप केवल parse... पद्धति को कॉल करें और अपवाद से निपटें।