జావాలో పూర్ణాంకాన్ని స్ట్రింగ్‌గా మార్చడం ఎలా

ఈ ఆర్టికల్‌లో పూర్ణాంకం (ప్రిమిటివ్ టైప్) మరియు ఆబ్జెక్ట్ టైప్ (ర్యాపర్) పూర్ణాంకాలను స్ట్రింగ్‌గా మార్చడం గురించి చర్చించబోతున్నాం. జావాలో దీన్ని చేయడానికి చాలా మార్గాలు ఉన్నాయి.

జావాలో పూర్ణాంకాన్ని స్ట్రింగ్‌గా మార్చడం ఎలా

ఖాళీ స్ట్రింగ్‌ని జోడించడం ద్వారా మార్చండి.

Intని స్ట్రింగ్‌గా మార్చడానికి సులభమైన మార్గం చాలా సులభం. పూర్ణాంకానికి లేదా పూర్ణాంకానికి ఒక ఖాళీ స్ట్రింగ్ ""ని జోడించండి మరియు మీరు మీ పూర్ణాంకాన్ని స్ట్రింగ్‌గా పొందుతారు. పూర్ణాంక మరియు స్ట్రింగ్ జోడించడం వలన మీకు కొత్త స్ట్రింగ్ వస్తుంది కాబట్టి ఇది జరుగుతుంది. అంటే మీరు కలిగి ఉంటే int x = 5, నిర్వచించండి x + ""మరియు మీరు మీ కొత్త స్ట్రింగ్‌ను పొందుతారు.

ఇక్కడ ఒక ఉదాహరణ:
```
//  converting int to string, Java 
public class Demo {
   public static void main(String[] args) {

       int x = 5;
       //  java int to string
       String xText = x + "";
       //  the result output
       System.out.println("convert int to String, Java: " + xText);
       //  the int output
       System.out.println("our int: " + x);
       //  adding int and String gives the new String
       System.out.println("adding int = 5 and String = \"5\". The result is a new String = " + xText + x);
       //  integer to string, Java code
       Integer y = 7;
       String yText = y + "";
       System.out.println("convert Integer to String: " + yText);
       System.out.println("our Integer: " + y);
       System.out.println("adding Integer = 7 and String = \"7\". The result is a new String = " + y + yText);
   }
}
```
అవుట్‌పుట్:
```
convert int to String, Java: 5
our int: 5
adding int = 5 and String = "5". The result is a new String = 55
convert Integer to String: 7
our Integer: 7
adding Integer = 7 and String = "7". The result is a new String = 77
```

Java Integer.toString(int)ని ఉపయోగించి పూర్ణాంకాన్ని స్ట్రింగ్‌గా మారుస్తుంది

ఆబ్జెక్ట్ క్లాస్ అనేది జావాలో రూట్ క్లాస్. అంటే ప్రతి జావా క్లాస్ ప్రత్యక్షంగా లేదా పరోక్షంగా ఆబ్జెక్ట్ క్లాస్ నుండి సంక్రమిస్తుంది మరియు అన్ని జావా క్లాస్‌లకు అన్ని ఆబ్జెక్ట్ క్లాస్ పద్ధతులు అందుబాటులో ఉంటాయి.

ఏదైనా వస్తువును స్ట్రింగ్‌గా సూచించడానికి ఆబ్జెక్ట్‌కు స్ట్రింగ్()కి ప్రత్యేక పద్ధతి ఉంది. కాబట్టి, ప్రతి జావా తరగతి కూడా ఈ పద్ధతిని వారసత్వంగా పొందుతుంది. అయితే తగిన ఫలితం పొందడానికి మీ స్వంత తరగతులలో ఈ పద్ధతిని భర్తీ చేయడం మంచి ఆలోచన.

పూర్ణాంక తరగతి' toString() పద్ధతి పేర్కొన్న int లేదా Integer పరామితిని సూచించే స్ట్రింగ్ ఆబ్జెక్ట్‌ను అందిస్తుంది.

దీని సింటాక్స్:


public static String toString(int i)

పద్ధతి వాదన iని మారుస్తుంది మరియు దానిని స్ట్రింగ్ ఉదాహరణగా అందిస్తుంది. సంఖ్య ప్రతికూలంగా ఉంటే, గుర్తు ఉంచబడుతుంది.

ఉదాహరణ:


//  java integer to string using toString method

public class Demo {
   public static void main(String[] args) {

       int x = -5;
       //  java convert int to string using Integer.toString
       String xText = Integer.toString(x);
       //  the result output
       System.out.println("convert int to String: " + xText);
       //  the int output
       System.out.println("our int: " + x);
       //  adding int and String gives the new String
       System.out.println("converting int = -5 and adding to String = \"-5\". The result is a new String = " + xText + Integer.toString(x));


   }
}


convert int to String: -5
our int: -5
converting int = -5 and adding to String = "-5". The result is a new String = -5-5

మీరు పూర్ణాంకం (ర్యాపర్ రకం)ని కూడా మార్చడానికి toString పద్ధతిని ఉపయోగించవచ్చు.


Integer number = -7;
String numberAsString = Integer.toString(number);
System.out.println("convert Integer to String: " + numberAsString);

ఫలితం:

పూర్ణాంకాన్ని స్ట్రింగ్‌గా మార్చండి: -7

Integer.toString method toString(int i, int base)మీరు స్ట్రింగ్ కంటే బేస్ బేస్‌తో సంఖ్య i యొక్క స్ట్రింగ్ ప్రాతినిధ్యాన్ని అందించే ప్రత్యేకతను ఉపయోగించవచ్చు . ఉదాహరణకి

వాక్యనిర్మాణం:


public static String toString(int i, int base)

ఇక్కడ ఒక ఉదాహరణ:


int a = 255;
//  binary
String customString = Integer.toString(a, 2);
System.out.println(customString);

అవుట్‌పుట్ దశాంశ సంఖ్య 255 యొక్క స్ట్రింగ్ బైనరీ ప్రాతినిధ్యం:

11111111

String.valueOf(int)ని ఉపయోగించి పూర్ణాంకాన్ని స్ట్రింగ్‌గా మార్చండి

మెథడ్ String.valueOf(int)పూర్ణాంక ఆర్గ్యుమెంట్ యొక్క స్ట్రింగ్ ప్రాతినిధ్యాన్ని అందిస్తుంది.

పద్ధతి యొక్క వాక్యనిర్మాణం:
```
public static String valueOf(int i)
```
జావాను స్ట్రింగ్‌గా మార్చడానికి ఇక్కడ ఒక ఉదాహరణ ఉంది String.valueOf(int):
```
public class Demo {
   public static void main(String[] args) {
       int z = -5;
       //  Java int to String converting 
 String zText = String.valueOf(z); 
       //  the result output
       System.out.println("convert int to String: " + zText);
       //  the int output
       System.out.println("our int: " + z);
       //  adding int and String gives the new String
       System.out.println("converting int = -5 and adding to String = \"-5\". The result is a new String = " + zText + z);
   }
}
```
```
convert int to String: -5
our int: -5
converting int = -5 and adding to String = "-5". The result is a new String = -5-5
```
మీరు పూర్ణాంకం (పూర్తి యొక్క రేపర్ రకం)తో కూడా చేయవచ్చు:
```
Integer number = -7;
String numberAsString = String.valueOf(number);
System.out.println("convert Integer to String: " + numberAsString);
```
అవుట్‌పుట్ ఇలా ఉంటుంది:

పూర్ణాంకాన్ని స్ట్రింగ్‌గా మార్చండి: -7
డెసిమల్ ఫార్మాట్ ఉపయోగించి మార్చండి

java.text.DecimalFormatప్యాకేజీలో నిర్వచించబడిన తరగతి java.textమరియు ఉపవర్గం NumberFormat. ఇది ఒక నిర్దిష్ట నమూనాను అనుసరించే స్ట్రింగ్‌కు దశాంశ సంఖ్యను ఫార్మాట్ చేయడానికి ఉపయోగించబడుతుంది. మేము దీనిని పూర్ణాంకాల కోసం కూడా ఉపయోగించవచ్చు.

ఉదాహరణ:
```
import java.text.DecimalFormat;
public class Demo {
   public static void main(String[] args) {
       int myNumber = 31415;
       DecimalFormat decimalFormat = new DecimalFormat("#");
       String myNumberAsString = decimalFormat.format(myNumber);
       System.out.println(myNumberAsString);
   }
}
```
అవుట్‌పుట్:
```
31415
```
String.format()ని ఉపయోగించి మార్చండి

String.format() అనేది పూర్ణాంకాన్ని స్ట్రింగ్ ఆబ్జెక్ట్‌గా మార్చడానికి మరొక మార్గం.

వాక్యనిర్మాణం
```
public static String format(String format, Object... args)
```
ఉదాహరణ
```
public class Demo {
   public static void main(String[] args) {
       int myNumber = 35;
       String myNumberAsString = String.format("%d", myNumber);  //  %d converter defines a single decimal integer variable.
       System.out.println(myNumberAsString);
   }
}
```
అవుట్‌పుట్:
```
35
```

మరింత పఠనం:
జావాలో స్ట్రింగ్‌ను పూర్ణాంకానికి ఎలా మార్చాలి జావాలో లాంగ్‌ను పూర్ణాంకానికి ఎలా మార్చాలి